/*
 * ADOXEnumNames.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL9
// 2009/06/05

#pragma once

#include <sol/Object.h>
#include <sol/Arg.h>
#include <sol/ArgT.h>
#include <sol/ArgListT.h>

namespace SOL {

class ADOXEnumNames :public Object {

public:
    /**
     * Constructor
     */
    ADOXEnumNames()
    {
    }

public:
    /**
     * Destructor
     */
    ~ADOXEnumNames()
    {
    }

public:
    //2009/06/05
    const char* getName(ADOX::RuleEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adRINone",     ADOX::adRINone},
            {"adRICascade", ADOX::adRICascade},
            {"adRISetNull", ADOX::adRISetNull},
                {"adRISetDefault", ADOX::adRISetDefault},
        };

        return findName(names, XtNumber(names), type);
    }

public:
    //2009/06/05
    const char* getName(ADOX::KeyTypeEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adKeyPrimary", ADOX::adKeyPrimary},
            {"adKeyForeign", ADOX::adKeyForeign},
            {"adKeyUnique", ADOX::adKeyUnique}
        };
        return findName(names, XtNumber(names), type);

    }
public:
    //2009/06/05
    const char* getName(ADOX::ColumnAttributesEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adColFixed", ADOX::adColFixed},
            {"adColNullable", ADOX::adColNullable}
        };
        return findName(names, XtNumber(names), type);
    }
    
public:
    //2009/06/05
    const char* getName(ADOX::SortOrderEnum type)
    {
        static const ArgT<char> names[] =
        {        
            {"adSortAscending", ADOX::adSortAscending},
            {"dSortDescending", ADOX::adSortDescending}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    //2009/06/05

    const char* getName(ADOX::AllowNullsEnum type)
    {
        static const ArgT<char> names[] =
        {        
            {"adIndexNullsAllow", ADOX::adIndexNullsAllow},
            {"adIndexNullsDisallow", ADOX::adIndexNullsDisallow},
            {"adIndexNullsIgnor", ADOX::adIndexNullsIgnore},
            {"dIndexNullsIgnoreAny", ADOX::adIndexNullsIgnoreAny}
        };

        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADOX::ObjectTypeEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adPermObjProviderSpecific", ADOX::adPermObjProviderSpecific},
            {"adPermObjTable", ADOX::adPermObjTable},
            {"adPermObjColumn", ADOX::adPermObjColumn},
            {"adPermObjDatabase", ADOX::adPermObjDatabase},
            {"adPermObjProcedure", ADOX::adPermObjProcedure},
            {"adPermObjView", ADOX::adPermObjView}
        };

        return findName(names, XtNumber(names), type);
    }

    
public:
    const char* getName(ADOX::RightsEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adRightNone", ADOX::adRightNone},
            {"adRightDrop", ADOX::adRightDrop},
            {"adRightExclusive", ADOX::adRightExclusive},
            {"adRightReadDesign", ADOX::adRightReadDesign},
            {"adRightWriteDesign", ADOX::adRightWriteDesign},
            {"adRightWithGrant", ADOX::adRightWithGrant},
            {"adRightReference", ADOX::adRightReference},
            {"adRightCreate", ADOX::adRightCreate},
            {"adRightInsert", ADOX::adRightInsert},
            {"adRightDelete", ADOX::adRightDelete},
            {"adRightReadPermissions", ADOX::adRightReadPermissions},
            {"adRightWritePermissions", ADOX::adRightWritePermissions},
            {"adRightWriteOwner", ADOX::adRightWriteOwner},
            {"adRightMaximumAllowed", ADOX::adRightMaximumAllowed},
            {"adRightFull", ADOX::adRightFull},
            {"adRightExecute", ADOX::adRightExecute},
            {"adRightUpdate", ADOX::adRightUpdate},
            {"adRightRead", ADOX::adRightRead}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADOX::ActionEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adAccessGrant", ADOX::adAccessGrant},
            {"adAccessSet", ADOX::adAccessSet},
            {"adAccessDeny", ADOX::adAccessDeny},
            {"adAccessRevoke", ADOX::adAccessRevoke}
        };

        return findName(names, XtNumber(names), type);
    }

    
public:
    const char* getName(ADOX::InheritTypeEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adInheritNone", ADOX::adInheritNone},
            {"adInheritObjects", ADOX::adInheritObjects},
            {"adInheritContainers", ADOX::adInheritContainers},
            {"adInheritBoth", ADOX::adInheritBoth},
            {"adInheritNoPropogate", ADOX::adInheritNoPropogate}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADOX::DataTypeEnum type)
    {
        static const ArgT<char> names[] = {
            {"Empty",            ADOX::adEmpty},
            {"TineyInt",        ADOX::adTinyInt},
            {"SmallInt",        ADOX::adSmallInt},
            {"Integer",            ADOX::adInteger},
            {"BigInt",            ADOX::adBigInt},
            {"UnsignedTinyInt", ADOX::adUnsignedTinyInt},
            {"UnsignedSmallInt",ADOX::adUnsignedSmallInt},
            {"UnsignedIn",        ADOX::adUnsignedInt},
            {"UnsignedBigInt",    ADOX::adUnsignedBigInt},
            {"Single",            ADOX::adSingle},
            {"Double",            ADOX::adDouble},
            {"Currency",        ADOX::adCurrency},
            {"Decimal",            ADOX::adDecimal},
            {"Numeric",            ADOX::adNumeric},
            {"Boolean",            ADOX::adBoolean},
            {"Error",            ADOX::adError},
            {"UserDefined",        ADOX::adUserDefined},
            {"Variant",            ADOX::adVariant},
            {"IDispatch",        ADOX::adIDispatch},
            {"IUnknown",        ADOX::adIUnknown},
            {"GUID",            ADOX::adGUID},
            {"Date",            ADOX::adDate},
            {"DBDate",            ADOX::adDBDate},
            {"DBTime",            ADOX::adDBTime},
            {"DBTimeStamp",        ADOX::adDBTimeStamp},
            {"BSTR",            ADOX::adBSTR},
            {"Char",            ADOX::adChar},
            {"VarChar",            ADOX::adVarChar},
            {"LongVarChar",        ADOX::adLongVarChar},
            {"WChar",            ADOX::adWChar},
            {"VarWChar",        ADOX::adVarWChar},
            {"LongVarWChar",    ADOX::adLongVarWChar},
            {"Binary",            ADOX::adBinary},
            {"VarBinary",        ADOX::adVarBinary},
            {"LongVarBinary",    ADOX::adLongVarBinary},
            {"Chapter",            ADOX::adChapter},
            {"FileTime",        ADOX::adFileTime},
            {"PropVariant",        ADOX::adPropVariant},
            {"VarNumeric",        ADOX::adVarNumeric},
            //{"Array",            ADOX::adArray}
        };
        return findName(names, XtNumber(names), type);
    }

private:
    const char* findName(const ArgT<char>* names, const int count, int type)
    {
        const char* name = "";
        for(int i = 0; i<count; i++) {
            if (names[i].value == type) {
                name = names[i].name;
                break;
            }
        }
        return name;
    }

};

}