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

/*
 *  96F8647, 96F8648, 96F8850 (C) Copyright IBM Corp. 1992, 1994
 *  All Rights Reserved
 *  Licensed Materials - Property of IBM
 *   SOMObject: System Object Model root class
 */


#ifndef SOM_SOMClass_h
#define SOM_SOMClass_h


/*
 * The SOM_STRICT_IDL macro means that we can ignore stars
 * in our declarations of objects.
 */
#define SOM_STRICT_IDL 1


#include <som.h>
#ifndef SOM_IMPORTEXPORT_som_somcls
#ifdef SOM_DLL_som
	/* export semantics */
	#if defined(SOM_DEFFILE_som)\
	||(defined(SOM_DEFFILE_BY_DEFAULT)&&!defined(SOM_NODEFFILE_som))\
	|| !defined(SOM_Module_somcls_Source)
	#define SOM_IMPORTEXPORT_som_somcls
	#else
	#define SOM_IMPORTEXPORT_som_somcls SOMDLLEXPORT
	#endif
#else
	#define SOM_IMPORTEXPORT_som_somcls SOMDLLIMPORT
#endif
#endif

/*
 * -- 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
/*
 *   SOMClass is the root SOM metaclass. Because it is a metaclass, its
 *   instances are classes. Because it is the root metaclass, all other
 *   metaclasses inherit its methods.
 * 
 *   SOMClass defines the default behavior for SOM class objects
 *   accessed using methods available through the SOMClass interface.
 *   Other metaclasses are allowed to specialize the behavior of
 *   classes by introducing new methods and overriding SOMClass
 *   methods.
 * 
 *   Generally, when SOMClass methods are overridden by user-defined
 *   metaclasses, a relative parent call should be made at some point to
 *   allow the default behavior implemented by SOMClass to execute
 *   (in addition to whatever additional behavior might be desired by the
 *   new metaclasses).
 * 
 */

/*
 * Include Parent Bindings
 */
#ifndef SOM_SOMObject_h
#ifdef SOMLOCALINCLUDES
#include "somobj.h"
#else
#include <somobj.h>
#endif
#endif

/*
 * 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 6

/*
 * Declare the class creation procedure
 */
SOMEXTERN SOM_IMPORTEXPORT_som_somcls SOMClass  SOMLINK SOMClassNewClass(integer4 somtmajorVersion,
		integer4 somtminorVersion);

/*
 * Declare the ABI 2 ClassData structure
 */
SOMEXTERN struct SOMClassClassDataStructure {
	SOMClass classObject;
	somMToken somNew;
	somMToken somRenew;
	somMToken somcPrivate1;
	somMToken somClassReady;
	somMToken somGetName;
	somMToken somcPrivate2;
	somMToken somDescendedFrom;
	somMToken somCheckVersion;
	somMToken somFindMethod;
	somMToken somFindMethodOk;
	somMToken somSupportsMethod;
	somMToken somGetNumMethods;
	somMToken somGetInstanceSize;
	somMToken somcPrivate3;
	somMToken somGetInstancePartSize;
	somMToken somGetMethodIndex;
	somMToken somGetNumStaticMethods;
	somMToken somGetPClsMtab;
	somMToken somGetClassMtab;
	somMToken somAddStaticMethod;
	somMToken somOverrideSMethod;
	somMToken somAddDynamicMethod;
	somMToken somcUnused1;
	somMToken somGetApplyStub;
	somMToken somFindSMethod;
	somMToken somFindSMethodOk;
	somMToken somGetMethodDescriptor;
	somMToken somGetNthMethodInfo;
	somMToken somSetClassData;
	somMToken somGetClassData;
	somMToken somNewNoInit;
	somMToken somRenewNoInit;
	somMToken somGetInstanceToken;
	somMToken somGetMemberToken;
	somMToken somcUnused2;
	somMToken somGetMethodData;
	somMToken somOverrideMtab;
	somMToken somGetMethodToken;
	somMToken somGetParents;
	somMToken somUnused3;
	somMToken somInitMIClass;
	somMToken somGetVersionNumbers;
	somMToken somLookupMethod;
	somMToken _get_somInstanceDataOffsets;
	somMToken somRenewNoZero;
	somMToken somRenewNoInitNoZero;
	somMToken somAllocate;
	somMToken somDeallocate;
	somMToken somGetRdStub;
	somMToken somGetNthMethodData;
	somMToken somcPrivate8;
	somMToken somcPrivate9;
	somMToken _get_somDirectInitClasses;
	somMToken somcPrivate10;
	somMToken somcPrivate11;
	somMToken somcPrivate12;
	somMToken somcPrivate13;
	somMToken somcPrivate14;
	somMToken somMethodImplOwner;
	somMToken somcPrivate15;
	somMToken somcPrivate16;
	somMToken somDefinedMethod;
	somMToken somcPrivate17;
	somMToken somcPrivate18;
	somMToken somcPrivate19;
	somMethodProc *somClassOfNewClassWithParents;
	somMToken somcPrivate20;
	somMToken somcUnused5;
	somMToken somcUnused6;
	somMToken somcUnused7;
	somMToken _get_somDataAlignment;
	somMToken somcPrivate21;
	somMToken somcUnused8;
	somMToken somcPrivate22;
	somMToken somcUnused9;
	somMToken somcUnused10;
	somMToken somGetMarshalPlan;
	somMToken somcUnused11;
	somMToken somPrivate23;
	somMToken somJoin;
	somMToken somEndow;
} SOM_IMPORTEXPORT_som_somcls SOMDLINK SOMClassClassData;

/*
 * Declare the ABI 2 CClassData structure
 */
SOMEXTERN struct SOMClassCClassDataStructure {
	somMethodTabs parentMtab;
	somDToken instanceDataToken;
} SOM_IMPORTEXPORT_som_somcls SOMDLINK SOMClassCClassData;

/*
 * Class Object and Method Token Macros
 */
#define _SOMCLASS_SOMClass (SOMClassClassData.classObject)
#ifndef SOMGD_SOMClass
    #if (defined(_SOMClass) || defined(__SOMClass))
        #undef _SOMClass
        #undef __SOMClass
        #define SOMGD_SOMClass 1
    #else
        #define _SOMClass _SOMCLASS_SOMClass
    #endif /* _SOMClass */
#endif /* SOMGD_SOMClass */
#define SOMClass_classObj _SOMCLASS_SOMClass
#define _SOMMTOKEN_SOMClass(method) ((somMToken)SOMClassClassData.method)

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

/*
 * New Method: somNew
 */
typedef SOMObject   SOMLINK somTP_SOMClass_somNew(SOMClass somSelf);
typedef somTP_SOMClass_somNew *somTD_SOMClass_somNew;
/*
 *  Uses somAllocate to allocate storage for a new
 *  instance of the receiving class, calls somRenewNoInitNoZero
 *  to load the new object's method table pointer, and then
 *  calls somDefaultInit to initialize the new object.
 *  Overrides are not expected. NULL is returned on failure.
 */
#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);
typedef somTP_SOMClass_somNewNoInit *somTD_SOMClass_somNewNoInit;
/*
 *  Equivalent to somNew except that somDefaultInit is not called.
 *  Overrides are not expected.
 */
#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);
typedef somTP_SOMClass_somRenew *somTD_SOMClass_somRenew;
/*
 *  Equivalent to somNew except that storage is not allocated.
 *  <obj> is taken as the address of the new object.
 *  Overrides are not expected.
 */
#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);
typedef somTP_SOMClass_somRenewNoInit *somTD_SOMClass_somRenewNoInit;
/*
 *  Equivalent to somRenew except that somDefaultInit is not called.
 *  Overrides are not expected.
 */
#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);
typedef somTP_SOMClass_somRenewNoZero *somTD_SOMClass_somRenewNoZero;
/*
 *  Equivalent to somRenew except that memory is not zeroed out.
 *  Overrides are not expected.
 */
#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);
typedef somTP_SOMClass_somRenewNoInitNoZero *somTD_SOMClass_somRenewNoInitNoZero;
/*
 *  This method loads an object's method table pointer, turning raw
 *  memory into an uninitialized SOM object. The other somNew and
 *  somRenew methods all call this method, so metaclasses can override
 *  this method to track object creation if this is desired. A relative
 *  parent call should be done from overrides.
 */
#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 somToken   SOMLINK somTP_SOMClass_somAllocate(SOMClass somSelf, 
		long size);
typedef somTP_SOMClass_somAllocate *somTD_SOMClass_somAllocate;
/*
 *  nonstatic
 *  Uses the memory allocation routine associated with the receiving
 *  class to allocate memory to hold an object of the indicated size.
 *  NULL is returned on failure. The default allocation routine uses
 *  SOMMalloc.
 */
#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, 
		somToken memptr);
typedef somTP_SOMClass_somDeallocate *somTD_SOMClass_somDeallocate;
/*
 *  nonstatic
 *  Uses the memory deallocation routine associated with the receiving
 *  class to deallocate memory beginning at the address indicated by
 *  memptr. The first word of this memory (normally a method table
 *  pointer) is loaded with NULL. The deallocation routine receives
 *  a void* (memptr) and a size_t (size) as arguments.
 */
#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: somJoin
 */
typedef SOMClass   SOMLINK somTP_SOMClass_somJoin(SOMClass somSelf, 
		SOMClass secondParent, 
		string nameOfNewClass);
typedef somTP_SOMClass_somJoin *somTD_SOMClass_somJoin;
/*
 *  Creates the multiple inheritance join of the target class and the
 *  secondParent with the class name nameOfNewClass.
 */
#define somMD_SOMClass_somJoin "::SOMClass::somJoin"
#define SOMClass_somJoin(somSelf,secondParent,nameOfNewClass) \
    (SOM_Resolve(somSelf, SOMClass, somJoin) \
	(somSelf,secondParent,nameOfNewClass))
#ifndef SOMGD_somJoin
    #if (defined(_somJoin) || defined(__somJoin))
        #undef _somJoin
        #undef __somJoin
        #define SOMGD_somJoin 1
    #else
        #define _somJoin SOMClass_somJoin
    #endif /* _somJoin */
#endif /* SOMGD_somJoin */

/*
 * New Method: somEndow
 */
typedef SOMClass   SOMLINK somTP_SOMClass_somEndow(SOMClass somSelf, 
		SOMClass parent, 
		string nameOfNewClass);
typedef somTP_SOMClass_somEndow *somTD_SOMClass_somEndow;
/*
 *  Creates the a subclass of parent with the class name nameOfNewClass
 *  where the target class is an added metaclass constraint.
 *  NOTE: this means that the target class must be a metaclass.
 */
#define somMD_SOMClass_somEndow "::SOMClass::somEndow"
#define SOMClass_somEndow(somSelf,parent,nameOfNewClass) \
    (SOM_Resolve(somSelf, SOMClass, somEndow) \
	(somSelf,parent,nameOfNewClass))
#ifndef SOMGD_somEndow
    #if (defined(_somEndow) || defined(__somEndow))
        #undef _somEndow
        #undef __somEndow
        #define SOMGD_somEndow 1
    #else
        #define _somEndow SOMClass_somEndow
    #endif /* _somEndow */
#endif /* SOMGD_somEndow */

/*
 * Direct call procedure
 */
typedef SOMClass   SOMLINK somTP_SOMClass_somClassOfNewClassWithParents(string newClassName, 
		SOMClass_SOMClassSequence* parents, 
		SOMClass explicitMeta);
typedef somTP_SOMClass_somClassOfNewClassWithParents *somTD_SOMClass_somClassOfNewClassWithParents;
#define SOMClass_somClassOfNewClassWithParents ((somTD_SOMClass_somClassOfNewClassWithParents) SOMClassClassData.somClassOfNewClassWithParents)
#ifndef SOMGD_somClassOfNewClassWithParents
    #if (defined(_somClassOfNewClassWithParents) || defined(__somClassOfNewClassWithParents))
        #undef _somClassOfNewClassWithParents
        #undef __somClassOfNewClassWithParents
        #define SOMGD_somClassOfNewClassWithParents 1
    #else
        #define _somClassOfNewClassWithParents SOMClass_somClassOfNewClassWithParents
    #endif /* _somClassOfNewClassWithParents */
#endif /* SOMGD_somClassOfNewClassWithParents */

/*
 * New Method: somInitMIClass
 */
typedef void   SOMLINK somTP_SOMClass_somInitMIClass(SOMClass somSelf, 
		unsigned long inherit_vars, 
		string className, 
		SOMClass_SOMClassSequence* parentClasses, 
		long dataSize, 
		long dataAlignment, 
		long maxNDMethods, 
		long majorVersion, 
		long minorVersion);
typedef somTP_SOMClass_somInitMIClass *somTD_SOMClass_somInitMIClass;
/*
 *  Perform inheritance into a class object from the specified parent
 *  classes, determine the layout of instances for the receiving class, and
 *  determine the layout of the instance method table for the receiving class.
 *  Overrides should perform relative parent calls.
 */
#define somMD_SOMClass_somInitMIClass "::SOMClass::somInitMIClass"
#define SOMClass_somInitMIClass(somSelf,inherit_vars,className,parentClasses,dataSize,dataAlignment,maxNDMethods,majorVersion,minorVersion) \
    (SOM_Resolve(somSelf, SOMClass, somInitMIClass) \
	(somSelf,inherit_vars,className,parentClasses,dataSize,dataAlignment,maxNDMethods,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);
typedef somTP_SOMClass_somAddStaticMethod *somTD_SOMClass_somAddStaticMethod;
/*
 *  Introduce a new static method with the indicated methodId into
 *  the receiving class. Overrides should perform relative parent calls.
 */
#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: somOverrideSMethod
 */
typedef void   SOMLINK somTP_SOMClass_somOverrideSMethod(SOMClass somSelf, 
		somId methodId, 
		somMethodPtr method);
typedef somTP_SOMClass_somOverrideSMethod *somTD_SOMClass_somOverrideSMethod;
/*
 *  Replace the implementation for the indicated method in the instances
 *  of the receiving class. Overrides should perform relative parent calls.
 */
#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);
typedef somTP_SOMClass_somClassReady *somTD_SOMClass_somClassReady;
/*
 *  This method is invoked when all of the static initialization for
 *  the class has been finished (i.e., its instance method table has
 *  been loaded) and allows final setup for the class to be done. When
 *  overriding this method, all setup should be done before doing a
 *  relative pcall, since SOMClass's implementation will register the
 *  class with the class manager.
 */
#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: somAddDynamicMethod
 */
typedef void   SOMLINK somTP_SOMClass_somAddDynamicMethod(SOMClass somSelf, 
		somId methodId, 
		somId methodDescriptor, 
		somMethodPtr methodImpl, 
		somMethodPtr applyStub);
typedef somTP_SOMClass_somAddDynamicMethod *somTD_SOMClass_somAddDynamicMethod;
/*
 *  If the receiving class supports a static method with the indicated
 *  methodId, then override the method with the indicated implementation.
 *  Otherwise, a dynamic method with the indicated methodId is added to
 *  the receiving class.
 */
#define somMD_SOMClass_somAddDynamicMethod "::SOMClass::somAddDynamicMethod"
#define SOMClass_somAddDynamicMethod(somSelf,methodId,methodDescriptor,methodImpl,applyStub) \
    (SOM_Resolve(somSelf, SOMClass, somAddDynamicMethod) \
	(somSelf,methodId,methodDescriptor,methodImpl,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: somGetName
 */
typedef string   SOMLINK somTP_SOMClass_somGetName(SOMClass somSelf);
typedef somTP_SOMClass_somGetName *somTD_SOMClass_somGetName;
/*
 *  This object's class name as a NULL terminated string.
 *  Overrides are not expected.
 */
#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: somGetVersionNumbers
 */
typedef void   SOMLINK somTP_SOMClass_somGetVersionNumbers(SOMClass somSelf, 
		long* majorVersion, 
		long* minorVersion);
typedef somTP_SOMClass_somGetVersionNumbers *somTD_SOMClass_somGetVersionNumbers;
/*
 *  Returns the class' major and minor version numbers in the corresponding
 *  output parameters.
 *  Overrides are not expected.
 */
#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: somGetNumMethods
 */
typedef long   SOMLINK somTP_SOMClass_somGetNumMethods(SOMClass somSelf);
typedef somTP_SOMClass_somGetNumMethods *somTD_SOMClass_somGetNumMethods;
/*
 *  The number of methods currently supported by this class,
 *  including inherited methods (static, nonstatic, and dynamic).
 *  Overrides are not expected.
 */
#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);
typedef somTP_SOMClass_somGetNumStaticMethods *somTD_SOMClass_somGetNumStaticMethods;
/*
 *  The number of nondynamic methods that this class has.  Can
 *  be used by a child class when initializing its method table.
 *  Overrides are not expected.
 */
#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: somGetParents
 */
typedef SOMClass_SOMClassSequence   SOMLINK somTP_SOMClass_somGetParents(SOMClass somSelf);
typedef somTP_SOMClass_somGetParents *somTD_SOMClass_somGetParents;
/*
 *  Returns a sequence containing pointers to the receiver's parent classes.
 *  Caller is responsible for using SOMFree on the returned sequence buffer.
 *  Overrides are not expected.
 */
#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: somGetInstanceSize
 */
typedef long   SOMLINK somTP_SOMClass_somGetInstanceSize(SOMClass somSelf);
typedef somTP_SOMClass_somGetInstanceSize *somTD_SOMClass_somGetInstanceSize;
/*
 *  The total size of an instance of the receiving class.
 *  Overrides are not expected.
 */
#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: somGetInstancePartSize
 */
typedef long   SOMLINK somTP_SOMClass_somGetInstancePartSize(SOMClass somSelf);
typedef somTP_SOMClass_somGetInstancePartSize *somTD_SOMClass_somGetInstancePartSize;
/*
 *  The size in bytes of the instance data introduced by the receiving
 *  class.
 *  Overrides are not expected.
 */
#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: somGetInstanceToken
 */
typedef somDToken   SOMLINK somTP_SOMClass_somGetInstanceToken(SOMClass somSelf);
typedef somTP_SOMClass_somGetInstanceToken *somTD_SOMClass_somGetInstanceToken;
/*
 *  A data token that identifies the introduced portion of this class
 *  within itself or any derived class.  This token can be subsequently
 *  passed to the run-time somDataResolve function to locate the instance
 *  data introduced by this class in any object derived from this class.
 *  Overrides are not expected.
 */
#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);
typedef somTP_SOMClass_somGetMemberToken *somTD_SOMClass_somGetMemberToken;
/*
 *  Returns a data token that for the data member at offset
 *  "memberOffset" within the introduced portion of the class identified
 *  by instanceToken.  The instance token must have been obtained from a
 *  previous invocation of somGetInstanceToken.  The returned member
 *  token can be subsequently passed to the run-time somDataResolve
 *  function to locate the data member.
 *  Overrides are not expected.
 */
#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: somGetClassMtab
 */
typedef somMethodTab*   SOMLINK somTP_SOMClass_somGetClassMtab(SOMClass somSelf);
typedef somTP_SOMClass_somGetClassMtab *somTD_SOMClass_somGetClassMtab;
/*
 *  A pointer to the method table used by instances of this class. This
 *  method was misnamed; it should have been called somGetInstanceMtab.
 *  Overrides are not expected.
 */
#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: somGetClassData
 */
typedef somClassDataStructurePtr   SOMLINK somTP_SOMClass_somGetClassData(SOMClass somSelf);
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, 
		somClassDataStructurePtr cds);
typedef somTP_SOMClass_somSetClassData *somTD_SOMClass_somSetClassData;
/*
 *  The pointer to the static <className>ClassData structure.
 *  Overrides are not expected.
 */
#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: _get_somDataAlignment
 */
typedef long   SOMLINK somTP_SOMClass__get_somDataAlignment(SOMClass somSelf);
typedef somTP_SOMClass__get_somDataAlignment *somTD_SOMClass__get_somDataAlignment;
/*
 *  The alignment required for the instance data structure
 *  introduced by the receiving class.
 *  Overrides are not expected.
 */
#define somMD_SOMClass__get_somDataAlignment "::SOMClass::_get_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);
typedef somTP_SOMClass__get_somInstanceDataOffsets *somTD_SOMClass__get_somInstanceDataOffsets;
/*
 *  A sequence of the instance data offsets for all classes used in
 *  the derivation of the receiving class (including the receiver).
 *  The caller is responsible for freeing the returned sequence buffer.
 *  Overrides are not expected.
 */
#define somMD_SOMClass__get_somInstanceDataOffsets "::SOMClass::_get_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);
typedef somTP_SOMClass__get_somDirectInitClasses *somTD_SOMClass__get_somDirectInitClasses;
/*
 *  The ancestors whose initializers the receiving class wants to
 *  directly invoke. Caller is responsible for freeing the returned
 *  sequence buffer.
 *  Overrides are not expected.
 */
#define somMD_SOMClass__get_somDirectInitClasses "::SOMClass::_get_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: somGetMethodDescriptor
 */
typedef somId   SOMLINK somTP_SOMClass_somGetMethodDescriptor(SOMClass somSelf, 
		somId methodId);
typedef somTP_SOMClass_somGetMethodDescriptor *somTD_SOMClass_somGetMethodDescriptor;
/*
 *  Returns the method descriptor for the indicated method.    If
 *  this object does not support the indicated method then NULL is
 *  returned.
 *  Overrides are not expected.
 */
#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);
typedef somTP_SOMClass_somGetMethodIndex *somTD_SOMClass_somGetMethodIndex;
/*
 *  Returns the index for the specified method. (A number that may
 *  change if any methods are added or deleted to this class object or
 *  any of its ancestors).  This number is the basis for other calls to
 *  get info about the method. Indexes start at 0. A -1 is returned if
 *  the method cannot be found.
 *  Overrides are not expected.
 */
#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);
typedef somTP_SOMClass_somGetMethodToken *somTD_SOMClass_somGetMethodToken;
/*
 *  Returns the specified method's access token. This token can then
 *  be passed to method resolution routines, which use the token
 *  to select a method pointer from a method table.
 *  Overrides are not expected.
 */
#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: somGetNthMethodInfo
 */
typedef somId   SOMLINK somTP_SOMClass_somGetNthMethodInfo(SOMClass somSelf, 
		long n, 
		somId* descriptor);
typedef somTP_SOMClass_somGetNthMethodInfo *somTD_SOMClass_somGetNthMethodInfo;
/*
 *  Returns the id of the <n>th method if one exists and NULL
 *  otherwise.
 * 
 *  The ordering of the methods is unpredictable, but will not change
 *  unless some change is made to the class or one of its ancestor classes.
 * 
 *  See CORBA documentation for info on method descriptors.
 *  Overrides are not expected.
 */
#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: somGetMarshalPlan
 */
typedef somToken   SOMLINK somTP_SOMClass_somGetMarshalPlan(SOMClass somSelf, 
		somId methodId);
typedef somTP_SOMClass_somGetMarshalPlan *somTD_SOMClass_somGetMarshalPlan;
/*
 *  uses namelookup from the target class to locate a method that has the
 *  indicated methodId, and returns that method's marshal plan if there
 *  is one. Otherwise, null is returned.
 *  Overrides are not expected.
 */
#define somMD_SOMClass_somGetMarshalPlan "::SOMClass::somGetMarshalPlan"
#define SOMClass_somGetMarshalPlan(somSelf,methodId) \
    (SOM_Resolve(somSelf, SOMClass, somGetMarshalPlan) \
	(somSelf,methodId))
#ifndef SOMGD_somGetMarshalPlan
    #if (defined(_somGetMarshalPlan) || defined(__somGetMarshalPlan))
        #undef _somGetMarshalPlan
        #undef __somGetMarshalPlan
        #define SOMGD_somGetMarshalPlan 1
    #else
        #define _somGetMarshalPlan SOMClass_somGetMarshalPlan
    #endif /* _somGetMarshalPlan */
#endif /* SOMGD_somGetMarshalPlan */

/*
 * New Method: somGetMethodData
 */
typedef boolean   SOMLINK somTP_SOMClass_somGetMethodData(SOMClass somSelf, 
		somId methodId, 
		somMethodData* md);
typedef somTP_SOMClass_somGetMethodData *somTD_SOMClass_somGetMethodData;
/*
 *  If the receiving class supports a method with the specified somId,
 *  then the method data pointed to by md is loaded with information
 *  for the method and 1 (TRUE) is returned. Otherwise md->id is set to
 *  NULL and 0 (FALSE) is returned. On success, the md->method field is
 *  loaded with a the address of a function that invokes the method
 *  implementation appropriate for instances of the receiving class.
 *  Successive calls for the same method are *not* guaranteed to load
 *  md->method with the same address. All somId-based method resolution
 *  routines use the md->method address computed by somGetMethodData
 *  as their resolution result.
 */
#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: somGetNthMethodData
 */
typedef boolean   SOMLINK somTP_SOMClass_somGetNthMethodData(SOMClass somSelf, 
		long n, 
		somMethodData* md);
typedef somTP_SOMClass_somGetNthMethodData *somTD_SOMClass_somGetNthMethodData;
/*
 *  This method is similar to somGetMethodData. The method
 *  whose data is returned is the method for which the receiving
 *  class would return n from somGetMethodIndex.
 */
#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: somFindMethod
 */
typedef boolean   SOMLINK somTP_SOMClass_somFindMethod(SOMClass somSelf, 
		somId methodId, 
		somMethodPtr* m);
typedef somTP_SOMClass_somFindMethod *somTD_SOMClass_somFindMethod;
/*
 *  If the receiving class supports a method with the specified
 *  methodId, m is set to the address of a function that
 *  will invoke the method implementation appropriate for instances
 *  of the receiving class and 1 (TRUE) is returned. Otherwise, m is
 *  set to NULL and 0 (FALSE) is returned. Successive calls on the
 *  same class with the same arguments are not guaranteed to return
 *  the same function address.
 *  Overrides are not expected.
 */
#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);
typedef somTP_SOMClass_somFindMethodOk *somTD_SOMClass_somFindMethodOk;
/*
 *  Just like <somFindMethod> except that if the method is not
 *  supported then an error is raised and execution is halted.
 *  Overrides are not expected.
 */
#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);
typedef somTP_SOMClass_somFindSMethod *somTD_SOMClass_somFindSMethod;
/*
 *  Finds the indicated method, which must be a static method supported
 *  by this class, and returns a pointer to a function that will
 *  invoke the method implementation appropriate for instances of the
 *  receiving class. If the method is not supported by the receiver
 *  (as a static method or at all) then a NULL pointer is returned.
 *  Overrides are not expected.
 */
#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);
typedef somTP_SOMClass_somFindSMethodOk *somTD_SOMClass_somFindSMethodOk;
/*
 *  Uses <somFindSMethod>, and raises an error if the result is NULL.
 *  Overrides are not expected.
 */
#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);
typedef somTP_SOMClass_somLookupMethod *somTD_SOMClass_somLookupMethod;
/*
 *  Like <somFindSMethodOK>, but without restriction to static methods.
 *  Overrides are not expected.
 */
#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: somGetApplyStub
 */
typedef somMethodPtr   SOMLINK somTP_SOMClass_somGetApplyStub(SOMClass somSelf, 
		somId methodId);
typedef somTP_SOMClass_somGetApplyStub *somTD_SOMClass_somGetApplyStub;
/*
 *  Returns the apply stub associated with the specified method,
 *  if one exists; otherwise NULL is returned. This method is obsolete,
 *  and retained for binary compatability. In SOMr2, users never access
 *  apply stubs directly; The function somApply is used to invoke apply
 *  stubs. See somApply documentation for further information on apply
 *  stubs, and see somAddStaticMethod documentation for information
 *  on how apply stubs are registered by class implementations.
 *  Overrides are not expected.
 */
#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: somGetPClsMtab
 */
typedef somMethodTabs   SOMLINK somTP_SOMClass_somGetPClsMtab(SOMClass somSelf);
typedef somTP_SOMClass_somGetPClsMtab *somTD_SOMClass_somGetPClsMtab;
/*
 *  Returns a list of the method tables of this class's parent classes in the
 *  specific format required by somParentNumResolve (for making parent method
 *  calls. The first entry on the list is actually the method table of the
 *  receiving class. Because the CClassData structure contains this list, the
 *  method table for any class with a CClassData structure is statically
 *  available. This method now returns a list because older SI emitters load
 *  CClassData.parentMtab with the result of this call, and the new runtime
 *  requires a list of classes in that position.
 *  Overrides are not expected.
 */
#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: somCheckVersion
 */
typedef boolean   SOMLINK somTP_SOMClass_somCheckVersion(SOMClass somSelf, 
		long majorVersion, 
		long minorVersion);
typedef somTP_SOMClass_somCheckVersion *somTD_SOMClass_somCheckVersion;
/*
 *  Returns 1 (true) if the implementation of this class is
 *  compatible with the specified major and minor version number and
 *  false (0) otherwise.  An implementation is compatible with the
 *  specified version numbers if it has the same major version number
 *  and a minor version number that is equal to or greater than
 *  <minorVersion>.    The major, minor version number pair (0,0) is
 *  considered to match any version.  This method is usually called
 *  immediately after creating the class object to verify that a
 *  dynamically loaded class definition is compatible with a using
 *  application.
 *  Overrides are not expected.
 */
#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);
typedef somTP_SOMClass_somDescendedFrom *somTD_SOMClass_somDescendedFrom;
/*
 *  Returns 1 (true) if <self> is a descendent class of <aClassObj> and
 *  0 (false) otherwise.  Note: a class object is considered to be
 *  descended itself for the purposes of this method.
 *  Overrides are not expected.
 */
#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);
typedef somTP_SOMClass_somSupportsMethod *somTD_SOMClass_somSupportsMethod;
/*
 *  Returns 1 (true) if the indicated method is supported by this
 *  class and 0 (false) otherwise.
 *  Overrides are not expected.
 */
#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);
typedef somTP_SOMClass_somDefinedMethod *somTD_SOMClass_somDefinedMethod;
/*
 *  If the receiving class explicitly defines an implementation for
 *  the indicated method, then the address of a function that will invoke
 *  this implementation is returned. Otherwise NULL is returned.
 *  Overrides are not expected.
 */
#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: somMethodImplOwner
 */
typedef SOMClass   SOMLINK somTP_SOMClass_somMethodImplOwner(SOMClass somSelf, 
		somMethodData* md);
typedef somTP_SOMClass_somMethodImplOwner *somTD_SOMClass_somMethodImplOwner;
/*
 *  Returns the owner of the implementation of the method indicated by md
 *  for instances of the receiving class, and loads md->method with a
 *  pointer to the method implementation. If the receiving class doesn't
 *  support the method, md->method is not changed, and null is returned.
 *  Implementations that are automatically installed by SOM (such as for
 *  SOMObject's initializers and for legacy support of somInit) are
 *  reported as being owned by SOMObject.
 *  Overrides are not expected.
 */
#define somMD_SOMClass_somMethodImplOwner "::SOMClass::somMethodImplOwner"
#define SOMClass_somMethodImplOwner(somSelf,md) \
    (SOM_Resolve(somSelf, SOMClass, somMethodImplOwner) \
	(somSelf,md))
#ifndef SOMGD_somMethodImplOwner
    #if (defined(_somMethodImplOwner) || defined(__somMethodImplOwner))
        #undef _somMethodImplOwner
        #undef __somMethodImplOwner
        #define SOMGD_somMethodImplOwner 1
    #else
        #define _somMethodImplOwner SOMClass_somMethodImplOwner
    #endif /* _somMethodImplOwner */
#endif /* SOMGD_somMethodImplOwner */

/*
 * New Method: somGetRdStub
 */
typedef somMethodProc*   SOMLINK somTP_SOMClass_somGetRdStub(SOMClass somSelf, 
		somId methodId);
typedef somTP_SOMClass_somGetRdStub *somTD_SOMClass_somGetRdStub;
/*
 *  Returns a redispatch stub for the indicated method if possible.
 *  If not possible (because a valid redispatch stub has not been
 *  registered, and there is insufficient information to dynamically
 *  construct one), then a pointer to a function that prints an
 *  informative message and terminates execution is returned.
 */
#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: somOverrideMtab
 */
typedef void   SOMLINK somTP_SOMClass_somOverrideMtab(SOMClass somSelf);
typedef somTP_SOMClass_somOverrideMtab *somTD_SOMClass_somOverrideMtab;
/*
 *  Overrides the method table pointers to point to the redispatch stubs.
 *  All the methods except somDispatch methods are overriden.
 */
#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 */

/*
 * Full Names for Inherited Methods
 */

#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_somUninit SOMObject_somUninit
#define SOMClass_somFree SOMObject_somFree
#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 */
