/*
 * Interface wrapper code.
 *
 * Generated by SIP 4.19.6
 */

#include "sipAPIKConfigCore.h"

#include <kconfiggroup.h>

#include <qbytearray.h>
#include <kconfigbase.h>
#include <qmap.h>
#include <qstring.h>
#include <qstringlist.h>
#include <qvariant.h>
#include <qlist.h>
#include <kconfigbase.h>
#include <kconfig.h>


class sipKConfigGroup : public  ::KConfigGroup
{
public:
    sipKConfigGroup();
    sipKConfigGroup(const  ::KConfigGroup&);
    virtual ~sipKConfigGroup();

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    void sipProtectVirt_virtual_hook(bool,int,void*);
    bool sipProtectVirt_hasGroupImpl(bool,const  ::QByteArray&) const;
    const  ::KConfigGroup sipProtectVirt_groupImpl(bool,const  ::QByteArray&) const;
    void sipProtectVirt_deleteGroupImpl(bool,const  ::QByteArray&, ::KConfigBase::WriteConfigFlags);
    bool sipProtectVirt_isGroupImmutableImpl(bool,const  ::QByteArray&) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    const  ::KConfigGroup groupImpl(const  ::QByteArray&) const;
     ::QStringList groupList() const;
    bool sync();
    void markAsClean();
     ::KConfigBase::AccessMode accessMode() const;
    bool isImmutable() const;
    bool hasGroupImpl(const  ::QByteArray&) const;
    void deleteGroupImpl(const  ::QByteArray&, ::KConfigBase::WriteConfigFlags);
    bool isGroupImmutableImpl(const  ::QByteArray&) const;
    void virtual_hook(int,void*);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipKConfigGroup(const sipKConfigGroup &);
    sipKConfigGroup &operator = (const sipKConfigGroup &);

    char sipPyMethods[10];
};

sipKConfigGroup::sipKConfigGroup():  ::KConfigGroup(), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipKConfigGroup::sipKConfigGroup(const  ::KConfigGroup& a0):  ::KConfigGroup(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipKConfigGroup::~sipKConfigGroup()
{
    sipInstanceDestroyed(sipPySelf);
}

const  ::KConfigGroup sipKConfigGroup::groupImpl(const  ::QByteArray& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[0]),sipPySelf,NULL,sipName_groupImpl);

    if (!sipMeth)
        return  ::KConfigGroup::groupImpl(a0);

    extern const  ::KConfigGroup sipVH_KConfigCore_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QByteArray&);

    return sipVH_KConfigCore_8(sipGILState, sipImportedVirtErrorHandlers_KConfigCore_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

 ::QStringList sipKConfigGroup::groupList() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[1]),sipPySelf,NULL,sipName_groupList);

    if (!sipMeth)
        return  ::KConfigGroup::groupList();

    extern  ::QStringList sipVH_KConfigCore_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_KConfigCore_0(sipGILState, sipImportedVirtErrorHandlers_KConfigCore_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

bool sipKConfigGroup::sync()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_sync);

    if (!sipMeth)
        return  ::KConfigGroup::sync();

    extern bool sipVH_KConfigCore_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_KConfigCore_1(sipGILState, sipImportedVirtErrorHandlers_KConfigCore_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

void sipKConfigGroup::markAsClean()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_markAsClean);

    if (!sipMeth)
    {
         ::KConfigGroup::markAsClean();
        return;
    }

    extern void sipVH_KConfigCore_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_KConfigCore_2(sipGILState, sipImportedVirtErrorHandlers_KConfigCore_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

 ::KConfigBase::AccessMode sipKConfigGroup::accessMode() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[4]),sipPySelf,NULL,sipName_accessMode);

    if (!sipMeth)
        return  ::KConfigGroup::accessMode();

    extern  ::KConfigBase::AccessMode sipVH_KConfigCore_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_KConfigCore_3(sipGILState, sipImportedVirtErrorHandlers_KConfigCore_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

bool sipKConfigGroup::isImmutable() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[5]),sipPySelf,NULL,sipName_isImmutable);

    if (!sipMeth)
        return  ::KConfigGroup::isImmutable();

    extern bool sipVH_KConfigCore_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_KConfigCore_1(sipGILState, sipImportedVirtErrorHandlers_KConfigCore_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

bool sipKConfigGroup::hasGroupImpl(const  ::QByteArray& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[6]),sipPySelf,NULL,sipName_hasGroupImpl);

    if (!sipMeth)
        return  ::KConfigGroup::hasGroupImpl(a0);

    extern bool sipVH_KConfigCore_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QByteArray&);

    return sipVH_KConfigCore_4(sipGILState, sipImportedVirtErrorHandlers_KConfigCore_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

void sipKConfigGroup::deleteGroupImpl(const  ::QByteArray& a0, ::KConfigBase::WriteConfigFlags a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,NULL,sipName_deleteGroupImpl);

    if (!sipMeth)
    {
         ::KConfigGroup::deleteGroupImpl(a0,a1);
        return;
    }

    extern void sipVH_KConfigCore_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QByteArray&, ::KConfigBase::WriteConfigFlags);

    sipVH_KConfigCore_6(sipGILState, sipImportedVirtErrorHandlers_KConfigCore_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

bool sipKConfigGroup::isGroupImmutableImpl(const  ::QByteArray& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[8]),sipPySelf,NULL,sipName_isGroupImmutableImpl);

    if (!sipMeth)
        return  ::KConfigGroup::isGroupImmutableImpl(a0);

    extern bool sipVH_KConfigCore_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QByteArray&);

    return sipVH_KConfigCore_4(sipGILState, sipImportedVirtErrorHandlers_KConfigCore_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

void sipKConfigGroup::virtual_hook(int a0,void*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[9],sipPySelf,NULL,sipName_virtual_hook);

    if (!sipMeth)
    {
         ::KConfigGroup::virtual_hook(a0,a1);
        return;
    }

    extern void sipVH_KConfigCore_7(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,void*);

    sipVH_KConfigCore_7(sipGILState, sipImportedVirtErrorHandlers_KConfigCore_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

void sipKConfigGroup::sipProtectVirt_virtual_hook(bool sipSelfWasArg,int a0,void*a1)
{
    (sipSelfWasArg ?  ::KConfigBase::virtual_hook(a0,a1) : virtual_hook(a0,a1));
}

bool sipKConfigGroup::sipProtectVirt_hasGroupImpl(bool sipSelfWasArg,const  ::QByteArray& a0) const
{
    return (sipSelfWasArg ?  ::KConfigGroup::hasGroupImpl(a0) : hasGroupImpl(a0));
}

const  ::KConfigGroup sipKConfigGroup::sipProtectVirt_groupImpl(bool sipSelfWasArg,const  ::QByteArray& a0) const
{
    return (sipSelfWasArg ?  ::KConfigGroup::groupImpl(a0) : groupImpl(a0));
}

void sipKConfigGroup::sipProtectVirt_deleteGroupImpl(bool sipSelfWasArg,const  ::QByteArray& a0, ::KConfigBase::WriteConfigFlags a1)
{
    (sipSelfWasArg ?  ::KConfigGroup::deleteGroupImpl(a0,a1) : deleteGroupImpl(a0,a1));
}

bool sipKConfigGroup::sipProtectVirt_isGroupImmutableImpl(bool sipSelfWasArg,const  ::QByteArray& a0) const
{
    return (sipSelfWasArg ?  ::KConfigGroup::isGroupImmutableImpl(a0) : isGroupImmutableImpl(a0));
}


extern "C" {static PyObject *meth_KConfigGroup_virtual_hook(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_virtual_hook(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        void* a1;
        sipKConfigGroup *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Biv", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, &a1))
        {
            sipCpp->sipProtectVirt_virtual_hook(sipSelfWasArg,a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_virtual_hook, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_isValid(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_isValid(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_KConfigGroup, &sipCpp))
        {
            bool sipRes;

            sipRes = sipCpp->isValid();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_isValid, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_name(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_name(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_KConfigGroup, &sipCpp))
        {
             ::QString*sipRes;

            sipRes = new  ::QString(sipCpp->name());

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_name, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_exists(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_exists(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_KConfigGroup, &sipCpp))
        {
            bool sipRes;

            sipRes = sipCpp->exists();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_exists, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_sync(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_sync(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_KConfigGroup, &sipCpp))
        {
            bool sipRes;

            sipRes = (sipSelfWasArg ? sipCpp-> ::KConfigGroup::sync() : sipCpp->sync());

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_sync, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_markAsClean(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_markAsClean(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_KConfigGroup, &sipCpp))
        {
            (sipSelfWasArg ? sipCpp-> ::KConfigGroup::markAsClean() : sipCpp->markAsClean());

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_markAsClean, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_accessMode(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_accessMode(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_KConfigGroup, &sipCpp))
        {
             ::KConfigBase::AccessMode sipRes;

            sipRes = (sipSelfWasArg ? sipCpp-> ::KConfigGroup::accessMode() : sipCpp->accessMode());

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_KConfigBase_AccessMode);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_accessMode, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_config(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_config(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_KConfigGroup, &sipCpp))
        {
             ::KConfig*sipRes;

            sipRes = sipCpp->config();

            return sipConvertFromType(sipRes,sipType_KConfig,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_config, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_changeGroup(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_changeGroup(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->changeGroup(*a0);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bs", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0))
        {
            sipCpp->changeGroup(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_changeGroup, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_copyTo(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_copyTo(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::KConfigBase* a0;
         ::KConfigBase::WriteConfigFlags a1def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a1 = &a1def;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_KConfigBase, &a0, sipType_KConfigBase_WriteConfigFlags, &a1, &a1State))
        {
            sipCpp->copyTo(a0,*a1);
            sipReleaseType(a1,sipType_KConfigBase_WriteConfigFlags,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_copyTo, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_reparent(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_reparent(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::KConfigBase* a0;
         ::KConfigBase::WriteConfigFlags a1def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a1 = &a1def;
        int a1State = 0;
        sipWrapper *sipOwner = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJH|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_KConfigBase, &a0, &sipOwner, sipType_KConfigBase_WriteConfigFlags, &a1, &a1State))
        {
            sipCpp->reparent(a0,*a1);

            if (sipOwner)
                sipTransferTo(sipSelf, (PyObject *)sipOwner);
            else
                sipTransferBack(sipSelf);
            sipReleaseType(a1,sipType_KConfigBase_WriteConfigFlags,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_reparent, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_groupList(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_groupList(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_KConfigGroup, &sipCpp))
        {
             ::QStringList*sipRes;

            sipRes = new  ::QStringList((sipSelfWasArg ? sipCpp-> ::KConfigGroup::groupList() : sipCpp->groupList()));

            return sipConvertFromNewType(sipRes,sipType_QStringList,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_groupList, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_keyList(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_keyList(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_KConfigGroup, &sipCpp))
        {
             ::QStringList*sipRes;

            sipRes = new  ::QStringList(sipCpp->keyList());

            return sipConvertFromNewType(sipRes,sipType_QStringList,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_keyList, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_deleteGroup(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_deleteGroup(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::KConfigBase::WriteConfigFlags a0def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a0 = &a0def;
        int a0State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_KConfigBase_WriteConfigFlags, &a0, &a0State))
        {
            sipCpp->deleteGroup(*a0);
            sipReleaseType(a0,sipType_KConfigBase_WriteConfigFlags,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_deleteGroup, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_readEntry(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_readEntry(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QVariant* a1;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QVariant, &a1, &a1State))
        {
             ::QVariant*sipRes;

            sipRes = new  ::QVariant(sipCpp->readEntry(*a0,*a1));
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QVariant *>(a1),sipType_QVariant,a1State);

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    {
        const char* a0;
        const  ::QVariant* a1;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BsJ1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QVariant, &a1, &a1State))
        {
             ::QVariant*sipRes;

            sipRes = new  ::QVariant(sipCpp->readEntry(a0,*a1));
            sipReleaseType(const_cast< ::QVariant *>(a1),sipType_QVariant,a1State);

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QString* a1;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QString,&a1, &a1State))
        {
             ::QString*sipRes;

            sipRes = new  ::QString(sipCpp->readEntry(*a0,*a1));
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    {
        const char* a0;
        const  ::QString* a1;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BsJ1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QString,&a1, &a1State))
        {
             ::QString*sipRes;

            sipRes = new  ::QString(sipCpp->readEntry(a0,*a1));
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
        const char* a1 = nullptr;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1|s", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, &a1))
        {
             ::QString*sipRes;

            sipRes = new  ::QString(sipCpp->readEntry(*a0,a1));
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    {
        const char* a0;
        const char* a1 = nullptr;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bs|s", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, &a1))
        {
             ::QString*sipRes;

            sipRes = new  ::QString(sipCpp->readEntry(a0,a1));

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
        const QList< ::QVariant>* a1;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QList_0100QVariant,&a1, &a1State))
        {
             ::QVariantList*sipRes;

            sipRes = new  ::QVariantList(sipCpp->readEntry(*a0,*a1));
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast<QList< ::QVariant> *>(a1),sipType_QList_0100QVariant,a1State);

            return sipConvertFromNewType(sipRes,sipType_QList_0100QVariant,NULL);
        }
    }

    {
        const char* a0;
        const QList< ::QVariant>* a1;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BsJ1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QList_0100QVariant,&a1, &a1State))
        {
             ::QVariantList*sipRes;

            sipRes = new  ::QVariantList(sipCpp->readEntry(a0,*a1));
            sipReleaseType(const_cast<QList< ::QVariant> *>(a1),sipType_QList_0100QVariant,a1State);

            return sipConvertFromNewType(sipRes,sipType_QList_0100QVariant,NULL);
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QStringList* a1;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QStringList,&a1, &a1State))
        {
             ::QStringList*sipRes;

            sipRes = new  ::QStringList(sipCpp->readEntry(*a0,*a1));
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QStringList *>(a1),sipType_QStringList,a1State);

            return sipConvertFromNewType(sipRes,sipType_QStringList,NULL);
        }
    }

    {
        const char* a0;
        const  ::QStringList* a1;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BsJ1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QStringList,&a1, &a1State))
        {
             ::QStringList*sipRes;

            sipRes = new  ::QStringList(sipCpp->readEntry(a0,*a1));
            sipReleaseType(const_cast< ::QStringList *>(a1),sipType_QStringList,a1State);

            return sipConvertFromNewType(sipRes,sipType_QStringList,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_readEntry, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_readXdgListEntry(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_readXdgListEntry(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QStringList& a1def = QStringList();
        const  ::QStringList* a1 = &a1def;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QStringList,&a1, &a1State))
        {
             ::QStringList*sipRes;

            sipRes = new  ::QStringList(sipCpp->readXdgListEntry(*a0,*a1));
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QStringList *>(a1),sipType_QStringList,a1State);

            return sipConvertFromNewType(sipRes,sipType_QStringList,NULL);
        }
    }

    {
        const char* a0;
        const  ::QStringList& a1def = QStringList();
        const  ::QStringList* a1 = &a1def;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bs|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QStringList,&a1, &a1State))
        {
             ::QStringList*sipRes;

            sipRes = new  ::QStringList(sipCpp->readXdgListEntry(a0,*a1));
            sipReleaseType(const_cast< ::QStringList *>(a1),sipType_QStringList,a1State);

            return sipConvertFromNewType(sipRes,sipType_QStringList,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_readXdgListEntry, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_readPathEntry(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_readPathEntry(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QString* a1;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QString,&a1, &a1State))
        {
             ::QString*sipRes;

            sipRes = new  ::QString(sipCpp->readPathEntry(*a0,*a1));
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    {
        const char* a0;
        const  ::QString* a1;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BsJ1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QString,&a1, &a1State))
        {
             ::QString*sipRes;

            sipRes = new  ::QString(sipCpp->readPathEntry(a0,*a1));
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QStringList* a1;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QStringList,&a1, &a1State))
        {
             ::QStringList*sipRes;

            sipRes = new  ::QStringList(sipCpp->readPathEntry(*a0,*a1));
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QStringList *>(a1),sipType_QStringList,a1State);

            return sipConvertFromNewType(sipRes,sipType_QStringList,NULL);
        }
    }

    {
        const char* a0;
        const  ::QStringList* a1;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BsJ1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QStringList,&a1, &a1State))
        {
             ::QStringList*sipRes;

            sipRes = new  ::QStringList(sipCpp->readPathEntry(a0,*a1));
            sipReleaseType(const_cast< ::QStringList *>(a1),sipType_QStringList,a1State);

            return sipConvertFromNewType(sipRes,sipType_QStringList,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_readPathEntry, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_readEntryUntranslated(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_readEntryUntranslated(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QString& a1def = QString();
        const  ::QString* a1 = &a1def;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QString,&a1, &a1State))
        {
             ::QString*sipRes;

            sipRes = new  ::QString(sipCpp->readEntryUntranslated(*a0,*a1));
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    {
        const char* a0;
        const  ::QString& a1def = QString();
        const  ::QString* a1 = &a1def;
        int a1State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bs|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QString,&a1, &a1State))
        {
             ::QString*sipRes;

            sipRes = new  ::QString(sipCpp->readEntryUntranslated(a0,*a1));
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_readEntryUntranslated, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_writeEntry(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_writeEntry(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QVariant* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QVariant, &a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writeEntry(*a0,*a1,*a2);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QVariant *>(a1),sipType_QVariant,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        const  ::QVariant* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BsJ1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QVariant, &a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writeEntry(a0,*a1,*a2);
            sipReleaseType(const_cast< ::QVariant *>(a1),sipType_QVariant,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QString* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QString,&a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writeEntry(*a0,*a1,*a2);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        const  ::QString* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BsJ1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QString,&a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writeEntry(a0,*a1,*a2);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QByteArray* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QByteArray, &a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writeEntry(*a0,*a1,*a2);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QByteArray *>(a1),sipType_QByteArray,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        const  ::QByteArray* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BsJ1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QByteArray, &a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writeEntry(a0,*a1,*a2);
            sipReleaseType(const_cast< ::QByteArray *>(a1),sipType_QByteArray,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
        const char* a1;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1s|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, &a1, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writeEntry(*a0,a1,*a2);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        const char* a1;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bss|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, &a1, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writeEntry(a0,a1,*a2);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QStringList* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QStringList,&a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writeEntry(*a0,*a1,*a2);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QStringList *>(a1),sipType_QStringList,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        const  ::QStringList* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BsJ1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QStringList,&a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writeEntry(a0,*a1,*a2);
            sipReleaseType(const_cast< ::QStringList *>(a1),sipType_QStringList,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
        const QList< ::QVariant>* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QList_0100QVariant,&a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writeEntry(*a0,*a1,*a2);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast<QList< ::QVariant> *>(a1),sipType_QList_0100QVariant,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        const QList< ::QVariant>* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BsJ1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QList_0100QVariant,&a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writeEntry(a0,*a1,*a2);
            sipReleaseType(const_cast<QList< ::QVariant> *>(a1),sipType_QList_0100QVariant,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_writeEntry, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_writeXdgListEntry(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_writeXdgListEntry(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QStringList* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QStringList,&a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writeXdgListEntry(*a0,*a1,*a2);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QStringList *>(a1),sipType_QStringList,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        const  ::QStringList* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BsJ1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QStringList,&a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writeXdgListEntry(a0,*a1,*a2);
            sipReleaseType(const_cast< ::QStringList *>(a1),sipType_QStringList,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_writeXdgListEntry, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_writePathEntry(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_writePathEntry(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QString* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QString,&a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writePathEntry(*a0,*a1,*a2);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        const  ::QString* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BsJ1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QString,&a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writePathEntry(a0,*a1,*a2);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QStringList* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_QStringList,&a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writePathEntry(*a0,*a1,*a2);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QStringList *>(a1),sipType_QStringList,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        const  ::QStringList* a1;
        int a1State = 0;
         ::KConfigBase::WriteConfigFlags a2def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a2 = &a2def;
        int a2State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BsJ1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_QStringList,&a1, &a1State, sipType_KConfigBase_WriteConfigFlags, &a2, &a2State))
        {
            sipCpp->writePathEntry(a0,*a1,*a2);
            sipReleaseType(const_cast< ::QStringList *>(a1),sipType_QStringList,a1State);
            sipReleaseType(a2,sipType_KConfigBase_WriteConfigFlags,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_writePathEntry, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_deleteEntry(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_deleteEntry(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
         ::KConfigBase::WriteConfigFlags a1def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a1 = &a1def;
        int a1State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State, sipType_KConfigBase_WriteConfigFlags, &a1, &a1State))
        {
            sipCpp->deleteEntry(*a0,*a1);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(a1,sipType_KConfigBase_WriteConfigFlags,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
         ::KConfigBase::WriteConfigFlags a1def = KConfigBase::Normal;
         ::KConfigBase::WriteConfigFlags* a1 = &a1def;
        int a1State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bs|J1", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0, sipType_KConfigBase_WriteConfigFlags, &a1, &a1State))
        {
            sipCpp->deleteEntry(a0,*a1);
            sipReleaseType(a1,sipType_KConfigBase_WriteConfigFlags,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_deleteEntry, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_hasKey(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_hasKey(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            sipRes = sipCpp->hasKey(*a0);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    {
        const char* a0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bs", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->hasKey(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_hasKey, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_isImmutable(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_isImmutable(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_KConfigGroup, &sipCpp))
        {
            bool sipRes;

            sipRes = (sipSelfWasArg ? sipCpp-> ::KConfigGroup::isImmutable() : sipCpp->isImmutable());

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_isImmutable, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_isEntryImmutable(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_isEntryImmutable(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            sipRes = sipCpp->isEntryImmutable(*a0);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    {
        const char* a0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bs", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->isEntryImmutable(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_isEntryImmutable, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_revertToDefault(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_revertToDefault(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->revertToDefault(*a0);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
         ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bs", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0))
        {
            sipCpp->revertToDefault(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_revertToDefault, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_hasDefault(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_hasDefault(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            sipRes = sipCpp->hasDefault(*a0);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    {
        const char* a0;
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bs", &sipSelf, sipType_KConfigGroup, &sipCpp, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->hasDefault(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_hasDefault, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_entryMap(PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_entryMap(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::KConfigGroup *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_KConfigGroup, &sipCpp))
        {
            QMap< ::QString, ::QString>*sipRes;

            sipRes = new QMap< ::QString, ::QString>(sipCpp->entryMap());

            return sipConvertFromNewType(sipRes,sipType_QMap_0100QString_0100QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_entryMap, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_hasGroupImpl(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_hasGroupImpl(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QByteArray* a0;
        int a0State = 0;
        const sipKConfigGroup *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QByteArray, &a0, &a0State))
        {
            bool sipRes;

            sipRes = sipCpp->sipProtectVirt_hasGroupImpl(sipSelfWasArg,*a0);
            sipReleaseType(const_cast< ::QByteArray *>(a0),sipType_QByteArray,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_hasGroupImpl, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_groupImpl(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_groupImpl(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QByteArray* a0;
        int a0State = 0;
        const sipKConfigGroup *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QByteArray, &a0, &a0State))
        {
             ::KConfigGroup*sipRes;

            sipRes = new  ::KConfigGroup(sipCpp->sipProtectVirt_groupImpl(sipSelfWasArg,*a0));
            sipReleaseType(const_cast< ::QByteArray *>(a0),sipType_QByteArray,a0State);

            return sipConvertFromNewType(sipRes,sipType_KConfigGroup,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_groupImpl, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_deleteGroupImpl(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_deleteGroupImpl(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QByteArray* a0;
        int a0State = 0;
         ::KConfigBase::WriteConfigFlags* a1;
        int a1State = 0;
        sipKConfigGroup *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1J1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QByteArray, &a0, &a0State, sipType_KConfigBase_WriteConfigFlags, &a1, &a1State))
        {
            sipCpp->sipProtectVirt_deleteGroupImpl(sipSelfWasArg,*a0,*a1);
            sipReleaseType(const_cast< ::QByteArray *>(a0),sipType_QByteArray,a0State);
            sipReleaseType(a1,sipType_KConfigBase_WriteConfigFlags,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_deleteGroupImpl, NULL);

    return NULL;
}


extern "C" {static PyObject *meth_KConfigGroup_isGroupImmutableImpl(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_KConfigGroup_isGroupImmutableImpl(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QByteArray* a0;
        int a0State = 0;
        const sipKConfigGroup *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_KConfigGroup, &sipCpp, sipType_QByteArray, &a0, &a0State))
        {
            bool sipRes;

            sipRes = sipCpp->sipProtectVirt_isGroupImmutableImpl(sipSelfWasArg,*a0);
            sipReleaseType(const_cast< ::QByteArray *>(a0),sipType_QByteArray,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_KConfigGroup, sipName_isGroupImmutableImpl, NULL);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_KConfigGroup(void *, const sipTypeDef *);}
static void *cast_KConfigGroup(void *sipCppV, const sipTypeDef *targetType)
{
     ::KConfigGroup *sipCpp = reinterpret_cast< ::KConfigGroup *>(sipCppV);

    if (targetType == sipType_KConfigBase)
        return static_cast< ::KConfigBase *>(sipCpp);

    return sipCppV;
}


/* Call the instance's destructor. */
extern "C" {static void release_KConfigGroup(void *, int);}
static void release_KConfigGroup(void *sipCppV, int sipState)
{
    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipKConfigGroup *>(sipCppV);
    else
        delete reinterpret_cast< ::KConfigGroup *>(sipCppV);
}


extern "C" {static void assign_KConfigGroup(void *, SIP_SSIZE_T, void *);}
static void assign_KConfigGroup(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::KConfigGroup *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::KConfigGroup *>(sipSrc);
}


extern "C" {static void *array_KConfigGroup(SIP_SSIZE_T);}
static void *array_KConfigGroup(SIP_SSIZE_T sipNrElem)
{
    return new  ::KConfigGroup[sipNrElem];
}


extern "C" {static void *copy_KConfigGroup(const void *, SIP_SSIZE_T);}
static void *copy_KConfigGroup(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::KConfigGroup(reinterpret_cast<const  ::KConfigGroup *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_KConfigGroup(sipSimpleWrapper *);}
static void dealloc_KConfigGroup(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipKConfigGroup *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_KConfigGroup(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_KConfigGroup(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_KConfigGroup(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipKConfigGroup *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new sipKConfigGroup();

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::KConfigGroup* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_KConfigGroup, &a0))
        {
            sipCpp = new sipKConfigGroup(*a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_KConfigGroup[] = {{5, 255, 1}};


static PyMethodDef methods_KConfigGroup[] = {
    {SIP_MLNAME_CAST(sipName_accessMode), meth_KConfigGroup_accessMode, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_changeGroup), meth_KConfigGroup_changeGroup, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_config), meth_KConfigGroup_config, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_copyTo), meth_KConfigGroup_copyTo, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_deleteEntry), meth_KConfigGroup_deleteEntry, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_deleteGroup), meth_KConfigGroup_deleteGroup, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_deleteGroupImpl), (PyCFunction)meth_KConfigGroup_deleteGroupImpl, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_entryMap), meth_KConfigGroup_entryMap, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_exists), meth_KConfigGroup_exists, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_groupImpl), (PyCFunction)meth_KConfigGroup_groupImpl, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_groupList), meth_KConfigGroup_groupList, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_hasDefault), meth_KConfigGroup_hasDefault, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_hasGroupImpl), (PyCFunction)meth_KConfigGroup_hasGroupImpl, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_hasKey), meth_KConfigGroup_hasKey, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_isEntryImmutable), meth_KConfigGroup_isEntryImmutable, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_isGroupImmutableImpl), (PyCFunction)meth_KConfigGroup_isGroupImmutableImpl, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_isImmutable), meth_KConfigGroup_isImmutable, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_isValid), meth_KConfigGroup_isValid, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_keyList), meth_KConfigGroup_keyList, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_markAsClean), meth_KConfigGroup_markAsClean, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_name), meth_KConfigGroup_name, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_readEntry), meth_KConfigGroup_readEntry, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_readEntryUntranslated), meth_KConfigGroup_readEntryUntranslated, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_readPathEntry), meth_KConfigGroup_readPathEntry, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_readXdgListEntry), meth_KConfigGroup_readXdgListEntry, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_reparent), meth_KConfigGroup_reparent, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_revertToDefault), meth_KConfigGroup_revertToDefault, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_sync), meth_KConfigGroup_sync, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_virtual_hook), (PyCFunction)meth_KConfigGroup_virtual_hook, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_writeEntry), meth_KConfigGroup_writeEntry, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_writePathEntry), meth_KConfigGroup_writePathEntry, METH_VARARGS, NULL},
    {SIP_MLNAME_CAST(sipName_writeXdgListEntry), meth_KConfigGroup_writeXdgListEntry, METH_VARARGS, NULL}
};


static pyqt5ClassPluginDef plugin_KConfigGroup = {
    0,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_KConfigCore_KConfigGroup = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_KConfigGroup,
        {0},
        &plugin_KConfigGroup
    },
    {
        sipNameNr_KConfigGroup,
        {0, 0, 1},
        32, methods_KConfigGroup,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    0,
    -1,
    -1,
    supers_KConfigGroup,
    0,
    init_type_KConfigGroup,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_KConfigGroup,
    assign_KConfigGroup,
    array_KConfigGroup,
    copy_KConfigGroup,
    release_KConfigGroup,
    cast_KConfigGroup,
    0,
    0,
    0,
    0,
    0,
    0
};
