/*
 * ADOEnumNames.h 
 * Copyright (c) 2009 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL9
// 2009/05/24

#pragma once

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

namespace SOL {

class ADOEnumNames :public Object {

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

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


public:
    const char* getName(ADODB::LockTypeEnum type)
    {
        static const ArgT<char> names[]=
        {
            {"adLockUnspecified", ADODB::adLockUnspecified},
            {"adLockReadOnly", ADODB::adLockReadOnly},
            {"adLockPessimistic", ADODB::adLockPessimistic},
            {"adLockOptimistic", ADODB::adLockOptimistic},
            {"adLockBatchOptimistic", ADODB::adLockBatchOptimistic}
        };
        return findName(names, XtNumber(names), type);
    }


public:
    const char* getName(ADODB::ExecuteOptionEnum type)
    {
        static const ArgT<char> names[]=
        {
            {"adOptionUnspecified", ADODB::adOptionUnspecified},
            {"adAsyncExecute", ADODB::adAsyncExecute},
            {"adAsyncFetch", ADODB::adAsyncFetch},
            {"adAsyncFetchNonBlocking", ADODB::adAsyncFetchNonBlocking},
            {"adExecuteNoRecords", ADODB::adExecuteNoRecords},
            {"adExecuteStream", ADODB::adExecuteStream},
            {"adExecuteRecord", ADODB::adExecuteRecord}
        };

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

public:
    const char* getName(ADODB::ConnectOptionEnum type)
    {
        static const ArgT<char> names[]=
        {
            {"adConnectUnspecified", ADODB::adConnectUnspecified},
            {"adAsyncConnect", ADODB::adAsyncConnect}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::ObjectStateEnum type)
    {
        static const ArgT<char> names[]=
        {
            {"adStateClosed", ADODB::adStateClosed},
            {"adStateOpen", ADODB::adStateOpen},
            {"adStateConnecting", ADODB::adStateConnecting},
            {"adStateExecuting", ADODB::adStateExecuting},
            {"adStateFetching", ADODB::adStateFetching}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::FieldAttributeEnum type)
    {
        static const ArgT<char> names[]=
        {
            {"adFldUnspecified", ADODB::adFldUnspecified},
            {"adFldMayDefer", ADODB::adFldMayDefer},
            {"adFldUpdatable", ADODB::adFldUpdatable},
            {"adFldUnknownUpdatable", ADODB::adFldUnknownUpdatable},
            {"adFldFixed", ADODB::adFldFixed},
            {"adFldIsNullable", ADODB::adFldIsNullable},
            {"adFldMayBeNull", ADODB::adFldMayBeNull},
            {"adFldLong", ADODB::adFldLong},
            {"adFldRowID", ADODB::adFldRowID},
            {"adFldRowVersion", ADODB::adFldRowVersion},
            {"adFldCacheDeferred", ADODB::adFldCacheDeferred},
            {"adFldIsChapter", ADODB::adFldIsChapter},
            {"adFldNegativeScale", ADODB::adFldNegativeScale},
            {"adFldKeyColumn", ADODB::adFldKeyColumn},
            {"adFldIsRowURL", ADODB::adFldIsRowURL},
            {"adFldIsDefaultStream", ADODB::adFldIsDefaultStream},
            {"adFldIsCollection", ADODB::adFldIsCollection}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::EditModeEnum type)
    {
        static const ArgT<char> names[]=
        {
            {"adEditNone", ADODB::adEditNone},
            {"adEditInProgress", ADODB::adEditInProgress},
            {"adEditAdd", ADODB::adEditAdd},
            {"adEditDelete", ADODB::adEditDelete}
        };
        return findName(names, XtNumber(names), type);
    }


public:
    const char* getName(ADODB::RecordStatusEnum type)
    {
        static const ArgT<char> names[]=
        {
            {"adRecOK", ADODB::adRecOK},
            {"adRecNew", ADODB::adRecNew},
            {"adRecModified", ADODB::adRecModified},
            {"adRecDeleted", ADODB::adRecDeleted},
            {"adRecUnmodified", ADODB::adRecUnmodified},
            {"adRecInvalid", ADODB::adRecInvalid},
            {"adRecMultipleChanges", ADODB::adRecMultipleChanges},
            {"adRecPendingChanges", ADODB::adRecPendingChanges},
            {"adRecCanceled", ADODB::adRecCanceled},
            {"adRecCantRelease", ADODB::adRecCantRelease},
            {"adRecConcurrencyViolation", ADODB::adRecConcurrencyViolation},
            {"adRecIntegrityViolation", ADODB::adRecIntegrityViolation},
            {"adRecMaxChangesExceeded", ADODB::adRecMaxChangesExceeded},
            {"adRecObjectOpen", ADODB::adRecObjectOpen},
            {"adRecOutOfMemory", ADODB::adRecOutOfMemory},
            {"adRecPermissionDenied", ADODB::adRecPermissionDenied},
            {"adRecSchemaViolation", ADODB::adRecSchemaViolation},
            {"adRecDBDeleted", ADODB::adRecDBDeleted}
        };
        return findName(names, XtNumber(names), type);
    }


public:
    const char* getName(ADODB::GetRowsOptionEnum type)
    {
        static const ArgT<char> names[]=
        {
            {"adGetRowsRest", ADODB::adGetRowsRest}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::PositionEnum type)
    {
        static const ArgT<char> names[]= 
        {
            {"adPosUnknown", ADODB::adPosUnknown},
            {"adPosBOF", ADODB::adPosBOF},
            {"adPosEOF", ADODB::adPosEOF}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::BookmarkEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adBookmarkCurrent", ADODB::adBookmarkCurrent},
            {"adBookmarkFirst", ADODB::adBookmarkFirst},
            {"adBookmarkLast", ADODB::adBookmarkLast}
        };
        return findName(names, XtNumber(names), type);
    }


public:
    const char* getName(ADODB::MarshalOptionsEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adMarshalAll", ADODB::adMarshalAll},
            {"adMarshalModifiedOnly", ADODB::adMarshalModifiedOnly}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::AffectEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adAffectCurrent", ADODB::adAffectCurrent},
            {"adAffectGroup", ADODB::adAffectGroup},
            {"adAffectAll", ADODB::adAffectAll},
            {"adAffectAllChapters", ADODB::adAffectAllChapters}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::ResyncEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adResyncUnderlyingValues", ADODB::adResyncUnderlyingValues},
            {"adResyncAllValues", ADODB::adResyncAllValues}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::CompareEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adCompareLessThan", ADODB::adCompareLessThan},
            {"adCompareEqual", ADODB::adCompareEqual},
            {"adCompareGreaterThan", ADODB::adCompareGreaterThan},
            {"adCompareNotEqual", ADODB::adCompareNotEqual},
            {"adCompareNotComparable", ADODB::adCompareNotComparable}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::FilterGroupEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adFilterNone", ADODB::adFilterNone},
            {"adFilterPendingRecords", ADODB::adFilterPendingRecords},
            {"adFilterAffectedRecords", ADODB::adFilterAffectedRecords},
            {"adFilterFetchedRecords", ADODB::adFilterFetchedRecords},
            {"adFilterPredicate", ADODB::adFilterPredicate},
            {"adFilterConflictingRecords", ADODB::adFilterConflictingRecords}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::SearchDirectionEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adSearchForward", ADODB::adSearchForward},
            {"adSearchBackward", ADODB::adSearchBackward}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::PersistFormatEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adPersistADTG", ADODB::adPersistADTG},
            {"adPersistXML", ADODB::adPersistXML}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::StringFormatEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adClipString", ADODB::adClipString}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::ConnectPromptEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adPromptAlways", ADODB::adPromptAlways},
            {"adPromptComplete", ADODB::adPromptComplete},
            {"adPromptCompleteRequired", ADODB::adPromptCompleteRequired},
            {"adPromptNever", ADODB::adPromptNever}
        };
        return findName(names, XtNumber(names), type);
    }


public:
    const char* getName(ADODB::PropertyAttributesEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adPropNotSupported", ADODB::adPropNotSupported},
            {"adPropRequired", ADODB::adPropRequired},
            {"adPropOptional", ADODB::adPropOptional},
            {"adPropRead", ADODB::adPropRead},
            {"adPropWrite", ADODB::adPropWrite}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    
    const char* getName(ADODB::CommandTypeEnum type)
    {
        static const ArgT<char> names[] = 
        {
            {"adCmdUnspecified", ADODB::adCmdUnspecified}, 
            {"adCmdText",            ADODB::adCmdText},
            {"adCmdTable",            ADODB::adCmdTable},
            {"adCmdStoredProc",        ADODB::adCmdStoredProc},

            {"adCmdUnknown",        ADODB::adCmdUnknown},
            {"adCmdFile",            ADODB::adCmdFile},
            {"adCmdTableDirect",    ADODB::adCmdTableDirect},
        };

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


public:
    const char* getName(ADODB::ParameterDirectionEnum type)
    {
        static const ArgT<char> names[] = 
        {
            {"adParamUnknown", ADODB::adParamUnknown},
            {"adParamInput", ADODB::adParamInput},
            {"adParamOutput", ADODB::adParamOutput},
            {"adParamInputOutput", ADODB::adParamInputOutput},
            {"adParamReturnValue", ADODB::adParamReturnValue},
        };

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

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


public:
    const char* getName(ADODB::CursorLocationEnum type)
    {
        static const ArgT<char> names[] = 
        {
            {"adUseNone", ADODB::adUseNone},
            {"adUseServer", ADODB::adUseServer},
            {"adUseClient", ADODB::adUseClient},
            {"adUseClientBatch", ADODB::adUseClientBatch},
        };

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

public:
    const char* getName(ADODB::ConnectModeEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adModeUnknown", ADODB::adModeUnknown},
            {"adModeRead", ADODB::adModeRead},
            {"adModeWrite", ADODB::adModeWrite},
            {"adModeReadWrite", ADODB::adModeReadWrite},
            {"adModeShareDenyRead", ADODB::adModeShareDenyRead},
            {"adModeShareDenyWrite", ADODB::adModeShareDenyWrite}, 
            {"adModeShareExclusive", ADODB::adModeShareExclusive},
            {"adModeShareDenyNone", ADODB::adModeShareDenyNone},
            {"adModeRecursive", ADODB::adModeRecursive},
        };
        return findName(names, XtNumber(names), type);
    }
public:
    
    const char* getName(ADODB::SchemaEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adSchemaProviderSpecific", ADODB::adSchemaProviderSpecific},
            {"adSchemaAsserts",    ADODB::adSchemaAsserts},
            {"adSchemaCatalogs",  ADODB::adSchemaCatalogs},
            {"adSchemaCharacterSets", ADODB::adSchemaCharacterSets},
            {"adSchemaCollations", ADODB::adSchemaCollations},
            {"adSchemaColumns", ADODB::adSchemaColumns},
            {"adSchemaCheckConstraints", ADODB::adSchemaCheckConstraints},
            {"adSchemaConstraintColumnUsage", ADODB::adSchemaConstraintColumnUsage},
            {"adSchemaConstraintTableUsage", ADODB::adSchemaConstraintTableUsage},
            {"adSchemaKeyColumnUsage", ADODB::adSchemaKeyColumnUsage},
            {"adSchemaReferentialContraints", ADODB::adSchemaReferentialContraints},
            {"adSchemaReferentialConstraints", ADODB::adSchemaReferentialConstraints},
            {"adSchemaTableConstraints", ADODB::adSchemaTableConstraints},
            {"adSchemaColumnsDomainUsage", ADODB::adSchemaColumnsDomainUsage},
            {"adSchemaIndexes", ADODB::adSchemaIndexes},
            {"adSchemaColumnPrivileges", ADODB::adSchemaColumnPrivileges},
            {"adSchemaTablePrivileges", ADODB::adSchemaTablePrivileges},
            {"adSchemaUsagePrivileges", ADODB::adSchemaUsagePrivileges},
            {"adSchemaProcedures", ADODB::adSchemaProcedures},
            {"adSchemaSchemata", ADODB::adSchemaSchemata},
            {"adSchemaSQLLanguages", ADODB::adSchemaSQLLanguages},
            {"adSchemaStatistics", ADODB::adSchemaStatistics},
            {"adSchemaTables", ADODB::adSchemaTables},
            {"adSchemaTranslations", ADODB::adSchemaTranslations},
            {"adSchemaProviderTypes", ADODB::adSchemaProviderTypes},
            {"adSchemaViews", ADODB::adSchemaViews},
            {"adSchemaViewColumnUsage", ADODB::adSchemaViewColumnUsage},
            {"adSchemaViewTableUsage", ADODB::adSchemaViewTableUsage},
            {"adSchemaProcedureParameters", ADODB::adSchemaProcedureParameters},
            {"adSchemaForeignKeys", ADODB::adSchemaForeignKeys},
            {"adSchemaPrimaryKeys", ADODB::adSchemaPrimaryKeys},
            {"adSchemaProcedureColumns", ADODB::adSchemaProcedureColumns},
            {"adSchemaDBInfoKeywords", ADODB::adSchemaDBInfoKeywords},
            {"adSchemaDBInfoLiterals", ADODB::adSchemaDBInfoLiterals},
            {"adSchemaCubes", ADODB::adSchemaCubes},
            {"adSchemaDimensions", ADODB::adSchemaDimensions},
            {"adSchemaHierarchies", ADODB::adSchemaHierarchies},
            {"adSchemaLevels", ADODB::adSchemaLevels},
            {"adSchemaMeasures", ADODB::adSchemaMeasures},
            {"adSchemaProperties", ADODB::adSchemaProperties},
            {"adSchemaMembers", ADODB::adSchemaMembers},
            {"adSchemaTrustees", ADODB::adSchemaTrustees},
            {"adSchemaFunctions", ADODB::adSchemaFunctions},
            {"adSchemaActions", ADODB::adSchemaActions},
            {"adSchemaCommands", ADODB::adSchemaCommands},
            {"adSchemaSets", ADODB::adSchemaSets},
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::ErrorValueEnum type)
    {
        static const ArgT<char> names[] =
        {
            {"adErrProviderFailed", ADODB::adErrProviderFailed},
            {"adErrInvalidArgument", ADODB::adErrInvalidArgument},
            {"adErrOpeningFile", ADODB::adErrOpeningFile},
            {"adErrReadFile", ADODB::adErrReadFile},
            {"adErrWriteFile", ADODB::adErrWriteFile},
            {"adErrNoCurrentRecord", ADODB::adErrNoCurrentRecord},
            {"adErrIllegalOperation", ADODB::adErrIllegalOperation},
            {"adErrCantChangeProvider", ADODB::adErrCantChangeProvider},
            {"adErrInTransaction", ADODB::adErrInTransaction},
            {"adErrFeatureNotAvailable", ADODB::adErrFeatureNotAvailable},
            {"adErrItemNotFound", ADODB::adErrItemNotFound},
            {"adErrObjectInCollection", ADODB::adErrObjectInCollection},
            {"adErrObjectNotSet", ADODB::adErrObjectNotSet},
            {"adErrDataConversion", ADODB::adErrDataConversion},
            {"adErrObjectClosed", ADODB::adErrObjectClosed},
            {"adErrObjectOpen", ADODB::adErrObjectOpen},
            {"adErrProviderNotFound", ADODB::adErrProviderNotFound},
            {"adErrBoundToCommand", ADODB::adErrBoundToCommand},
            {"adErrInvalidParamInfo", ADODB::adErrInvalidParamInfo},
            {"adErrInvalidConnection", ADODB::adErrInvalidConnection},
            {"adErrNotReentrant", ADODB::adErrNotReentrant},
            {"adErrStillExecuting", ADODB::adErrStillExecuting},
            {"adErrOperationCancelled", ADODB::adErrOperationCancelled},
            {"adErrStillConnecting", ADODB::adErrStillConnecting},
            {"adErrInvalidTransaction", ADODB::adErrInvalidTransaction},
            {"adErrNotExecuting", ADODB::adErrNotExecuting},
            {"adErrUnsafeOperation", ADODB::adErrUnsafeOperation},
            {"adwrnSecurityDialog", ADODB::adwrnSecurityDialog},
            {"adwrnSecurityDialogHeader", ADODB::adwrnSecurityDialogHeader},
            {"adErrIntegrityViolation", ADODB::adErrIntegrityViolation},
            {"adErrPermissionDenied", ADODB::adErrPermissionDenied},
            {"adErrDataOverflow", ADODB::adErrDataOverflow},
            {"adErrSchemaViolation", ADODB::adErrSchemaViolation},
            {"adErrSignMismatch", ADODB::adErrSignMismatch},
            {"adErrCantConvertvalue", ADODB::adErrCantConvertvalue},
            {"adErrCantCreate", ADODB::adErrCantCreate},
            {"adErrColumnNotOnThisRow", ADODB::adErrColumnNotOnThisRow},
            {"adErrURLDoesNotExist", ADODB::adErrURLDoesNotExist},
            {"adErrTreePermissionDenied", ADODB::adErrTreePermissionDenied},
            {"adErrInvalidURL", ADODB::adErrInvalidURL},
            {"adErrResourceLocked", ADODB::adErrResourceLocked},
            {"adErrResourceExists", ADODB::adErrResourceExists},
            {"adErrCannotComplete", ADODB::adErrCannotComplete},
            {"adErrVolumeNotFound", ADODB::adErrVolumeNotFound},
            {"adErrOutOfSpace", ADODB::adErrOutOfSpace},
            {"adErrResourceOutOfScope", ADODB::adErrResourceOutOfScope},
            {"adErrUnavailable", ADODB::adErrUnavailable},
            {"adErrURLNamedRowDoesNotExist", ADODB::adErrURLNamedRowDoesNotExist},
            {"adErrDelResOutOfScope", ADODB::adErrDelResOutOfScope},
            {"adErrPropInvalidColumn", ADODB::adErrPropInvalidColumn},
            {"adErrPropInvalidOption", ADODB::adErrPropInvalidOption},
            {"adErrPropInvalidValue", ADODB::adErrPropInvalidValue},
            {"adErrPropConflicting", ADODB::adErrPropConflicting},
            {"adErrPropNotAllSettable", ADODB::adErrPropNotAllSettable},
            {"adErrPropNotSet", ADODB::adErrPropNotSet},
            {"adErrPropNotSettable", ADODB::adErrPropNotSettable},
            {"adErrPropNotSupported", ADODB::adErrPropNotSupported},
            {"adErrCatalogNotSet", ADODB::adErrCatalogNotSet},
            {"adErrCantChangeConnection", ADODB::adErrCantChangeConnection},
            {"adErrFieldsUpdateFailed", ADODB::adErrFieldsUpdateFailed},
            {"adErrDenyNotSupported", ADODB::adErrDenyNotSupported},
            {"adErrDenyTypeNotSupported", ADODB::adErrDenyTypeNotSupported},
            {"adErrProviderNotSpecified", ADODB::adErrProviderNotSpecified},
            {"adErrConnectionStringTooLong", ADODB::adErrConnectionStringTooLong}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::RecordCreateOptionsEnum type)
    {
        static const ArgT<char> names[] = 
        {
            {"adCreateCollection", ADODB::adCreateCollection},
            {"adCreateStructDoc", ADODB::adCreateStructDoc},
            {"adCreateNonCollection", ADODB::adCreateNonCollection},
            {"adOpenIfExists", ADODB::adOpenIfExists},
            {"adCreateOverwrite", ADODB::adCreateOverwrite},
            {"adFailIfNotExists", ADODB::adFailIfNotExists}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::RecordOpenOptionsEnum type)
    {
        static const ArgT<char> names[] = 
        {
            {"adOpenRecordUnspecified", ADODB::adOpenRecordUnspecified},
            {"adOpenSource", ADODB::adOpenSource},
            {"adOpenOutput", ADODB::adOpenOutput},
            {"adOpenAsync", ADODB::adOpenAsync},
            {"adDelayFetchStream", ADODB::adDelayFetchStream},
            {"adDelayFetchFields", ADODB::adDelayFetchFields},
            {"adOpenExecuteCommand", ADODB::adOpenExecuteCommand}
        };
        return findName(names, XtNumber(names), type);
    }

public:
    const char* getName(ADODB::IsolationLevelEnum type)
    {
        static const ArgT<char> names[] = 
        {
            {"adXactUnspecified", ADODB::adXactUnspecified},
            {"adXactChaos", ADODB::adXactChaos},
            {"adXactReadUncommitted", ADODB::adXactReadUncommitted},
            {"adXactBrowse", ADODB::adXactBrowse},
            {"adXactCursorStability", ADODB::adXactCursorStability},
            {"adXactReadCommitted", ADODB::adXactReadCommitted},
            {"adXactRepeatableRead", ADODB::adXactRepeatableRead},
            {"adXactSerializable", ADODB::adXactSerializable},
            {"adXactIsolated", ADODB::adXactIsolated}
        };
        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;
    }

};

}