
/*
 * This file was generated by the SOM Compiler.
 * FileName: somcls.h.
 * Generated using:
 *     SOM Precompiler somipc: 2.29.1.3
 *     SOM Emitter emith: 2.41
 */

/*
 *  @(#)75	1.3  src/somk/somobj.idl, somk.so, som2.1.1 6/20/95 11:22:52
 * 
 *    COMPONENT_NAME: somk
 * 
 *    ORIGINS: 27
 * 
 * 
 *    10H9767, 10H9769  (C) COPYRIGHT International Business Machines Corp. 1994
 *    All Rights Reserved
 *    Licensed Materials - Property of IBM
 *    US Government Users Restricted Rights - Use, duplication or
 *    disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 * 
 *   SOMObject: System Object Model root class
 */


#ifndef SOM_SOMClass_h
#define SOM_SOMClass_h


#include <som.h>

/*
 * -- This emitter treats Method Tokens as Thunks by default.
 * -- Use the sc modifier "nothunks" to change this default
 */
#undef somresolve_
#define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))

/*
 * Define the class name as an object type
 */
#ifndef SOMClass
#define SOMClass SOMObject
#endif
#include <somobj.h>

/*
 * Start of bindings for IDL types
 */

#ifndef SOMClass
    #define SOMClass SOMObject
#endif /* SOMClass */
#ifndef _IDL_SEQUENCE_somToken_defined
#define _IDL_SEQUENCE_somToken_defined
typedef struct {
    unsigned long _maximum;
    unsigned long _length;
    somToken *_buffer;
} _IDL_SEQUENCE_somToken;
#endif /* _IDL_SEQUENCE_somToken_defined */ 
typedef
_IDL_SEQUENCE_somToken SOMClass_somTokenSequence;
/*
 *  a (generic) sequence of somTokens
 */

#ifndef _IDL_SEQUENCE_SOMClass_defined
#define _IDL_SEQUENCE_SOMClass_defined
typedef struct {
    unsigned long _maximum;
    unsigned long _length;
    SOMClass **_buffer;
} _IDL_SEQUENCE_SOMClass;
#endif /* _IDL_SEQUENCE_SOMClass_defined */ 
typedef
_IDL_SEQUENCE_SOMClass SOMClass_SOMClassSequence;
/*
 *  a sequence of classes
 */

typedef
struct SOMClass_somOffsetInfo {
SOMClass* cls;
long  offset;
} SOMClass_somOffsetInfo;
/*
 *  a structure to describe a class-related offset
 */

struct SOMClass_somOffsetInfo;
#ifndef _IDL_SEQUENCE_SOMClass_somOffsetInfo_defined
#define _IDL_SEQUENCE_SOMClass_somOffsetInfo_defined
typedef struct {
    unsigned long _maximum;
    unsigned long _length;
    struct SOMClass_somOffsetInfo *_buffer;
} _IDL_SEQUENCE_SOMClass_somOffsetInfo;
#endif /* _IDL_SEQUENCE_SOMClass_somOffsetInfo_defined */ 
typedef
_IDL_SEQUENCE_SOMClass_somOffsetInfo SOMClass_somOffsets;
/*
 *  a sequence of class-related offsets
 */

#ifndef _IDL_SEQUENCE_somId_defined
#define _IDL_SEQUENCE_somId_defined
typedef struct {
    unsigned long _maximum;
    unsigned long _length;
    somId *_buffer;
} _IDL_SEQUENCE_somId;
#endif /* _IDL_SEQUENCE_somId_defined */ 
typedef
_IDL_SEQUENCE_somId SOMClass_somIdSequence;
/*
 *  a sequence of somIds
 */


#ifndef SOM_DONT_USE_SHORT_NAMES

#ifndef SOM_DONT_USE_SHORT_NAMES
#ifndef SOMTGD_somTokenSequence
    #ifdef somTokenSequence
        #undef somTokenSequence
        #define SOMTGD_somTokenSequence 1
    #else
        #define somTokenSequence SOMClass_somTokenSequence
    #endif /* somTokenSequence */
#endif /* SOMTGD_somTokenSequence */
#endif /* SOM_DONT_USE_SHORT_NAMES */

#ifndef SOM_DONT_USE_SHORT_NAMES
#ifndef SOMTGD_SOMClassSequence
    #ifdef SOMClassSequence
        #undef SOMClassSequence
        #define SOMTGD_SOMClassSequence 1
    #else
        #define SOMClassSequence SOMClass_SOMClassSequence
    #endif /* SOMClassSequence */
#endif /* SOMTGD_SOMClassSequence */
#endif /* SOM_DONT_USE_SHORT_NAMES */
#ifndef SOMTGD_somOffsetInfo
    #ifdef somOffsetInfo
        #undef somOffsetInfo
        #define SOMTGD_somOffsetInfo 1
    #else
        #define somOffsetInfo SOMClass_somOffsetInfo
    #endif /* somOffsetInfo */
#endif /* SOMTGD_somOffsetInfo */
#ifndef SOMTGD__IDL_SEQUENCE_somOffsetInfo
    #ifdef _IDL_SEQUENCE_somOffsetInfo
        #undef _IDL_SEQUENCE_somOffsetInfo
        #define SOMTGD__IDL_SEQUENCE_somOffsetInfo 1
    #else
        #define _IDL_SEQUENCE_somOffsetInfo _IDL_SEQUENCE_SOMClass_somOffsetInfo
    #endif /* _IDL_SEQUENCE_somOffsetInfo */
#endif /* SOMTGD__IDL_SEQUENCE_somOffsetInfo */

#ifndef SOM_DONT_USE_SHORT_NAMES
#ifndef SOMTGD_somOffsets
    #ifdef somOffsets
        #undef somOffsets
        #define SOMTGD_somOffsets 1
    #else
        #define somOffsets SOMClass_somOffsets
    #endif /* somOffsets */
#endif /* SOMTGD_somOffsets */
#endif /* SOM_DONT_USE_SHORT_NAMES */

#ifndef SOM_DONT_USE_SHORT_NAMES
#ifndef SOMTGD_somIdSequence
    #ifdef somIdSequence
        #undef somIdSequence
        #define SOMTGD_somIdSequence 1
    #else
        #define somIdSequence SOMClass_somIdSequence
    #endif /* somIdSequence */
#endif /* SOMTGD_somIdSequence */
#endif /* SOM_DONT_USE_SHORT_NAMES */
#endif /* SOM_DONT_USE_SHORT_NAMES */

/*
 * End of bindings for IDL types.
 */

#define SOMClass_MajorVersion 1
#define SOMClass_MinorVersion 4

/*
 * External name shortening if required
 */
#ifdef SOM_USE_SHORT_EXTERNAL_NAMES
#define SOMClassNewClass sommcc
#pragma linkage(sommcc, system)
#define SOMClassClassData sommcd
#define SOMClassCClassData sommcx
#endif /* SOM_USE_SHORT_EXTERNAL_NAMES */
/*--------------Migration------------*/
#define SOMClass_classObj SOMClassClassData.classObject
#define _SOMClass SOMClass_classObj

/*
 * Declare the class creation procedure
 */
SOMEXTERN SOMClass * SOMLINK SOMClassNewClass(integer4 somtmajorVersion,
		integer4 somtminorVersion);
#pragma linkage(SOMClassNewClass, system)

/*
 * Declare the class data structure
 */
SOMEXTERN struct SOMClassClassDataStructure {
	SOMClass *classObject;
	somMToken somNew;
	somMToken somRenew;
	somMToken somInitClass;
	somMToken somClassReady;
	somMToken somGetName;
	somMToken somGetParent;
	somMToken somDescendedFrom;
	somMToken somCheckVersion;
	somMToken somFindMethod;
	somMToken somFindMethodOk;
	somMToken somSupportsMethod;
	somMToken somGetNumMethods;
	somMToken somGetInstanceSize;
	somMToken somGetInstanceOffset;
	somMToken somGetInstancePartSize;
	somMToken somGetMethodIndex;
	somMToken somGetNumStaticMethods;
	somMToken somGetPClsMtab;
	somMToken somGetClassMtab;
	somMToken somAddStaticMethod;
	somMToken somOverrideSMethod;
	somMToken somAddDynamicMethod;
	somMToken somcPrivate0;
	somMToken somGetApplyStub;
	somMToken somFindSMethod;
	somMToken somFindSMethodOk;
	somMToken somGetMethodDescriptor;
	somMToken somGetNthMethodInfo;
	somMToken somSetClassData;
	somMToken somGetClassData;
	somMToken somNewNoInit;
	somMToken somRenewNoInit;
	somMToken somGetInstanceToken;
	somMToken somGetMemberToken;
	somMToken somSetMethodDescriptor;
	somMToken somGetMethodData;
	somMToken somOverrideMtab;
	somMToken somGetMethodToken;
	somMToken somGetParents;
	somMToken somGetPClsMtabs;
	somMToken somInitMIClass;
	somMToken somGetVersionNumbers;
	somMToken somLookupMethod;
	somMToken _get_somInstanceDataOffsets;
	somMToken somRenewNoZero;
	somMToken somRenewNoInitNoZero;
	somMToken somAllocate;
	somMToken somDeallocate;
	somMToken somGetRdStub;
	somMToken somGetNthMethodData;
	somMToken somcPrivate1;
	somMToken somcPrivate2;
	somMToken _get_somDirectInitClasses;
	somMToken _set_somDirectInitClasses;
	somMToken somGetInstanceInitMask;
	somMToken somGetInstanceDestructionMask;
	somMToken somcPrivate3;
	somMToken somcPrivate4;
	somMToken somcPrivate5;
	somMToken somcPrivate6;
	somMToken somcPrivate7;
	somMToken somDefinedMethod;
	somMToken somcPrivate8;
	somMToken somcPrivate9;
	somMToken somcPrivate10;
	somMToken somcPrivate11;
	somMToken somcPrivate12;
	somMToken somcPrivate13;
	somMToken somcPrivate14;
	somMToken somcPrivate15;
	somMToken _get_somDataAlignment;
	somMToken somGetInstanceAssignmentMask;
	somMToken somcPrivate16;
	somMToken somcPrivate17;
} SOMDLINK SOMClassClassData;

/*
 * Declare the C specific class data structure
 */
SOMEXTERN struct SOMClassCClassDataStructure {
	somMethodTabs parentMtab;
	somDToken instanceDataToken;
} SOMDLINK SOMClassCClassData;

/*
 * New and Renew macros for SOMClass
 */
#define SOMClassNew() \
   (_somNew(_SOMClass ? _SOMClass : SOMClassNewClass(SOMClass_MajorVersion, SOMClass_MinorVersion)))
#define SOMClassRenew(buf) \
   (_somRenew(_SOMClass ? _SOMClass : SOMClassNewClass(SOMClass_MajorVersion, SOMClass_MinorVersion), buf))

/*
 * New Method: _get_somDataAlignment
 */
typedef long   SOMLINK somTP_SOMClass__get_somDataAlignment(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass__get_somDataAlignment, system)
typedef somTP_SOMClass__get_somDataAlignment *somTD_SOMClass__get_somDataAlignment;
#define somMD_SOMClass__get_somDataAlignment "::SOMClass::somDataAlignment"
#define SOMClass__get_somDataAlignment(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, _get_somDataAlignment) \
	(somSelf))
#ifndef SOMGD_get_somDataAlignment
    #if (defined(_get_somDataAlignment) || defined(__get_somDataAlignment))
        #undef _get_somDataAlignment
        #undef __get_somDataAlignment
        #define SOMGD_get_somDataAlignment 1
    #else
        #define __get_somDataAlignment SOMClass__get_somDataAlignment
    #endif /* __get_somDataAlignment */
#endif /* SOMGD_get_somDataAlignment */

/*
 * New Method: _get_somInstanceDataOffsets
 */
typedef SOMClass_somOffsets   SOMLINK somTP_SOMClass__get_somInstanceDataOffsets(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass__get_somInstanceDataOffsets, system)
typedef somTP_SOMClass__get_somInstanceDataOffsets *somTD_SOMClass__get_somInstanceDataOffsets;
#define somMD_SOMClass__get_somInstanceDataOffsets "::SOMClass::somInstanceDataOffsets"
#define SOMClass__get_somInstanceDataOffsets(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, _get_somInstanceDataOffsets) \
	(somSelf))
#ifndef SOMGD_get_somInstanceDataOffsets
    #if (defined(_get_somInstanceDataOffsets) || defined(__get_somInstanceDataOffsets))
        #undef _get_somInstanceDataOffsets
        #undef __get_somInstanceDataOffsets
        #define SOMGD_get_somInstanceDataOffsets 1
    #else
        #define __get_somInstanceDataOffsets SOMClass__get_somInstanceDataOffsets
    #endif /* __get_somInstanceDataOffsets */
#endif /* SOMGD_get_somInstanceDataOffsets */

/*
 * New Method: _get_somDirectInitClasses
 */
typedef SOMClass_SOMClassSequence   SOMLINK somTP_SOMClass__get_somDirectInitClasses(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass__get_somDirectInitClasses, system)
typedef somTP_SOMClass__get_somDirectInitClasses *somTD_SOMClass__get_somDirectInitClasses;
#define somMD_SOMClass__get_somDirectInitClasses "::SOMClass::somDirectInitClasses"
#define SOMClass__get_somDirectInitClasses(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, _get_somDirectInitClasses) \
	(somSelf))
#ifndef SOMGD_get_somDirectInitClasses
    #if (defined(_get_somDirectInitClasses) || defined(__get_somDirectInitClasses))
        #undef _get_somDirectInitClasses
        #undef __get_somDirectInitClasses
        #define SOMGD_get_somDirectInitClasses 1
    #else
        #define __get_somDirectInitClasses SOMClass__get_somDirectInitClasses
    #endif /* __get_somDirectInitClasses */
#endif /* SOMGD_get_somDirectInitClasses */

/*
 * New Method: _set_somDirectInitClasses
 */
typedef void   SOMLINK somTP_SOMClass__set_somDirectInitClasses(SOMClass *somSelf, 
		SOMClass_SOMClassSequence* somDirectInitClasses);
#pragma linkage(somTP_SOMClass__set_somDirectInitClasses, system)
typedef somTP_SOMClass__set_somDirectInitClasses *somTD_SOMClass__set_somDirectInitClasses;
#define somMD_SOMClass__set_somDirectInitClasses "::SOMClass::somDirectInitClasses"
#define SOMClass__set_somDirectInitClasses(somSelf,somDirectInitClasses) \
    (SOM_Resolve(somSelf, SOMClass, _set_somDirectInitClasses) \
	(somSelf,somDirectInitClasses))
#ifndef SOMGD_set_somDirectInitClasses
    #if (defined(_set_somDirectInitClasses) || defined(__set_somDirectInitClasses))
        #undef _set_somDirectInitClasses
        #undef __set_somDirectInitClasses
        #define SOMGD_set_somDirectInitClasses 1
    #else
        #define __set_somDirectInitClasses SOMClass__set_somDirectInitClasses
    #endif /* __set_somDirectInitClasses */
#endif /* SOMGD_set_somDirectInitClasses */

/*
 * New Method: somNew
 */
typedef SOMObject*   SOMLINK somTP_SOMClass_somNew(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somNew, system)
typedef somTP_SOMClass_somNew *somTD_SOMClass_somNew;
#define somMD_SOMClass_somNew "::SOMClass::somNew"
#define SOMClass_somNew(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somNew) \
	(somSelf))
#ifndef SOMGD_somNew
    #if (defined(_somNew) || defined(__somNew))
        #undef _somNew
        #undef __somNew
        #define SOMGD_somNew 1
    #else
        #define _somNew SOMClass_somNew
    #endif /* _somNew */
#endif /* SOMGD_somNew */

/*
 * New Method: somNewNoInit
 */
typedef SOMObject*   SOMLINK somTP_SOMClass_somNewNoInit(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somNewNoInit, system)
typedef somTP_SOMClass_somNewNoInit *somTD_SOMClass_somNewNoInit;
#define somMD_SOMClass_somNewNoInit "::SOMClass::somNewNoInit"
#define SOMClass_somNewNoInit(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somNewNoInit) \
	(somSelf))
#ifndef SOMGD_somNewNoInit
    #if (defined(_somNewNoInit) || defined(__somNewNoInit))
        #undef _somNewNoInit
        #undef __somNewNoInit
        #define SOMGD_somNewNoInit 1
    #else
        #define _somNewNoInit SOMClass_somNewNoInit
    #endif /* _somNewNoInit */
#endif /* SOMGD_somNewNoInit */

/*
 * New Method: somRenew
 */
typedef SOMObject*   SOMLINK somTP_SOMClass_somRenew(SOMClass *somSelf, 
		void* obj);
#pragma linkage(somTP_SOMClass_somRenew, system)
typedef somTP_SOMClass_somRenew *somTD_SOMClass_somRenew;
#define somMD_SOMClass_somRenew "::SOMClass::somRenew"
#define SOMClass_somRenew(somSelf,obj) \
    (SOM_Resolve(somSelf, SOMClass, somRenew) \
	(somSelf,obj))
#ifndef SOMGD_somRenew
    #if (defined(_somRenew) || defined(__somRenew))
        #undef _somRenew
        #undef __somRenew
        #define SOMGD_somRenew 1
    #else
        #define _somRenew SOMClass_somRenew
    #endif /* _somRenew */
#endif /* SOMGD_somRenew */

/*
 * New Method: somRenewNoInit
 */
typedef SOMObject*   SOMLINK somTP_SOMClass_somRenewNoInit(SOMClass *somSelf, 
		void* obj);
#pragma linkage(somTP_SOMClass_somRenewNoInit, system)
typedef somTP_SOMClass_somRenewNoInit *somTD_SOMClass_somRenewNoInit;
#define somMD_SOMClass_somRenewNoInit "::SOMClass::somRenewNoInit"
#define SOMClass_somRenewNoInit(somSelf,obj) \
    (SOM_Resolve(somSelf, SOMClass, somRenewNoInit) \
	(somSelf,obj))
#ifndef SOMGD_somRenewNoInit
    #if (defined(_somRenewNoInit) || defined(__somRenewNoInit))
        #undef _somRenewNoInit
        #undef __somRenewNoInit
        #define SOMGD_somRenewNoInit 1
    #else
        #define _somRenewNoInit SOMClass_somRenewNoInit
    #endif /* _somRenewNoInit */
#endif /* SOMGD_somRenewNoInit */

/*
 * New Method: somRenewNoZero
 */
typedef SOMObject*   SOMLINK somTP_SOMClass_somRenewNoZero(SOMClass *somSelf, 
		void* obj);
#pragma linkage(somTP_SOMClass_somRenewNoZero, system)
typedef somTP_SOMClass_somRenewNoZero *somTD_SOMClass_somRenewNoZero;
#define somMD_SOMClass_somRenewNoZero "::SOMClass::somRenewNoZero"
#define SOMClass_somRenewNoZero(somSelf,obj) \
    (SOM_Resolve(somSelf, SOMClass, somRenewNoZero) \
	(somSelf,obj))
#ifndef SOMGD_somRenewNoZero
    #if (defined(_somRenewNoZero) || defined(__somRenewNoZero))
        #undef _somRenewNoZero
        #undef __somRenewNoZero
        #define SOMGD_somRenewNoZero 1
    #else
        #define _somRenewNoZero SOMClass_somRenewNoZero
    #endif /* _somRenewNoZero */
#endif /* SOMGD_somRenewNoZero */

/*
 * New Method: somRenewNoInitNoZero
 */
typedef SOMObject*   SOMLINK somTP_SOMClass_somRenewNoInitNoZero(SOMClass *somSelf, 
		void* obj);
#pragma linkage(somTP_SOMClass_somRenewNoInitNoZero, system)
typedef somTP_SOMClass_somRenewNoInitNoZero *somTD_SOMClass_somRenewNoInitNoZero;
#define somMD_SOMClass_somRenewNoInitNoZero "::SOMClass::somRenewNoInitNoZero"
#define SOMClass_somRenewNoInitNoZero(somSelf,obj) \
    (SOM_Resolve(somSelf, SOMClass, somRenewNoInitNoZero) \
	(somSelf,obj))
#ifndef SOMGD_somRenewNoInitNoZero
    #if (defined(_somRenewNoInitNoZero) || defined(__somRenewNoInitNoZero))
        #undef _somRenewNoInitNoZero
        #undef __somRenewNoInitNoZero
        #define SOMGD_somRenewNoInitNoZero 1
    #else
        #define _somRenewNoInitNoZero SOMClass_somRenewNoInitNoZero
    #endif /* _somRenewNoInitNoZero */
#endif /* SOMGD_somRenewNoInitNoZero */

/*
 * New Method: somAllocate
 */
typedef string   SOMLINK somTP_SOMClass_somAllocate(SOMClass *somSelf, 
		long size);
#pragma linkage(somTP_SOMClass_somAllocate, system)
typedef somTP_SOMClass_somAllocate *somTD_SOMClass_somAllocate;
#define somMD_SOMClass_somAllocate "::SOMClass::somAllocate"
#define SOMClass_somAllocate(somSelf,size) \
    (SOM_Resolve(somSelf, SOMClass, somAllocate) \
	(somSelf,size))
#ifndef SOMGD_somAllocate
    #if (defined(_somAllocate) || defined(__somAllocate))
        #undef _somAllocate
        #undef __somAllocate
        #define SOMGD_somAllocate 1
    #else
        #define _somAllocate SOMClass_somAllocate
    #endif /* _somAllocate */
#endif /* SOMGD_somAllocate */

/*
 * New Method: somDeallocate
 */
typedef void   SOMLINK somTP_SOMClass_somDeallocate(SOMClass *somSelf, 
		string memptr);
#pragma linkage(somTP_SOMClass_somDeallocate, system)
typedef somTP_SOMClass_somDeallocate *somTD_SOMClass_somDeallocate;
#define somMD_SOMClass_somDeallocate "::SOMClass::somDeallocate"
#define SOMClass_somDeallocate(somSelf,memptr) \
    (SOM_Resolve(somSelf, SOMClass, somDeallocate) \
	(somSelf,memptr))
#ifndef SOMGD_somDeallocate
    #if (defined(_somDeallocate) || defined(__somDeallocate))
        #undef _somDeallocate
        #undef __somDeallocate
        #define SOMGD_somDeallocate 1
    #else
        #define _somDeallocate SOMClass_somDeallocate
    #endif /* _somDeallocate */
#endif /* SOMGD_somDeallocate */

/*
 * New Method: somGetInstanceInitMask
 */
typedef somBooleanVector   SOMLINK somTP_SOMClass_somGetInstanceInitMask(SOMClass *somSelf, 
		somInitCtrl* ctrl);
#pragma linkage(somTP_SOMClass_somGetInstanceInitMask, system)
typedef somTP_SOMClass_somGetInstanceInitMask *somTD_SOMClass_somGetInstanceInitMask;
#define somMD_SOMClass_somGetInstanceInitMask "::SOMClass::somGetInstanceInitMask"
#define SOMClass_somGetInstanceInitMask(somSelf,ctrl) \
    (SOM_Resolve(somSelf, SOMClass, somGetInstanceInitMask) \
	(somSelf,ctrl))
#ifndef SOMGD_somGetInstanceInitMask
    #if (defined(_somGetInstanceInitMask) || defined(__somGetInstanceInitMask))
        #undef _somGetInstanceInitMask
        #undef __somGetInstanceInitMask
        #define SOMGD_somGetInstanceInitMask 1
    #else
        #define _somGetInstanceInitMask SOMClass_somGetInstanceInitMask
    #endif /* _somGetInstanceInitMask */
#endif /* SOMGD_somGetInstanceInitMask */

/*
 * New Method: somGetInstanceDestructionMask
 */
typedef somBooleanVector   SOMLINK somTP_SOMClass_somGetInstanceDestructionMask(SOMClass *somSelf, 
		somDestructCtrl* ctrl);
#pragma linkage(somTP_SOMClass_somGetInstanceDestructionMask, system)
typedef somTP_SOMClass_somGetInstanceDestructionMask *somTD_SOMClass_somGetInstanceDestructionMask;
#define somMD_SOMClass_somGetInstanceDestructionMask "::SOMClass::somGetInstanceDestructionMask"
#define SOMClass_somGetInstanceDestructionMask(somSelf,ctrl) \
    (SOM_Resolve(somSelf, SOMClass, somGetInstanceDestructionMask) \
	(somSelf,ctrl))
#ifndef SOMGD_somGetInstanceDestructionMask
    #if (defined(_somGetInstanceDestructionMask) || defined(__somGetInstanceDestructionMask))
        #undef _somGetInstanceDestructionMask
        #undef __somGetInstanceDestructionMask
        #define SOMGD_somGetInstanceDestructionMask 1
    #else
        #define _somGetInstanceDestructionMask SOMClass_somGetInstanceDestructionMask
    #endif /* _somGetInstanceDestructionMask */
#endif /* SOMGD_somGetInstanceDestructionMask */

/*
 * New Method: somGetInstanceAssignmentMask
 */
typedef somBooleanVector   SOMLINK somTP_SOMClass_somGetInstanceAssignmentMask(SOMClass *somSelf, 
		somAssignCtrl* ctrl);
#pragma linkage(somTP_SOMClass_somGetInstanceAssignmentMask, system)
typedef somTP_SOMClass_somGetInstanceAssignmentMask *somTD_SOMClass_somGetInstanceAssignmentMask;
#define somMD_SOMClass_somGetInstanceAssignmentMask "::SOMClass::somGetInstanceAssignmentMask"
#define SOMClass_somGetInstanceAssignmentMask(somSelf,ctrl) \
    (SOM_Resolve(somSelf, SOMClass, somGetInstanceAssignmentMask) \
	(somSelf,ctrl))
#ifndef SOMGD_somGetInstanceAssignmentMask
    #if (defined(_somGetInstanceAssignmentMask) || defined(__somGetInstanceAssignmentMask))
        #undef _somGetInstanceAssignmentMask
        #undef __somGetInstanceAssignmentMask
        #define SOMGD_somGetInstanceAssignmentMask 1
    #else
        #define _somGetInstanceAssignmentMask SOMClass_somGetInstanceAssignmentMask
    #endif /* _somGetInstanceAssignmentMask */
#endif /* SOMGD_somGetInstanceAssignmentMask */

/*
 * New Method: somInitClass
 */
typedef void   SOMLINK somTP_SOMClass_somInitClass(SOMClass *somSelf, 
		string className, 
		SOMClass* parentClass, 
		long dataSize, 
		long maxStaticMethods, 
		long majorVersion, 
		long minorVersion);
#pragma linkage(somTP_SOMClass_somInitClass, system)
typedef somTP_SOMClass_somInitClass *somTD_SOMClass_somInitClass;
#define somMD_SOMClass_somInitClass "::SOMClass::somInitClass"
#define SOMClass_somInitClass(somSelf,className,parentClass,dataSize,maxStaticMethods,majorVersion,minorVersion) \
    (SOM_Resolve(somSelf, SOMClass, somInitClass) \
	(somSelf,className,parentClass,dataSize,maxStaticMethods,majorVersion,minorVersion))
#ifndef SOMGD_somInitClass
    #if (defined(_somInitClass) || defined(__somInitClass))
        #undef _somInitClass
        #undef __somInitClass
        #define SOMGD_somInitClass 1
    #else
        #define _somInitClass SOMClass_somInitClass
    #endif /* _somInitClass */
#endif /* SOMGD_somInitClass */

/*
 * New Method: somInitMIClass
 */
typedef void   SOMLINK somTP_SOMClass_somInitMIClass(SOMClass *somSelf, 
		long inherit_vars, 
		string className, 
		SOMClass_SOMClassSequence* parentClasses, 
		long dataSize, 
		long dataAlignment, 
		long maxStaticMethods, 
		long majorVersion, 
		long minorVersion);
#pragma linkage(somTP_SOMClass_somInitMIClass, system)
typedef somTP_SOMClass_somInitMIClass *somTD_SOMClass_somInitMIClass;
#define somMD_SOMClass_somInitMIClass "::SOMClass::somInitMIClass"
#define SOMClass_somInitMIClass(somSelf,inherit_vars,className,parentClasses,dataSize,dataAlignment,maxStaticMethods,majorVersion,minorVersion) \
    (SOM_Resolve(somSelf, SOMClass, somInitMIClass) \
	(somSelf,inherit_vars,className,parentClasses,dataSize,dataAlignment,maxStaticMethods,majorVersion,minorVersion))
#ifndef SOMGD_somInitMIClass
    #if (defined(_somInitMIClass) || defined(__somInitMIClass))
        #undef _somInitMIClass
        #undef __somInitMIClass
        #define SOMGD_somInitMIClass 1
    #else
        #define _somInitMIClass SOMClass_somInitMIClass
    #endif /* _somInitMIClass */
#endif /* SOMGD_somInitMIClass */

/*
 * New Method: somAddStaticMethod
 */
typedef somMToken   SOMLINK somTP_SOMClass_somAddStaticMethod(SOMClass *somSelf, 
		somId methodId, 
		somId methodDescriptor, 
		somMethodPtr method, 
		somMethodPtr redispatchStub, 
		somMethodPtr applyStub);
#pragma linkage(somTP_SOMClass_somAddStaticMethod, system)
typedef somTP_SOMClass_somAddStaticMethod *somTD_SOMClass_somAddStaticMethod;
#define somMD_SOMClass_somAddStaticMethod "::SOMClass::somAddStaticMethod"
#define SOMClass_somAddStaticMethod(somSelf,methodId,methodDescriptor,method,redispatchStub,applyStub) \
    (SOM_Resolve(somSelf, SOMClass, somAddStaticMethod) \
	(somSelf,methodId,methodDescriptor,method,redispatchStub,applyStub))
#ifndef SOMGD_somAddStaticMethod
    #if (defined(_somAddStaticMethod) || defined(__somAddStaticMethod))
        #undef _somAddStaticMethod
        #undef __somAddStaticMethod
        #define SOMGD_somAddStaticMethod 1
    #else
        #define _somAddStaticMethod SOMClass_somAddStaticMethod
    #endif /* _somAddStaticMethod */
#endif /* SOMGD_somAddStaticMethod */

/*
 * New Method: somAddDynamicMethod
 */
typedef void   SOMLINK somTP_SOMClass_somAddDynamicMethod(SOMClass *somSelf, 
		somId methodId, 
		somId methodDescriptor, 
		somMethodPtr method, 
		somMethodPtr applyStub);
#pragma linkage(somTP_SOMClass_somAddDynamicMethod, system)
typedef somTP_SOMClass_somAddDynamicMethod *somTD_SOMClass_somAddDynamicMethod;
#define somMD_SOMClass_somAddDynamicMethod "::SOMClass::somAddDynamicMethod"
#define SOMClass_somAddDynamicMethod(somSelf,methodId,methodDescriptor,method,applyStub) \
    (SOM_Resolve(somSelf, SOMClass, somAddDynamicMethod) \
	(somSelf,methodId,methodDescriptor,method,applyStub))
#ifndef SOMGD_somAddDynamicMethod
    #if (defined(_somAddDynamicMethod) || defined(__somAddDynamicMethod))
        #undef _somAddDynamicMethod
        #undef __somAddDynamicMethod
        #define SOMGD_somAddDynamicMethod 1
    #else
        #define _somAddDynamicMethod SOMClass_somAddDynamicMethod
    #endif /* _somAddDynamicMethod */
#endif /* SOMGD_somAddDynamicMethod */

/*
 * New Method: somOverrideSMethod
 */
typedef void   SOMLINK somTP_SOMClass_somOverrideSMethod(SOMClass *somSelf, 
		somId methodId, 
		somMethodPtr method);
#pragma linkage(somTP_SOMClass_somOverrideSMethod, system)
typedef somTP_SOMClass_somOverrideSMethod *somTD_SOMClass_somOverrideSMethod;
#define somMD_SOMClass_somOverrideSMethod "::SOMClass::somOverrideSMethod"
#define SOMClass_somOverrideSMethod(somSelf,methodId,method) \
    (SOM_Resolve(somSelf, SOMClass, somOverrideSMethod) \
	(somSelf,methodId,method))
#ifndef SOMGD_somOverrideSMethod
    #if (defined(_somOverrideSMethod) || defined(__somOverrideSMethod))
        #undef _somOverrideSMethod
        #undef __somOverrideSMethod
        #define SOMGD_somOverrideSMethod 1
    #else
        #define _somOverrideSMethod SOMClass_somOverrideSMethod
    #endif /* _somOverrideSMethod */
#endif /* SOMGD_somOverrideSMethod */

/*
 * New Method: somClassReady
 */
typedef void   SOMLINK somTP_SOMClass_somClassReady(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somClassReady, system)
typedef somTP_SOMClass_somClassReady *somTD_SOMClass_somClassReady;
#define somMD_SOMClass_somClassReady "::SOMClass::somClassReady"
#define SOMClass_somClassReady(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somClassReady) \
	(somSelf))
#ifndef SOMGD_somClassReady
    #if (defined(_somClassReady) || defined(__somClassReady))
        #undef _somClassReady
        #undef __somClassReady
        #define SOMGD_somClassReady 1
    #else
        #define _somClassReady SOMClass_somClassReady
    #endif /* _somClassReady */
#endif /* SOMGD_somClassReady */

/*
 * New Method: somGetApplyStub
 */
typedef somMethodPtr   SOMLINK somTP_SOMClass_somGetApplyStub(SOMClass *somSelf, 
		somId methodId);
#pragma linkage(somTP_SOMClass_somGetApplyStub, system)
typedef somTP_SOMClass_somGetApplyStub *somTD_SOMClass_somGetApplyStub;
#define somMD_SOMClass_somGetApplyStub "::SOMClass::somGetApplyStub"
#define SOMClass_somGetApplyStub(somSelf,methodId) \
    (SOM_Resolve(somSelf, SOMClass, somGetApplyStub) \
	(somSelf,methodId))
#ifndef SOMGD_somGetApplyStub
    #if (defined(_somGetApplyStub) || defined(__somGetApplyStub))
        #undef _somGetApplyStub
        #undef __somGetApplyStub
        #define SOMGD_somGetApplyStub 1
    #else
        #define _somGetApplyStub SOMClass_somGetApplyStub
    #endif /* _somGetApplyStub */
#endif /* SOMGD_somGetApplyStub */

/*
 * New Method: somGetClassData
 */
typedef somClassDataStructure*   SOMLINK somTP_SOMClass_somGetClassData(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetClassData, system)
typedef somTP_SOMClass_somGetClassData *somTD_SOMClass_somGetClassData;
#define somMD_SOMClass_somGetClassData "::SOMClass::somGetClassData"
#define SOMClass_somGetClassData(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somGetClassData) \
	(somSelf))
#ifndef SOMGD_somGetClassData
    #if (defined(_somGetClassData) || defined(__somGetClassData))
        #undef _somGetClassData
        #undef __somGetClassData
        #define SOMGD_somGetClassData 1
    #else
        #define _somGetClassData SOMClass_somGetClassData
    #endif /* _somGetClassData */
#endif /* SOMGD_somGetClassData */

/*
 * New Method: somSetClassData
 */
typedef void   SOMLINK somTP_SOMClass_somSetClassData(SOMClass *somSelf, 
		somClassDataStructure* cds);
#pragma linkage(somTP_SOMClass_somSetClassData, system)
typedef somTP_SOMClass_somSetClassData *somTD_SOMClass_somSetClassData;
#define somMD_SOMClass_somSetClassData "::SOMClass::somSetClassData"
#define SOMClass_somSetClassData(somSelf,cds) \
    (SOM_Resolve(somSelf, SOMClass, somSetClassData) \
	(somSelf,cds))
#ifndef SOMGD_somSetClassData
    #if (defined(_somSetClassData) || defined(__somSetClassData))
        #undef _somSetClassData
        #undef __somSetClassData
        #define SOMGD_somSetClassData 1
    #else
        #define _somSetClassData SOMClass_somSetClassData
    #endif /* _somSetClassData */
#endif /* SOMGD_somSetClassData */

/*
 * New Method: somGetClassMtab
 */
typedef somMethodTab*   SOMLINK somTP_SOMClass_somGetClassMtab(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetClassMtab, system)
typedef somTP_SOMClass_somGetClassMtab *somTD_SOMClass_somGetClassMtab;
#define somMD_SOMClass_somGetClassMtab "::SOMClass::somGetClassMtab"
#define SOMClass_somGetClassMtab(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somGetClassMtab) \
	(somSelf))
#ifndef SOMGD_somGetClassMtab
    #if (defined(_somGetClassMtab) || defined(__somGetClassMtab))
        #undef _somGetClassMtab
        #undef __somGetClassMtab
        #define SOMGD_somGetClassMtab 1
    #else
        #define _somGetClassMtab SOMClass_somGetClassMtab
    #endif /* _somGetClassMtab */
#endif /* SOMGD_somGetClassMtab */

/*
 * New Method: somGetInstanceOffset
 */
typedef long   SOMLINK somTP_SOMClass_somGetInstanceOffset(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetInstanceOffset, system)
typedef somTP_SOMClass_somGetInstanceOffset *somTD_SOMClass_somGetInstanceOffset;
#define somMD_SOMClass_somGetInstanceOffset "::SOMClass::somGetInstanceOffset"
#define SOMClass_somGetInstanceOffset(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somGetInstanceOffset) \
	(somSelf))
#ifndef SOMGD_somGetInstanceOffset
    #if (defined(_somGetInstanceOffset) || defined(__somGetInstanceOffset))
        #undef _somGetInstanceOffset
        #undef __somGetInstanceOffset
        #define SOMGD_somGetInstanceOffset 1
    #else
        #define _somGetInstanceOffset SOMClass_somGetInstanceOffset
    #endif /* _somGetInstanceOffset */
#endif /* SOMGD_somGetInstanceOffset */

/*
 * New Method: somGetInstancePartSize
 */
typedef long   SOMLINK somTP_SOMClass_somGetInstancePartSize(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetInstancePartSize, system)
typedef somTP_SOMClass_somGetInstancePartSize *somTD_SOMClass_somGetInstancePartSize;
#define somMD_SOMClass_somGetInstancePartSize "::SOMClass::somGetInstancePartSize"
#define SOMClass_somGetInstancePartSize(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somGetInstancePartSize) \
	(somSelf))
#ifndef SOMGD_somGetInstancePartSize
    #if (defined(_somGetInstancePartSize) || defined(__somGetInstancePartSize))
        #undef _somGetInstancePartSize
        #undef __somGetInstancePartSize
        #define SOMGD_somGetInstancePartSize 1
    #else
        #define _somGetInstancePartSize SOMClass_somGetInstancePartSize
    #endif /* _somGetInstancePartSize */
#endif /* SOMGD_somGetInstancePartSize */

/*
 * New Method: somGetInstanceSize
 */
typedef long   SOMLINK somTP_SOMClass_somGetInstanceSize(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetInstanceSize, system)
typedef somTP_SOMClass_somGetInstanceSize *somTD_SOMClass_somGetInstanceSize;
#define somMD_SOMClass_somGetInstanceSize "::SOMClass::somGetInstanceSize"
#define SOMClass_somGetInstanceSize(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somGetInstanceSize) \
	(somSelf))
#ifndef SOMGD_somGetInstanceSize
    #if (defined(_somGetInstanceSize) || defined(__somGetInstanceSize))
        #undef _somGetInstanceSize
        #undef __somGetInstanceSize
        #define SOMGD_somGetInstanceSize 1
    #else
        #define _somGetInstanceSize SOMClass_somGetInstanceSize
    #endif /* _somGetInstanceSize */
#endif /* SOMGD_somGetInstanceSize */

/*
 * New Method: somGetInstanceToken
 */
typedef somDToken   SOMLINK somTP_SOMClass_somGetInstanceToken(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetInstanceToken, system)
typedef somTP_SOMClass_somGetInstanceToken *somTD_SOMClass_somGetInstanceToken;
#define somMD_SOMClass_somGetInstanceToken "::SOMClass::somGetInstanceToken"
#define SOMClass_somGetInstanceToken(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somGetInstanceToken) \
	(somSelf))
#ifndef SOMGD_somGetInstanceToken
    #if (defined(_somGetInstanceToken) || defined(__somGetInstanceToken))
        #undef _somGetInstanceToken
        #undef __somGetInstanceToken
        #define SOMGD_somGetInstanceToken 1
    #else
        #define _somGetInstanceToken SOMClass_somGetInstanceToken
    #endif /* _somGetInstanceToken */
#endif /* SOMGD_somGetInstanceToken */

/*
 * New Method: somGetMemberToken
 */
typedef somDToken   SOMLINK somTP_SOMClass_somGetMemberToken(SOMClass *somSelf, 
		long memberOffset, 
		somDToken instanceToken);
#pragma linkage(somTP_SOMClass_somGetMemberToken, system)
typedef somTP_SOMClass_somGetMemberToken *somTD_SOMClass_somGetMemberToken;
#define somMD_SOMClass_somGetMemberToken "::SOMClass::somGetMemberToken"
#define SOMClass_somGetMemberToken(somSelf,memberOffset,instanceToken) \
    (SOM_Resolve(somSelf, SOMClass, somGetMemberToken) \
	(somSelf,memberOffset,instanceToken))
#ifndef SOMGD_somGetMemberToken
    #if (defined(_somGetMemberToken) || defined(__somGetMemberToken))
        #undef _somGetMemberToken
        #undef __somGetMemberToken
        #define SOMGD_somGetMemberToken 1
    #else
        #define _somGetMemberToken SOMClass_somGetMemberToken
    #endif /* _somGetMemberToken */
#endif /* SOMGD_somGetMemberToken */

/*
 * New Method: somGetMethodData
 */
typedef boolean   SOMLINK somTP_SOMClass_somGetMethodData(SOMClass *somSelf, 
		somId methodId, 
		somMethodData* md);
#pragma linkage(somTP_SOMClass_somGetMethodData, system)
typedef somTP_SOMClass_somGetMethodData *somTD_SOMClass_somGetMethodData;
#define somMD_SOMClass_somGetMethodData "::SOMClass::somGetMethodData"
#define SOMClass_somGetMethodData(somSelf,methodId,md) \
    (SOM_Resolve(somSelf, SOMClass, somGetMethodData) \
	(somSelf,methodId,md))
#ifndef SOMGD_somGetMethodData
    #if (defined(_somGetMethodData) || defined(__somGetMethodData))
        #undef _somGetMethodData
        #undef __somGetMethodData
        #define SOMGD_somGetMethodData 1
    #else
        #define _somGetMethodData SOMClass_somGetMethodData
    #endif /* _somGetMethodData */
#endif /* SOMGD_somGetMethodData */

/*
 * New Method: somGetRdStub
 */
typedef somMethodProc*   SOMLINK somTP_SOMClass_somGetRdStub(SOMClass *somSelf, 
		somId methodId);
#pragma linkage(somTP_SOMClass_somGetRdStub, system)
typedef somTP_SOMClass_somGetRdStub *somTD_SOMClass_somGetRdStub;
#define somMD_SOMClass_somGetRdStub "::SOMClass::somGetRdStub"
#define SOMClass_somGetRdStub(somSelf,methodId) \
    (SOM_Resolve(somSelf, SOMClass, somGetRdStub) \
	(somSelf,methodId))
#ifndef SOMGD_somGetRdStub
    #if (defined(_somGetRdStub) || defined(__somGetRdStub))
        #undef _somGetRdStub
        #undef __somGetRdStub
        #define SOMGD_somGetRdStub 1
    #else
        #define _somGetRdStub SOMClass_somGetRdStub
    #endif /* _somGetRdStub */
#endif /* SOMGD_somGetRdStub */

/*
 * New Method: somGetMethodDescriptor
 */
typedef somId   SOMLINK somTP_SOMClass_somGetMethodDescriptor(SOMClass *somSelf, 
		somId methodId);
#pragma linkage(somTP_SOMClass_somGetMethodDescriptor, system)
typedef somTP_SOMClass_somGetMethodDescriptor *somTD_SOMClass_somGetMethodDescriptor;
#define somMD_SOMClass_somGetMethodDescriptor "::SOMClass::somGetMethodDescriptor"
#define SOMClass_somGetMethodDescriptor(somSelf,methodId) \
    (SOM_Resolve(somSelf, SOMClass, somGetMethodDescriptor) \
	(somSelf,methodId))
#ifndef SOMGD_somGetMethodDescriptor
    #if (defined(_somGetMethodDescriptor) || defined(__somGetMethodDescriptor))
        #undef _somGetMethodDescriptor
        #undef __somGetMethodDescriptor
        #define SOMGD_somGetMethodDescriptor 1
    #else
        #define _somGetMethodDescriptor SOMClass_somGetMethodDescriptor
    #endif /* _somGetMethodDescriptor */
#endif /* SOMGD_somGetMethodDescriptor */

/*
 * New Method: somGetMethodIndex
 */
typedef long   SOMLINK somTP_SOMClass_somGetMethodIndex(SOMClass *somSelf, 
		somId id);
#pragma linkage(somTP_SOMClass_somGetMethodIndex, system)
typedef somTP_SOMClass_somGetMethodIndex *somTD_SOMClass_somGetMethodIndex;
#define somMD_SOMClass_somGetMethodIndex "::SOMClass::somGetMethodIndex"
#define SOMClass_somGetMethodIndex(somSelf,id) \
    (SOM_Resolve(somSelf, SOMClass, somGetMethodIndex) \
	(somSelf,id))
#ifndef SOMGD_somGetMethodIndex
    #if (defined(_somGetMethodIndex) || defined(__somGetMethodIndex))
        #undef _somGetMethodIndex
        #undef __somGetMethodIndex
        #define SOMGD_somGetMethodIndex 1
    #else
        #define _somGetMethodIndex SOMClass_somGetMethodIndex
    #endif /* _somGetMethodIndex */
#endif /* SOMGD_somGetMethodIndex */

/*
 * New Method: somGetMethodToken
 */
typedef somMToken   SOMLINK somTP_SOMClass_somGetMethodToken(SOMClass *somSelf, 
		somId methodId);
#pragma linkage(somTP_SOMClass_somGetMethodToken, system)
typedef somTP_SOMClass_somGetMethodToken *somTD_SOMClass_somGetMethodToken;
#define somMD_SOMClass_somGetMethodToken "::SOMClass::somGetMethodToken"
#define SOMClass_somGetMethodToken(somSelf,methodId) \
    (SOM_Resolve(somSelf, SOMClass, somGetMethodToken) \
	(somSelf,methodId))
#ifndef SOMGD_somGetMethodToken
    #if (defined(_somGetMethodToken) || defined(__somGetMethodToken))
        #undef _somGetMethodToken
        #undef __somGetMethodToken
        #define SOMGD_somGetMethodToken 1
    #else
        #define _somGetMethodToken SOMClass_somGetMethodToken
    #endif /* _somGetMethodToken */
#endif /* SOMGD_somGetMethodToken */

/*
 * New Method: somGetName
 */
typedef string   SOMLINK somTP_SOMClass_somGetName(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetName, system)
typedef somTP_SOMClass_somGetName *somTD_SOMClass_somGetName;
#define somMD_SOMClass_somGetName "::SOMClass::somGetName"
#define SOMClass_somGetName(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somGetName) \
	(somSelf))
#ifndef SOMGD_somGetName
    #if (defined(_somGetName) || defined(__somGetName))
        #undef _somGetName
        #undef __somGetName
        #define SOMGD_somGetName 1
    #else
        #define _somGetName SOMClass_somGetName
    #endif /* _somGetName */
#endif /* SOMGD_somGetName */

/*
 * New Method: somGetNthMethodData
 */
typedef boolean   SOMLINK somTP_SOMClass_somGetNthMethodData(SOMClass *somSelf, 
		long n, 
		somMethodData* md);
#pragma linkage(somTP_SOMClass_somGetNthMethodData, system)
typedef somTP_SOMClass_somGetNthMethodData *somTD_SOMClass_somGetNthMethodData;
#define somMD_SOMClass_somGetNthMethodData "::SOMClass::somGetNthMethodData"
#define SOMClass_somGetNthMethodData(somSelf,n,md) \
    (SOM_Resolve(somSelf, SOMClass, somGetNthMethodData) \
	(somSelf,n,md))
#ifndef SOMGD_somGetNthMethodData
    #if (defined(_somGetNthMethodData) || defined(__somGetNthMethodData))
        #undef _somGetNthMethodData
        #undef __somGetNthMethodData
        #define SOMGD_somGetNthMethodData 1
    #else
        #define _somGetNthMethodData SOMClass_somGetNthMethodData
    #endif /* _somGetNthMethodData */
#endif /* SOMGD_somGetNthMethodData */

/*
 * New Method: somGetNthMethodInfo
 */
typedef somId   SOMLINK somTP_SOMClass_somGetNthMethodInfo(SOMClass *somSelf, 
		long n, 
		somId* descriptor);
#pragma linkage(somTP_SOMClass_somGetNthMethodInfo, system)
typedef somTP_SOMClass_somGetNthMethodInfo *somTD_SOMClass_somGetNthMethodInfo;
#define somMD_SOMClass_somGetNthMethodInfo "::SOMClass::somGetNthMethodInfo"
#define SOMClass_somGetNthMethodInfo(somSelf,n,descriptor) \
    (SOM_Resolve(somSelf, SOMClass, somGetNthMethodInfo) \
	(somSelf,n,descriptor))
#ifndef SOMGD_somGetNthMethodInfo
    #if (defined(_somGetNthMethodInfo) || defined(__somGetNthMethodInfo))
        #undef _somGetNthMethodInfo
        #undef __somGetNthMethodInfo
        #define SOMGD_somGetNthMethodInfo 1
    #else
        #define _somGetNthMethodInfo SOMClass_somGetNthMethodInfo
    #endif /* _somGetNthMethodInfo */
#endif /* SOMGD_somGetNthMethodInfo */

/*
 * New Method: somGetNumMethods
 */
typedef long   SOMLINK somTP_SOMClass_somGetNumMethods(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetNumMethods, system)
typedef somTP_SOMClass_somGetNumMethods *somTD_SOMClass_somGetNumMethods;
#define somMD_SOMClass_somGetNumMethods "::SOMClass::somGetNumMethods"
#define SOMClass_somGetNumMethods(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somGetNumMethods) \
	(somSelf))
#ifndef SOMGD_somGetNumMethods
    #if (defined(_somGetNumMethods) || defined(__somGetNumMethods))
        #undef _somGetNumMethods
        #undef __somGetNumMethods
        #define SOMGD_somGetNumMethods 1
    #else
        #define _somGetNumMethods SOMClass_somGetNumMethods
    #endif /* _somGetNumMethods */
#endif /* SOMGD_somGetNumMethods */

/*
 * New Method: somGetNumStaticMethods
 */
typedef long   SOMLINK somTP_SOMClass_somGetNumStaticMethods(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetNumStaticMethods, system)
typedef somTP_SOMClass_somGetNumStaticMethods *somTD_SOMClass_somGetNumStaticMethods;
#define somMD_SOMClass_somGetNumStaticMethods "::SOMClass::somGetNumStaticMethods"
#define SOMClass_somGetNumStaticMethods(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somGetNumStaticMethods) \
	(somSelf))
#ifndef SOMGD_somGetNumStaticMethods
    #if (defined(_somGetNumStaticMethods) || defined(__somGetNumStaticMethods))
        #undef _somGetNumStaticMethods
        #undef __somGetNumStaticMethods
        #define SOMGD_somGetNumStaticMethods 1
    #else
        #define _somGetNumStaticMethods SOMClass_somGetNumStaticMethods
    #endif /* _somGetNumStaticMethods */
#endif /* SOMGD_somGetNumStaticMethods */

/*
 * New Method: somGetParent
 */
typedef SOMClass*   SOMLINK somTP_SOMClass_somGetParent(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetParent, system)
typedef somTP_SOMClass_somGetParent *somTD_SOMClass_somGetParent;
#define somMD_SOMClass_somGetParent "::SOMClass::somGetParent"
#define SOMClass_somGetParent(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somGetParent) \
	(somSelf))
#ifndef SOMGD_somGetParent
    #if (defined(_somGetParent) || defined(__somGetParent))
        #undef _somGetParent
        #undef __somGetParent
        #define SOMGD_somGetParent 1
    #else
        #define _somGetParent SOMClass_somGetParent
    #endif /* _somGetParent */
#endif /* SOMGD_somGetParent */

/*
 * New Method: somGetParents
 */
typedef SOMClass_SOMClassSequence   SOMLINK somTP_SOMClass_somGetParents(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetParents, system)
typedef somTP_SOMClass_somGetParents *somTD_SOMClass_somGetParents;
#define somMD_SOMClass_somGetParents "::SOMClass::somGetParents"
#define SOMClass_somGetParents(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somGetParents) \
	(somSelf))
#ifndef SOMGD_somGetParents
    #if (defined(_somGetParents) || defined(__somGetParents))
        #undef _somGetParents
        #undef __somGetParents
        #define SOMGD_somGetParents 1
    #else
        #define _somGetParents SOMClass_somGetParents
    #endif /* _somGetParents */
#endif /* SOMGD_somGetParents */

/*
 * New Method: somGetPClsMtab
 */
typedef somMethodTabs   SOMLINK somTP_SOMClass_somGetPClsMtab(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetPClsMtab, system)
typedef somTP_SOMClass_somGetPClsMtab *somTD_SOMClass_somGetPClsMtab;
#define somMD_SOMClass_somGetPClsMtab "::SOMClass::somGetPClsMtab"
#define SOMClass_somGetPClsMtab(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somGetPClsMtab) \
	(somSelf))
#ifndef SOMGD_somGetPClsMtab
    #if (defined(_somGetPClsMtab) || defined(__somGetPClsMtab))
        #undef _somGetPClsMtab
        #undef __somGetPClsMtab
        #define SOMGD_somGetPClsMtab 1
    #else
        #define _somGetPClsMtab SOMClass_somGetPClsMtab
    #endif /* _somGetPClsMtab */
#endif /* SOMGD_somGetPClsMtab */

/*
 * New Method: somGetPClsMtabs
 */
typedef somMethodTabs   SOMLINK somTP_SOMClass_somGetPClsMtabs(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetPClsMtabs, system)
typedef somTP_SOMClass_somGetPClsMtabs *somTD_SOMClass_somGetPClsMtabs;
#define somMD_SOMClass_somGetPClsMtabs "::SOMClass::somGetPClsMtabs"
#define SOMClass_somGetPClsMtabs(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somGetPClsMtabs) \
	(somSelf))
#ifndef SOMGD_somGetPClsMtabs
    #if (defined(_somGetPClsMtabs) || defined(__somGetPClsMtabs))
        #undef _somGetPClsMtabs
        #undef __somGetPClsMtabs
        #define SOMGD_somGetPClsMtabs 1
    #else
        #define _somGetPClsMtabs SOMClass_somGetPClsMtabs
    #endif /* _somGetPClsMtabs */
#endif /* SOMGD_somGetPClsMtabs */

/*
 * New Method: somGetVersionNumbers
 */
typedef void   SOMLINK somTP_SOMClass_somGetVersionNumbers(SOMClass *somSelf, 
		long* majorVersion, 
		long* minorVersion);
#pragma linkage(somTP_SOMClass_somGetVersionNumbers, system)
typedef somTP_SOMClass_somGetVersionNumbers *somTD_SOMClass_somGetVersionNumbers;
#define somMD_SOMClass_somGetVersionNumbers "::SOMClass::somGetVersionNumbers"
#define SOMClass_somGetVersionNumbers(somSelf,majorVersion,minorVersion) \
    (SOM_Resolve(somSelf, SOMClass, somGetVersionNumbers) \
	(somSelf,majorVersion,minorVersion))
#ifndef SOMGD_somGetVersionNumbers
    #if (defined(_somGetVersionNumbers) || defined(__somGetVersionNumbers))
        #undef _somGetVersionNumbers
        #undef __somGetVersionNumbers
        #define SOMGD_somGetVersionNumbers 1
    #else
        #define _somGetVersionNumbers SOMClass_somGetVersionNumbers
    #endif /* _somGetVersionNumbers */
#endif /* SOMGD_somGetVersionNumbers */

/*
 * New Method: somSetMethodDescriptor
 */
typedef boolean   SOMLINK somTP_SOMClass_somSetMethodDescriptor(SOMClass *somSelf, 
		somId methodId, 
		somId descriptor);
#pragma linkage(somTP_SOMClass_somSetMethodDescriptor, system)
typedef somTP_SOMClass_somSetMethodDescriptor *somTD_SOMClass_somSetMethodDescriptor;
#define somMD_SOMClass_somSetMethodDescriptor "::SOMClass::somSetMethodDescriptor"
#define SOMClass_somSetMethodDescriptor(somSelf,methodId,descriptor) \
    (SOM_Resolve(somSelf, SOMClass, somSetMethodDescriptor) \
	(somSelf,methodId,descriptor))
#ifndef SOMGD_somSetMethodDescriptor
    #if (defined(_somSetMethodDescriptor) || defined(__somSetMethodDescriptor))
        #undef _somSetMethodDescriptor
        #undef __somSetMethodDescriptor
        #define SOMGD_somSetMethodDescriptor 1
    #else
        #define _somSetMethodDescriptor SOMClass_somSetMethodDescriptor
    #endif /* _somSetMethodDescriptor */
#endif /* SOMGD_somSetMethodDescriptor */

/*
 * New Method: somFindMethod
 */
typedef boolean   SOMLINK somTP_SOMClass_somFindMethod(SOMClass *somSelf, 
		somId methodId, 
		somMethodPtr* m);
#pragma linkage(somTP_SOMClass_somFindMethod, system)
typedef somTP_SOMClass_somFindMethod *somTD_SOMClass_somFindMethod;
#define somMD_SOMClass_somFindMethod "::SOMClass::somFindMethod"
#define SOMClass_somFindMethod(somSelf,methodId,m) \
    (SOM_Resolve(somSelf, SOMClass, somFindMethod) \
	(somSelf,methodId,m))
#ifndef SOMGD_somFindMethod
    #if (defined(_somFindMethod) || defined(__somFindMethod))
        #undef _somFindMethod
        #undef __somFindMethod
        #define SOMGD_somFindMethod 1
    #else
        #define _somFindMethod SOMClass_somFindMethod
    #endif /* _somFindMethod */
#endif /* SOMGD_somFindMethod */

/*
 * New Method: somFindMethodOk
 */
typedef boolean   SOMLINK somTP_SOMClass_somFindMethodOk(SOMClass *somSelf, 
		somId methodId, 
		somMethodPtr* m);
#pragma linkage(somTP_SOMClass_somFindMethodOk, system)
typedef somTP_SOMClass_somFindMethodOk *somTD_SOMClass_somFindMethodOk;
#define somMD_SOMClass_somFindMethodOk "::SOMClass::somFindMethodOk"
#define SOMClass_somFindMethodOk(somSelf,methodId,m) \
    (SOM_Resolve(somSelf, SOMClass, somFindMethodOk) \
	(somSelf,methodId,m))
#ifndef SOMGD_somFindMethodOk
    #if (defined(_somFindMethodOk) || defined(__somFindMethodOk))
        #undef _somFindMethodOk
        #undef __somFindMethodOk
        #define SOMGD_somFindMethodOk 1
    #else
        #define _somFindMethodOk SOMClass_somFindMethodOk
    #endif /* _somFindMethodOk */
#endif /* SOMGD_somFindMethodOk */

/*
 * New Method: somFindSMethod
 */
typedef somMethodPtr   SOMLINK somTP_SOMClass_somFindSMethod(SOMClass *somSelf, 
		somId methodId);
#pragma linkage(somTP_SOMClass_somFindSMethod, system)
typedef somTP_SOMClass_somFindSMethod *somTD_SOMClass_somFindSMethod;
#define somMD_SOMClass_somFindSMethod "::SOMClass::somFindSMethod"
#define SOMClass_somFindSMethod(somSelf,methodId) \
    (SOM_Resolve(somSelf, SOMClass, somFindSMethod) \
	(somSelf,methodId))
#ifndef SOMGD_somFindSMethod
    #if (defined(_somFindSMethod) || defined(__somFindSMethod))
        #undef _somFindSMethod
        #undef __somFindSMethod
        #define SOMGD_somFindSMethod 1
    #else
        #define _somFindSMethod SOMClass_somFindSMethod
    #endif /* _somFindSMethod */
#endif /* SOMGD_somFindSMethod */

/*
 * New Method: somFindSMethodOk
 */
typedef somMethodPtr   SOMLINK somTP_SOMClass_somFindSMethodOk(SOMClass *somSelf, 
		somId methodId);
#pragma linkage(somTP_SOMClass_somFindSMethodOk, system)
typedef somTP_SOMClass_somFindSMethodOk *somTD_SOMClass_somFindSMethodOk;
#define somMD_SOMClass_somFindSMethodOk "::SOMClass::somFindSMethodOk"
#define SOMClass_somFindSMethodOk(somSelf,methodId) \
    (SOM_Resolve(somSelf, SOMClass, somFindSMethodOk) \
	(somSelf,methodId))
#ifndef SOMGD_somFindSMethodOk
    #if (defined(_somFindSMethodOk) || defined(__somFindSMethodOk))
        #undef _somFindSMethodOk
        #undef __somFindSMethodOk
        #define SOMGD_somFindSMethodOk 1
    #else
        #define _somFindSMethodOk SOMClass_somFindSMethodOk
    #endif /* _somFindSMethodOk */
#endif /* SOMGD_somFindSMethodOk */

/*
 * New Method: somLookupMethod
 */
typedef somMethodPtr   SOMLINK somTP_SOMClass_somLookupMethod(SOMClass *somSelf, 
		somId methodId);
#pragma linkage(somTP_SOMClass_somLookupMethod, system)
typedef somTP_SOMClass_somLookupMethod *somTD_SOMClass_somLookupMethod;
#define somMD_SOMClass_somLookupMethod "::SOMClass::somLookupMethod"
#define SOMClass_somLookupMethod(somSelf,methodId) \
    (SOM_Resolve(somSelf, SOMClass, somLookupMethod) \
	(somSelf,methodId))
#ifndef SOMGD_somLookupMethod
    #if (defined(_somLookupMethod) || defined(__somLookupMethod))
        #undef _somLookupMethod
        #undef __somLookupMethod
        #define SOMGD_somLookupMethod 1
    #else
        #define _somLookupMethod SOMClass_somLookupMethod
    #endif /* _somLookupMethod */
#endif /* SOMGD_somLookupMethod */

/*
 * New Method: somCheckVersion
 */
typedef boolean   SOMLINK somTP_SOMClass_somCheckVersion(SOMClass *somSelf, 
		long majorVersion, 
		long minorVersion);
#pragma linkage(somTP_SOMClass_somCheckVersion, system)
typedef somTP_SOMClass_somCheckVersion *somTD_SOMClass_somCheckVersion;
#define somMD_SOMClass_somCheckVersion "::SOMClass::somCheckVersion"
#define SOMClass_somCheckVersion(somSelf,majorVersion,minorVersion) \
    (SOM_Resolve(somSelf, SOMClass, somCheckVersion) \
	(somSelf,majorVersion,minorVersion))
#ifndef SOMGD_somCheckVersion
    #if (defined(_somCheckVersion) || defined(__somCheckVersion))
        #undef _somCheckVersion
        #undef __somCheckVersion
        #define SOMGD_somCheckVersion 1
    #else
        #define _somCheckVersion SOMClass_somCheckVersion
    #endif /* _somCheckVersion */
#endif /* SOMGD_somCheckVersion */

/*
 * New Method: somDescendedFrom
 */
typedef boolean   SOMLINK somTP_SOMClass_somDescendedFrom(SOMClass *somSelf, 
		SOMClass* aClassObj);
#pragma linkage(somTP_SOMClass_somDescendedFrom, system)
typedef somTP_SOMClass_somDescendedFrom *somTD_SOMClass_somDescendedFrom;
#define somMD_SOMClass_somDescendedFrom "::SOMClass::somDescendedFrom"
#define SOMClass_somDescendedFrom(somSelf,aClassObj) \
    (SOM_Resolve(somSelf, SOMClass, somDescendedFrom) \
	(somSelf,aClassObj))
#ifndef SOMGD_somDescendedFrom
    #if (defined(_somDescendedFrom) || defined(__somDescendedFrom))
        #undef _somDescendedFrom
        #undef __somDescendedFrom
        #define SOMGD_somDescendedFrom 1
    #else
        #define _somDescendedFrom SOMClass_somDescendedFrom
    #endif /* _somDescendedFrom */
#endif /* SOMGD_somDescendedFrom */

/*
 * New Method: somSupportsMethod
 */
typedef boolean   SOMLINK somTP_SOMClass_somSupportsMethod(SOMClass *somSelf, 
		somId mId);
#pragma linkage(somTP_SOMClass_somSupportsMethod, system)
typedef somTP_SOMClass_somSupportsMethod *somTD_SOMClass_somSupportsMethod;
#define somMD_SOMClass_somSupportsMethod "::SOMClass::somSupportsMethod"
#define SOMClass_somSupportsMethod(somSelf,mId) \
    (SOM_Resolve(somSelf, SOMClass, somSupportsMethod) \
	(somSelf,mId))
#ifndef SOMGD_somSupportsMethod
    #if (defined(_somSupportsMethod) || defined(__somSupportsMethod))
        #undef _somSupportsMethod
        #undef __somSupportsMethod
        #define SOMGD_somSupportsMethod 1
    #else
        #define _somSupportsMethod SOMClass_somSupportsMethod
    #endif /* _somSupportsMethod */
#endif /* SOMGD_somSupportsMethod */

/*
 * New Method: somDefinedMethod
 */
typedef somMethodPtr   SOMLINK somTP_SOMClass_somDefinedMethod(SOMClass *somSelf, 
		somMToken method);
#pragma linkage(somTP_SOMClass_somDefinedMethod, system)
typedef somTP_SOMClass_somDefinedMethod *somTD_SOMClass_somDefinedMethod;
#define somMD_SOMClass_somDefinedMethod "::SOMClass::somDefinedMethod"
#define SOMClass_somDefinedMethod(somSelf,method) \
    (SOM_Resolve(somSelf, SOMClass, somDefinedMethod) \
	(somSelf,method))
#ifndef SOMGD_somDefinedMethod
    #if (defined(_somDefinedMethod) || defined(__somDefinedMethod))
        #undef _somDefinedMethod
        #undef __somDefinedMethod
        #define SOMGD_somDefinedMethod 1
    #else
        #define _somDefinedMethod SOMClass_somDefinedMethod
    #endif /* _somDefinedMethod */
#endif /* SOMGD_somDefinedMethod */

/*
 * New Method: somOverrideMtab
 */
typedef void   SOMLINK somTP_SOMClass_somOverrideMtab(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somOverrideMtab, system)
typedef somTP_SOMClass_somOverrideMtab *somTD_SOMClass_somOverrideMtab;
#define somMD_SOMClass_somOverrideMtab "::SOMClass::somOverrideMtab"
#define SOMClass_somOverrideMtab(somSelf) \
    (SOM_Resolve(somSelf, SOMClass, somOverrideMtab) \
	(somSelf))
#ifndef SOMGD_somOverrideMtab
    #if (defined(_somOverrideMtab) || defined(__somOverrideMtab))
        #undef _somOverrideMtab
        #undef __somOverrideMtab
        #define SOMGD_somOverrideMtab 1
    #else
        #define _somOverrideMtab SOMClass_somOverrideMtab
    #endif /* _somOverrideMtab */
#endif /* SOMGD_somOverrideMtab */
#ifndef SOM_DONT_USE_INHERITED_MACROS
#define SOMClass_somDefaultInit SOMObject_somDefaultInit
#define SOMClass_somDestruct SOMObject_somDestruct
#define SOMClass_somDefaultCopyInit SOMObject_somDefaultCopyInit
#define SOMClass_somDefaultAssign SOMObject_somDefaultAssign
#define SOMClass_somDefaultConstCopyInit SOMObject_somDefaultConstCopyInit
#define SOMClass_somDefaultVCopyInit SOMObject_somDefaultVCopyInit
#define SOMClass_somDefaultConstVCopyInit SOMObject_somDefaultConstVCopyInit
#define SOMClass_somDefaultConstAssign SOMObject_somDefaultConstAssign
#define SOMClass_somDefaultVAssign SOMObject_somDefaultVAssign
#define SOMClass_somDefaultConstVAssign SOMObject_somDefaultConstVAssign
#define SOMClass_somInit SOMObject_somInit
#define SOMClass_somFree SOMObject_somFree
#define SOMClass_somUninit SOMObject_somUninit
#define SOMClass_somGetClass SOMObject_somGetClass
#define SOMClass_somGetClassName SOMObject_somGetClassName
#define SOMClass_somGetSize SOMObject_somGetSize
#define SOMClass_somIsA SOMObject_somIsA
#define SOMClass_somIsInstanceOf SOMObject_somIsInstanceOf
#define SOMClass_somRespondsTo SOMObject_somRespondsTo
#define SOMClass_somDispatch SOMObject_somDispatch
#define SOMClass_somClassDispatch SOMObject_somClassDispatch
#define SOMClass_somCastObj SOMObject_somCastObj
#define SOMClass_somResetObj SOMObject_somResetObj
#define SOMClass_somPrintSelf SOMObject_somPrintSelf
#define SOMClass_somDumpSelf SOMObject_somDumpSelf
#define SOMClass_somDumpSelfInt SOMObject_somDumpSelfInt
#endif /* SOM_DONT_USE_INHERITED_MACROS */

#endif       /* SOM_SOMClass_h */
