
/*
 * This file was generated by the SOM Compiler.
 * FileName: somrmcls.xh.
 * Generated using:
 *     SOM Precompiler somipc: 2.29.1.17
 *     SOM Emitter emitxh: 2.47
 */

/*
 *    COMPONENT_NAME: somr
 * 
 *    ORIGINS: 27
 * 
 * 
 *    10H9767, 10H9769  (C) COPYRIGHT International Business Machines Corp. 1992,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.
 * 
 */


#ifndef SOM_SOMRReplicable_xh
#define SOM_SOMRReplicable_xh

class SOMRReplicable;

/*
 * 
 */

#define SOMRReplicable_MajorVersion 2
#define SOMRReplicable_MinorVersion 1

/* C++ SOM defs */
#include <somcls.xh>
#include <somcm.xh>

/* C++ parent defs */
#ifndef SOM_SOMMBeforeAfter_xh
#include <sombacls.xh>
#endif

#ifndef SOMRReplicable_API
#define SOMRReplicable_API
/*
 * -- The Class API
 */

/*
 * Start of bindings for IDL types
 */

class SOMClass;
class SOMObject;

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

/* A procedure to create the SOMRReplicable Class */
SOMEXTERN SOMClass * SOMLINK SOMRReplicableNewClass(
		integer4 majorVersion,
		integer4 minorVersion);

/* The API to the SOMRReplicable class object, and the methods it introduces. */
SOMEXTERN struct SOMRReplicableClassDataStructure {
	SOMClass *classObject;
} SOMDLINK SOMRReplicableClassData;
#define _SOMRReplicable SOMRReplicableClassData.classObject

/* The API to parentMtabs for SOMRReplicable, and the instance data it introduces. */
SOMEXTERN struct SOMRReplicableCClassDataStructure {
	somMethodTabs parentMtab;
	somDToken              instanceDataToken;
} SOMDLINK SOMRReplicableCClassData;

/*
 * -- Typedefs for SOMRReplicable Method Procedures
 */
SOMEXTERN {

/*
 * -- Typedefs for Reintroduced Wrapper Methods
 */
typedef boolean   SOMLINK somTP_SOMRReplicable_sommBeforeMethod(SOMRReplicable *somSelf, Environment *ev, 
		SOMObject* object, 
		somId methodId, 
		va_list ap);
typedef somTP_SOMRReplicable_sommBeforeMethod *somTD_SOMRReplicable_sommBeforeMethod;
typedef void   SOMLINK somTP_SOMRReplicable_sommAfterMethod(SOMRReplicable *somSelf, Environment *ev, 
		SOMObject* object, 
		somId methodId, 
		somToken returnedvalue, 
		va_list ap);
typedef somTP_SOMRReplicable_sommAfterMethod *somTD_SOMRReplicable_sommAfterMethod;
typedef void   SOMLINK somTP_SOMRReplicable_somDefaultInit(SOMRReplicable *somSelf, 
		som3InitCtrl* ctrl);
typedef somTP_SOMRReplicable_somDefaultInit *somTD_SOMRReplicable_somDefaultInit;
typedef void   SOMLINK somTP_SOMRReplicable_somInitMIClass(SOMRReplicable *somSelf, 
		long inherit_vars, 
		string className, 
		SOMClass_SOMClassSequence* parentClasses, 
		long dataSize, 
		long dataAlignment, 
		long maxStaticMethods, 
		long majorVersion, 
		long minorVersion);
typedef somTP_SOMRReplicable_somInitMIClass *somTD_SOMRReplicable_somInitMIClass;
typedef long   SOMLINK somTP_SOMRReplicable__get_somDataAlignment(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable__get_somDataAlignment *somTD_SOMRReplicable__get_somDataAlignment;
typedef SOMClass_somOffsets   SOMLINK somTP_SOMRReplicable__get_somInstanceDataOffsets(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable__get_somInstanceDataOffsets *somTD_SOMRReplicable__get_somInstanceDataOffsets;
typedef SOMClass_SOMClassSequence   SOMLINK somTP_SOMRReplicable__get_somDirectInitClasses(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable__get_somDirectInitClasses *somTD_SOMRReplicable__get_somDirectInitClasses;
typedef SOMObject*   SOMLINK somTP_SOMRReplicable_somNew(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somNew *somTD_SOMRReplicable_somNew;
typedef SOMObject*   SOMLINK somTP_SOMRReplicable_somNewNoInit(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somNewNoInit *somTD_SOMRReplicable_somNewNoInit;
typedef SOMObject*   SOMLINK somTP_SOMRReplicable_somRenew(SOMRReplicable *somSelf, 
		void* obj);
typedef somTP_SOMRReplicable_somRenew *somTD_SOMRReplicable_somRenew;
typedef SOMObject*   SOMLINK somTP_SOMRReplicable_somRenewNoInit(SOMRReplicable *somSelf, 
		void* obj);
typedef somTP_SOMRReplicable_somRenewNoInit *somTD_SOMRReplicable_somRenewNoInit;
typedef SOMObject*   SOMLINK somTP_SOMRReplicable_somRenewNoZero(SOMRReplicable *somSelf, 
		void* obj);
typedef somTP_SOMRReplicable_somRenewNoZero *somTD_SOMRReplicable_somRenewNoZero;
typedef SOMObject*   SOMLINK somTP_SOMRReplicable_somRenewNoInitNoZero(SOMRReplicable *somSelf, 
		void* obj);
typedef somTP_SOMRReplicable_somRenewNoInitNoZero *somTD_SOMRReplicable_somRenewNoInitNoZero;
typedef somToken   SOMLINK somTP_SOMRReplicable_somAllocate(SOMRReplicable *somSelf, 
		long size);
typedef somTP_SOMRReplicable_somAllocate *somTD_SOMRReplicable_somAllocate;
typedef void   SOMLINK somTP_SOMRReplicable_somDeallocate(SOMRReplicable *somSelf, 
		somToken memptr);
typedef somTP_SOMRReplicable_somDeallocate *somTD_SOMRReplicable_somDeallocate;
typedef void   SOMLINK somTP_SOMRReplicable_somInitClass(SOMRReplicable *somSelf, 
		string className, 
		SOMClass* parentClass, 
		long dataSize, 
		long maxStaticMethods, 
		long majorVersion, 
		long minorVersion);
typedef somTP_SOMRReplicable_somInitClass *somTD_SOMRReplicable_somInitClass;
typedef somMToken   SOMLINK somTP_SOMRReplicable_somAddStaticMethod(SOMRReplicable *somSelf, 
		somId methodId, 
		somId methodDescriptor, 
		somMethodPtr method, 
		somMethodPtr redispatchStub, 
		somMethodPtr applyStub);
typedef somTP_SOMRReplicable_somAddStaticMethod *somTD_SOMRReplicable_somAddStaticMethod;
typedef void   SOMLINK somTP_SOMRReplicable_somAddDynamicMethod(SOMRReplicable *somSelf, 
		somId methodId, 
		somId methodDescriptor, 
		somMethodPtr method, 
		somMethodPtr applyStub);
typedef somTP_SOMRReplicable_somAddDynamicMethod *somTD_SOMRReplicable_somAddDynamicMethod;
typedef void   SOMLINK somTP_SOMRReplicable_somOverrideSMethod(SOMRReplicable *somSelf, 
		somId methodId, 
		somMethodPtr method);
typedef somTP_SOMRReplicable_somOverrideSMethod *somTD_SOMRReplicable_somOverrideSMethod;
typedef void   SOMLINK somTP_SOMRReplicable_somClassReady(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somClassReady *somTD_SOMRReplicable_somClassReady;
typedef somMethodPtr   SOMLINK somTP_SOMRReplicable_somGetApplyStub(SOMRReplicable *somSelf, 
		somId methodId);
typedef somTP_SOMRReplicable_somGetApplyStub *somTD_SOMRReplicable_somGetApplyStub;
typedef somClassDataStructure*   SOMLINK somTP_SOMRReplicable_somGetClassData(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somGetClassData *somTD_SOMRReplicable_somGetClassData;
typedef void   SOMLINK somTP_SOMRReplicable_somSetClassData(SOMRReplicable *somSelf, 
		somClassDataStructure* cds);
typedef somTP_SOMRReplicable_somSetClassData *somTD_SOMRReplicable_somSetClassData;
typedef somMethodTab*   SOMLINK somTP_SOMRReplicable_somGetClassMtab(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somGetClassMtab *somTD_SOMRReplicable_somGetClassMtab;
typedef long   SOMLINK somTP_SOMRReplicable_somGetInstanceOffset(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somGetInstanceOffset *somTD_SOMRReplicable_somGetInstanceOffset;
typedef long   SOMLINK somTP_SOMRReplicable_somGetInstancePartSize(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somGetInstancePartSize *somTD_SOMRReplicable_somGetInstancePartSize;
typedef long   SOMLINK somTP_SOMRReplicable_somGetInstanceSize(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somGetInstanceSize *somTD_SOMRReplicable_somGetInstanceSize;
typedef somDToken   SOMLINK somTP_SOMRReplicable_somGetInstanceToken(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somGetInstanceToken *somTD_SOMRReplicable_somGetInstanceToken;
typedef somDToken   SOMLINK somTP_SOMRReplicable_somGetMemberToken(SOMRReplicable *somSelf, 
		long memberOffset, 
		somDToken instanceToken);
typedef somTP_SOMRReplicable_somGetMemberToken *somTD_SOMRReplicable_somGetMemberToken;
typedef boolean   SOMLINK somTP_SOMRReplicable_somGetMethodData(SOMRReplicable *somSelf, 
		somId methodId, 
		somMethodData* md);
typedef somTP_SOMRReplicable_somGetMethodData *somTD_SOMRReplicable_somGetMethodData;
typedef somMethodProc*   SOMLINK somTP_SOMRReplicable_somGetRdStub(SOMRReplicable *somSelf, 
		somId methodId);
typedef somTP_SOMRReplicable_somGetRdStub *somTD_SOMRReplicable_somGetRdStub;
typedef somId   SOMLINK somTP_SOMRReplicable_somGetMethodDescriptor(SOMRReplicable *somSelf, 
		somId methodId);
typedef somTP_SOMRReplicable_somGetMethodDescriptor *somTD_SOMRReplicable_somGetMethodDescriptor;
typedef long   SOMLINK somTP_SOMRReplicable_somGetMethodIndex(SOMRReplicable *somSelf, 
		somId id);
typedef somTP_SOMRReplicable_somGetMethodIndex *somTD_SOMRReplicable_somGetMethodIndex;
typedef somMToken   SOMLINK somTP_SOMRReplicable_somGetMethodToken(SOMRReplicable *somSelf, 
		somId methodId);
typedef somTP_SOMRReplicable_somGetMethodToken *somTD_SOMRReplicable_somGetMethodToken;
typedef string   SOMLINK somTP_SOMRReplicable_somGetName(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somGetName *somTD_SOMRReplicable_somGetName;
typedef boolean   SOMLINK somTP_SOMRReplicable_somGetNthMethodData(SOMRReplicable *somSelf, 
		long n, 
		somMethodData* md);
typedef somTP_SOMRReplicable_somGetNthMethodData *somTD_SOMRReplicable_somGetNthMethodData;
typedef somId   SOMLINK somTP_SOMRReplicable_somGetNthMethodInfo(SOMRReplicable *somSelf, 
		long n, 
		somId* descriptor);
typedef somTP_SOMRReplicable_somGetNthMethodInfo *somTD_SOMRReplicable_somGetNthMethodInfo;
typedef long   SOMLINK somTP_SOMRReplicable_somGetNumMethods(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somGetNumMethods *somTD_SOMRReplicable_somGetNumMethods;
typedef long   SOMLINK somTP_SOMRReplicable_somGetNumStaticMethods(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somGetNumStaticMethods *somTD_SOMRReplicable_somGetNumStaticMethods;
typedef SOMClass*   SOMLINK somTP_SOMRReplicable_somGetParent(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somGetParent *somTD_SOMRReplicable_somGetParent;
typedef SOMClass_SOMClassSequence   SOMLINK somTP_SOMRReplicable_somGetParents(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somGetParents *somTD_SOMRReplicable_somGetParents;
typedef void   SOMLINK somTP_SOMRReplicable_somGetVersionNumbers(SOMRReplicable *somSelf, 
		long* majorVersion, 
		long* minorVersion);
typedef somTP_SOMRReplicable_somGetVersionNumbers *somTD_SOMRReplicable_somGetVersionNumbers;
typedef boolean   SOMLINK somTP_SOMRReplicable_somFindMethod(SOMRReplicable *somSelf, 
		somId methodId, 
		somMethodPtr* m);
typedef somTP_SOMRReplicable_somFindMethod *somTD_SOMRReplicable_somFindMethod;
typedef boolean   SOMLINK somTP_SOMRReplicable_somFindMethodOk(SOMRReplicable *somSelf, 
		somId methodId, 
		somMethodPtr* m);
typedef somTP_SOMRReplicable_somFindMethodOk *somTD_SOMRReplicable_somFindMethodOk;
typedef somMethodPtr   SOMLINK somTP_SOMRReplicable_somFindSMethod(SOMRReplicable *somSelf, 
		somId methodId);
typedef somTP_SOMRReplicable_somFindSMethod *somTD_SOMRReplicable_somFindSMethod;
typedef somMethodPtr   SOMLINK somTP_SOMRReplicable_somFindSMethodOk(SOMRReplicable *somSelf, 
		somId methodId);
typedef somTP_SOMRReplicable_somFindSMethodOk *somTD_SOMRReplicable_somFindSMethodOk;
typedef somMethodPtr   SOMLINK somTP_SOMRReplicable_somLookupMethod(SOMRReplicable *somSelf, 
		somId methodId);
typedef somTP_SOMRReplicable_somLookupMethod *somTD_SOMRReplicable_somLookupMethod;
typedef boolean   SOMLINK somTP_SOMRReplicable_somCheckVersion(SOMRReplicable *somSelf, 
		long majorVersion, 
		long minorVersion);
typedef somTP_SOMRReplicable_somCheckVersion *somTD_SOMRReplicable_somCheckVersion;
typedef boolean   SOMLINK somTP_SOMRReplicable_somDescendedFrom(SOMRReplicable *somSelf, 
		SOMClass* aClassObj);
typedef somTP_SOMRReplicable_somDescendedFrom *somTD_SOMRReplicable_somDescendedFrom;
typedef boolean   SOMLINK somTP_SOMRReplicable_somSupportsMethod(SOMRReplicable *somSelf, 
		somId mId);
typedef somTP_SOMRReplicable_somSupportsMethod *somTD_SOMRReplicable_somSupportsMethod;
typedef somMethodPtr   SOMLINK somTP_SOMRReplicable_somDefinedMethod(SOMRReplicable *somSelf, 
		somMToken method);
typedef somTP_SOMRReplicable_somDefinedMethod *somTD_SOMRReplicable_somDefinedMethod;
typedef void   SOMLINK somTP_SOMRReplicable_somOverrideMtab(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somOverrideMtab *somTD_SOMRReplicable_somOverrideMtab;
typedef void   SOMLINK somTP_SOMRReplicable_somDestruct(SOMRReplicable *somSelf, 
		octet doFree, 
		som3DestructCtrl* ctrl);
typedef somTP_SOMRReplicable_somDestruct *somTD_SOMRReplicable_somDestruct;
typedef void   SOMLINK somTP_SOMRReplicable_somDefaultCopyInit(SOMRReplicable *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_SOMRReplicable_somDefaultCopyInit *somTD_SOMRReplicable_somDefaultCopyInit;
typedef SOMRReplicable*   SOMLINK somTP_SOMRReplicable_somDefaultAssign(SOMRReplicable *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_SOMRReplicable_somDefaultAssign *somTD_SOMRReplicable_somDefaultAssign;
typedef void   SOMLINK somTP_SOMRReplicable_somDefaultConstCopyInit(SOMRReplicable *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_SOMRReplicable_somDefaultConstCopyInit *somTD_SOMRReplicable_somDefaultConstCopyInit;
typedef void   SOMLINK somTP_SOMRReplicable_somDefaultVCopyInit(SOMRReplicable *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_SOMRReplicable_somDefaultVCopyInit *somTD_SOMRReplicable_somDefaultVCopyInit;
typedef void   SOMLINK somTP_SOMRReplicable_somDefaultConstVCopyInit(SOMRReplicable *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_SOMRReplicable_somDefaultConstVCopyInit *somTD_SOMRReplicable_somDefaultConstVCopyInit;
typedef SOMRReplicable*   SOMLINK somTP_SOMRReplicable_somDefaultConstAssign(SOMRReplicable *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_SOMRReplicable_somDefaultConstAssign *somTD_SOMRReplicable_somDefaultConstAssign;
typedef SOMRReplicable*   SOMLINK somTP_SOMRReplicable_somDefaultVAssign(SOMRReplicable *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_SOMRReplicable_somDefaultVAssign *somTD_SOMRReplicable_somDefaultVAssign;
typedef SOMRReplicable*   SOMLINK somTP_SOMRReplicable_somDefaultConstVAssign(SOMRReplicable *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_SOMRReplicable_somDefaultConstVAssign *somTD_SOMRReplicable_somDefaultConstVAssign;
typedef void   SOMLINK somTP_SOMRReplicable_somInit(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somInit *somTD_SOMRReplicable_somInit;
typedef void   SOMLINK somTP_SOMRReplicable_somFree(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somFree *somTD_SOMRReplicable_somFree;
typedef void   SOMLINK somTP_SOMRReplicable_somUninit(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somUninit *somTD_SOMRReplicable_somUninit;
typedef SOMClass*   SOMLINK somTP_SOMRReplicable_somGetClass(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somGetClass *somTD_SOMRReplicable_somGetClass;
typedef string   SOMLINK somTP_SOMRReplicable_somGetClassName(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somGetClassName *somTD_SOMRReplicable_somGetClassName;
typedef long   SOMLINK somTP_SOMRReplicable_somGetSize(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somGetSize *somTD_SOMRReplicable_somGetSize;
typedef boolean   SOMLINK somTP_SOMRReplicable_somIsA(SOMRReplicable *somSelf, 
		SOMClass* aClassObj);
typedef somTP_SOMRReplicable_somIsA *somTD_SOMRReplicable_somIsA;
typedef boolean   SOMLINK somTP_SOMRReplicable_somIsInstanceOf(SOMRReplicable *somSelf, 
		SOMClass* aClassObj);
typedef somTP_SOMRReplicable_somIsInstanceOf *somTD_SOMRReplicable_somIsInstanceOf;
typedef boolean   SOMLINK somTP_SOMRReplicable_somRespondsTo(SOMRReplicable *somSelf, 
		somId mId);
typedef somTP_SOMRReplicable_somRespondsTo *somTD_SOMRReplicable_somRespondsTo;
typedef boolean   SOMLINK somTP_SOMRReplicable_somDispatch(SOMRReplicable *somSelf, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_SOMRReplicable_somDispatch *somTD_SOMRReplicable_somDispatch;
typedef boolean   SOMLINK somTP_SOMRReplicable_somClassDispatch(SOMRReplicable *somSelf, 
		SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_SOMRReplicable_somClassDispatch *somTD_SOMRReplicable_somClassDispatch;
typedef boolean   SOMLINK somTP_SOMRReplicable_somCastObj(SOMRReplicable *somSelf, 
		SOMClass* cls);
typedef somTP_SOMRReplicable_somCastObj *somTD_SOMRReplicable_somCastObj;
typedef boolean   SOMLINK somTP_SOMRReplicable_somResetObj(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somResetObj *somTD_SOMRReplicable_somResetObj;
typedef void   SOMLINK somTP_SOMRReplicable_somDispatchV(SOMRReplicable *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_SOMRReplicable_somDispatchV *somTD_SOMRReplicable_somDispatchV;
typedef long   SOMLINK somTP_SOMRReplicable_somDispatchL(SOMRReplicable *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_SOMRReplicable_somDispatchL *somTD_SOMRReplicable_somDispatchL;
typedef void*   SOMLINK somTP_SOMRReplicable_somDispatchA(SOMRReplicable *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_SOMRReplicable_somDispatchA *somTD_SOMRReplicable_somDispatchA;
typedef double   SOMLINK somTP_SOMRReplicable_somDispatchD(SOMRReplicable *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_SOMRReplicable_somDispatchD *somTD_SOMRReplicable_somDispatchD;
typedef SOMObject*   SOMLINK somTP_SOMRReplicable_somPrintSelf(SOMRReplicable *somSelf);
typedef somTP_SOMRReplicable_somPrintSelf *somTD_SOMRReplicable_somPrintSelf;
typedef void   SOMLINK somTP_SOMRReplicable_somDumpSelf(SOMRReplicable *somSelf, 
		long level);
typedef somTP_SOMRReplicable_somDumpSelf *somTD_SOMRReplicable_somDumpSelf;
typedef void   SOMLINK somTP_SOMRReplicable_somDumpSelfInt(SOMRReplicable *somSelf, 
		long level);
typedef somTP_SOMRReplicable_somDumpSelfInt *somTD_SOMRReplicable_somDumpSelfInt;
}

#endif /* SOMRReplicable_API */


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

/*
 * -- The C++ Wrapper Class for SOMRReplicable
 */
class SOMRReplicable : public SOMMBeforeAfter
{
/*
 * 
 */
public:

// SOMRReplicable::new creates the class object if necessary, and then uses somNewNoInit
// to allocate memory and create the object. Initialization is in ctors.
void *operator new(size_t)
{
   if (!_SOMRReplicable) SOMRReplicableNewClass(SOMRReplicable_MajorVersion,SOMRReplicable_MinorVersion);
   return (void*)
      SOM_Resolve(_SOMRReplicable,SOMClass,somNewNoInit)
         ((SOMClass *)((void*)_SOMRReplicable));
}

// SOMRReplicable::delete uses somDestruct.
void operator delete(void * obj)
{
   if (obj && *(void**)obj) {
      SOM_Resolve(obj,SOMObject,somFree)
         ((SOMObject*)obj);
   }
}

SOMRReplicable& operator=(SOMRReplicable& fromObj)
{
   this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
   return *this;
}

SOMRReplicable()
{
   if (*(void**)this != 
       ((somParentMtabStructPtr)
        (SOMRReplicableCClassData.parentMtab))->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultInit(0);
}

SOMRReplicable(SOMRReplicable* fromObj)
{
   if (*(void**)this != 
       ((somParentMtabStructPtr)
        (SOMRReplicableCClassData.parentMtab))->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
}

#ifdef __IBMCPP__
#pragma info(nocnv,nopar)
#endif
SOMRReplicable(const SOMRReplicable* fromObj)
{
   if (*(void**)this != 
       ((somParentMtabStructPtr)
        (SOMRReplicableCClassData.parentMtab))->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
}
#ifdef __IBMCPP__
#pragma info(restore)
#endif


/*
 * Reintroduce inherited methods
 */

/* va_list method: sommBeforeMethod */

/*
 *  returns one of the following values:
 *       TRUE  --  continue Before/After processing
 *       FALSE --  skip to executing the corresponding After method
 *                 (this includes skipping the requested method)
 */
/* the va_list invocation form */
boolean   SOMRReplicable_sommBeforeMethod(Environment *ev, 
		SOMObject* object, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,SOMRReplicable,SOMMBeforeAfter,sommBeforeMethod)
	(this, ev,object,methodId,ap);
}

/* the varargs invocation form */
boolean   sommBeforeMethod(Environment *ev, 
		SOMObject* object, 
		somId methodId, 
		...)
{
/*
 *  returns one of the following values:
 *       TRUE  --  continue Before/After processing
 *       FALSE --  skip to executing the corresponding After method
 *                 (this includes skipping the requested method)
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      SOM_ResolveD(this,SOMRReplicable,SOMMBeforeAfter,sommBeforeMethod)
	(this, ev,object,methodId,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: sommAfterMethod */

/* the va_list invocation form */
void   SOMRReplicable_sommAfterMethod(Environment *ev, 
		SOMObject* object, 
		somId methodId, 
		somToken returnedvalue, 
		va_list ap)
{   SOM_ResolveD(this,SOMRReplicable,SOMMBeforeAfter,sommAfterMethod)
	(this, ev,object,methodId,returnedvalue,ap);
}

/* the varargs invocation form */
void   sommAfterMethod(Environment *ev, 
		SOMObject* object, 
		somId methodId, 
		somToken returnedvalue, 
		...)
{
   va_list ap;
   va_start(ap, returnedvalue);
   SOM_ResolveD(this,SOMRReplicable,SOMMBeforeAfter,sommAfterMethod)
	(this, ev,object,methodId,returnedvalue,ap);
   va_end(ap);
}


/* initializer method: somDefaultInit */
void   somDefaultInit(som3InitCtrl* ctrl)
{
   SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultInit)
	(this,ctrl);
}


/* method: somInitMIClass */
void   somInitMIClass(long inherit_vars, 
		string className, 
		SOMClass_SOMClassSequence* parentClasses, 
		long dataSize, 
		long dataAlignment, 
		long maxStaticMethods, 
		long majorVersion, 
		long minorVersion)
{
   SOM_ResolveD(this,SOMRReplicable,SOMClass,somInitMIClass)
	(this,inherit_vars,className,parentClasses,dataSize,dataAlignment,maxStaticMethods,majorVersion,minorVersion);
}


/* method: _get_somDataAlignment */
long   _get_somDataAlignment()
{
/*
 *  The alignment required for the instance data structure
 *  introduced by the receiving class.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,_get_somDataAlignment)
	(this);
}


/* nonstatic method: _get_somInstanceDataOffsets */
SOMClass_somOffsets   _get_somInstanceDataOffsets()
{
/*
 *  A sequence of the instance data offsets for all classes used in
 *  the derivation of the receiving class (including the receiver).
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,_get_somInstanceDataOffsets)
	(this);
}


/* nonstatic method: _get_somDirectInitClasses */
SOMClass_SOMClassSequence   _get_somDirectInitClasses()
{
/*
 *  The ancestors whose initializers the receiving
 *  class wants to directly invoke.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,_get_somDirectInitClasses)
	(this);
}


/* method: somNew */
SOMObject*   somNew()
{
/*
 *  Uses SOMMalloc to allocate storage for a new instance of the
 *  receiving class, and then calls somRenewNoInitNoZero to load the
 *  new object's method table pointer. Then somDefaultInit is called to
 *  initialize the new object.  Note: If the instance is a class object,
 *  somInitMIClass must then be invoked to declare parents and
 *  initialize the class's instance method table. Upon failure, NULL
 *  is returned.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somNew)
	(this);
}


/* method: somNewNoInit */
SOMObject*   somNewNoInit()
{
/*
 *  Equivalent to somNew except that somDefaultInit is not called.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somNewNoInit)
	(this);
}


/* method: somRenew */
SOMObject*   somRenew(void* obj)
{
/*
 *  Equivalent to somNew except that storage is not allocated.
 *  <obj> is taken as the address of the new object.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somRenew)
	(this,obj);
}


/* method: somRenewNoInit */
SOMObject*   somRenewNoInit(void* obj)
{
/*
 *  Equivalent to somRenew except that somDefaultInit is not called.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somRenewNoInit)
	(this,obj);
}


/* method: somRenewNoZero */
SOMObject*   somRenewNoZero(void* obj)
{
/*
 *  Equivalent to somRenew except that memory is not zeroed out.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somRenewNoZero)
	(this,obj);
}


/* method: somRenewNoInitNoZero */
SOMObject*   somRenewNoInitNoZero(void* obj)
{
/*
 *  The purpose of this method is to load an object's method table.
 *  The SOM API requires that somRenewNoInitNoZero always be
 *  called when creating a new object whose metaclass is not SOMClass.
 *  This is because metaclasses must be guaranteed that they can use
 *  somRenewNoInitNoZero to track object creation if this is desired.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somRenewNoInitNoZero)
	(this,obj);
}


/* nonstatic method: somAllocate */
somToken   somAllocate(long size)
{
/*
 *  Allocates memory to hold an object and returns a pointer to this memory.
 *  This is a nonstatic method, and cannot be overridden. The default
 *  implementation calls SOMMalloc, but a class designer can specify a
 *  different implementation using the somallocate modifier in IDL. The
 *  allocator takes the same parameters as this method.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somAllocate)
	(this,size);
}


/* nonstatic method: somDeallocate */
void   somDeallocate(somToken memptr)
{
/*
 *  Zeros out the method table pointer stored in the word pointed to by
 *  memptr, and then deallocates the block of memory pointed to by memptr.
 *  This is a nonstatic method and cannot be overridden. The default
 *  deallocator called is SOMFree, but a class designer can specify a
 *  different deallocator using the somdeallocate modifier in IDL. The
 *  deallocator takes a char* (memptr) and a long (size) as arguments.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMClass,somDeallocate)
	(this,memptr);
}


/* method: somInitClass */
void   somInitClass(string className, 
		SOMClass* parentClass, 
		long dataSize, 
		long maxStaticMethods, 
		long majorVersion, 
		long minorVersion)
{
/*
 *  somInitClass is obsolete, and should no longer be used. The SOM 2.0
 *  kernel provides special handling for redispatch stubs in the case
 *  of SOM 1.0 classes, and use of this method is what tells the kernel
 *  that old-style redispatch stubs will be registered.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMClass,somInitClass)
	(this,className,parentClass,dataSize,maxStaticMethods,majorVersion,minorVersion);
}


/* method: somAddStaticMethod */
somMToken   somAddStaticMethod(somId methodId, 
		somId methodDescriptor, 
		somMethodPtr method, 
		somMethodPtr redispatchStub, 
		somMethodPtr applyStub)
{
/*
 *  Adds the indicated method, creating and returning a new method token.
 * 
 *  <methodDescriptor> is the somId for an identifier that can be used
 *  to access signature information about the method from an interface
 *  repository.
 * 
 *  <method> is the actual method procedure for this method
 * 
 *  <redispatchStub> is a procedure with the same calling sequence as
 *  <method> that invokes somDispatch for the method.
 * 
 *  <applyStub> is a procedure used to support somApply.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somAddStaticMethod)
	(this,methodId,methodDescriptor,method,redispatchStub,applyStub);
}


/* method: somAddDynamicMethod */
void   somAddDynamicMethod(somId methodId, 
		somId methodDescriptor, 
		somMethodPtr method, 
		somMethodPtr applyStub)
{
/*
 *  Adds the indicated method to the class's name lookup list.
 *  If this happens to override a static method then this operation is
 *  equivalent to <somOverrideSMethod> and the <methodDescriptor> and
 *  <applyStub> arguments are ignored (the overridden method's values
 *  will be used).
 * 
 *  <methodDescriptor> is the somId for an identifier that can be used
 *  to access signature information about the method from an interface
 *  repository.
 * 
 *  <method> is the actual method procedure for this method
 * 
 *  <applyStub> is a procedure that takes a standard variable argument
 *  list data structure applies it to its target object by calling
 *  <method> with arguments derived from the data structure.  Its
 *  calling sequence is the same as the calling sequence of the
 *  dispatch methods defined in SOMObject.  This stub is used in the
 *  support of the dispatch methods used in some classes.  In classes
 *  where the dispatch functions do not need such a function this
 *  parameter may be null.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMClass,somAddDynamicMethod)
	(this,methodId,methodDescriptor,method,applyStub);
}


/* method: somOverrideSMethod */
void   somOverrideSMethod(somId methodId, 
		somMethodPtr method)
{
/*
 *  This method can be used instead of <somAddStaticMethod> or
 *  <somAddDynamicMethod> when it is known that the class' parent
 *  class already supports this method.  This call does not require the
 *  method descriptor and stub methods that the others do.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMClass,somOverrideSMethod)
	(this,methodId,method);
}


/* method: somClassReady */
void   somClassReady()
{
/*
 *  This method is invoked when all of the static initialization for
 *  the class has been finished.  The default implementation simply
 *  registers the newly constructed class with the SOMClassMgr.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMClass,somClassReady)
	(this);
}


/* method: somGetApplyStub */
somMethodPtr   somGetApplyStub(somId methodId)
{
/*
 *  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.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetApplyStub)
	(this,methodId);
}


/* method: somGetClassData */
somClassDataStructure*   somGetClassData()
{
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetClassData)
	(this);
}


/* method: somSetClassData */
void   somSetClassData(somClassDataStructure* cds)
{
/*
 *  The class' pointer to the static <className>ClassData structure.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMClass,somSetClassData)
	(this,cds);
}


/* method: somGetClassMtab */
somMethodTab*   somGetClassMtab()
{
/*
 *  A pointer to the method table used by instances of this class. This
 *  method was misnamed; it should have been called somGetInstanceMtab.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetClassMtab)
	(this);
}


/* method: somGetInstanceOffset */
long   somGetInstanceOffset()
{
/*
 *  Returns the offset of instance data introduced by the receiver in
 *  an instance of the receiver. This method is obsolete and not useful in
 *  multiple-inheritance situations. The attribute somInstanceDataOffsets
 *  replaces this method.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetInstanceOffset)
	(this);
}


/* method: somGetInstancePartSize */
long   somGetInstancePartSize()
{
/*
 *  The size in bytes of the instance data introduced by the receiving
 *  class.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetInstancePartSize)
	(this);
}


/* method: somGetInstanceSize */
long   somGetInstanceSize()
{
/*
 *  The total size of an instance of the receiving class.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetInstanceSize)
	(this);
}


/* method: somGetInstanceToken */
somDToken   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.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetInstanceToken)
	(this);
}


/* method: somGetMemberToken */
somDToken   somGetMemberToken(long memberOffset, 
		somDToken instanceToken)
{
/*
 *  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.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetMemberToken)
	(this,memberOffset,instanceToken);
}


/* method: somGetMethodData */
boolean   somGetMethodData(somId methodId, 
		somMethodData* md)
{
/*
 *  If a method with id <methodId> is supported by the target class,
 *  the structure pointed to by <md> is loaded with method information
 *  and the value 1 is returned. In this case, if the method is not
 *  dynamic, md->method is loaded with the result of somClassResolve on
 *  the target class for the method. If the method is not supported,
 *  md->id is loaded with 0, and the value 0 is returned.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetMethodData)
	(this,methodId,md);
}


/* method: somGetRdStub */
somMethodProc*   somGetRdStub(somId methodId)
{
/*
 *  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 NULL is returned.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetRdStub)
	(this,methodId);
}


/* method: somGetMethodDescriptor */
somId   somGetMethodDescriptor(somId methodId)
{
/*
 *  Returns the method descriptor for the indicated method.    If
 *  this object does not support the indicated method then NULL is
 *  returned.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetMethodDescriptor)
	(this,methodId);
}


/* method: somGetMethodIndex */
long   somGetMethodIndex(somId id)
{
/*
 *  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.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetMethodIndex)
	(this,id);
}


/* method: somGetMethodToken */
somMToken   somGetMethodToken(somId methodId)
{
/*
 *  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.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetMethodToken)
	(this,methodId);
}


/* method: somGetName */
string   somGetName()
{
/*
 *  This object's class name as a NULL terminated string.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetName)
	(this);
}


/* method: somGetNthMethodData */
boolean   somGetNthMethodData(long n, 
		somMethodData* md)
{
/*
 *  loads *md with the method data associated with the the nth method,
 *  or NULL if there is no such method. Returns true is successful;
 *  false otherwise.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetNthMethodData)
	(this,n,md);
}


/* method: somGetNthMethodInfo */
somId   somGetNthMethodInfo(long n, 
		somId* descriptor)
{
/*
 *  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.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetNthMethodInfo)
	(this,n,descriptor);
}


/* method: somGetNumMethods */
long   somGetNumMethods()
{
/*
 *  The number of methods currently supported by this class,
 *  including inherited methods (both static and dynamic).
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetNumMethods)
	(this);
}


/* method: somGetNumStaticMethods */
long   somGetNumStaticMethods()
{
/*
 *  The number of static methods that this class has.  Can
 *  be used by a child class when initializing its method table.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetNumStaticMethods)
	(this);
}


/* method: somGetParent */
SOMClass*   somGetParent()
{
/*
 *  Returns the parent class of self (along its "left-hand" derivation
 *  path), if one exists and NULL otherwise.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetParent)
	(this);
}


/* method: somGetParents */
SOMClass_SOMClassSequence   somGetParents()
{
/*
 *  The parent classes of self.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetParents)
	(this);
}


/* method: somGetVersionNumbers */
void   somGetVersionNumbers(long* majorVersion, 
		long* minorVersion)
{
/*
 *  Returns the class' major and minor version numbers in the corresponding
 *  output parameters.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetVersionNumbers)
	(this,majorVersion,minorVersion);
}


/* method: somFindMethod */
boolean   somFindMethod(somId methodId, 
		somMethodPtr* m)
{
/*
 *  Finds the method procedure associated with <methodId> for this
 *  class and sets <m> to it.  1 (true) is returned when the
 *  method procedure is a static method and 0 (false) is returned
 *  when the method procedure is dynamic method.
 * 
 *  If the class does not support the specified method then
 *  <m> is set to NULL and the return value is meaningless.
 * 
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somFindMethod)
	(this,methodId,m);
}


/* method: somFindMethodOk */
boolean   somFindMethodOk(somId methodId, 
		somMethodPtr* m)
{
/*
 *  Just like <somFindMethod> except that if the method is not
 *  supported then an error is raised and execution is halted.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somFindMethodOk)
	(this,methodId,m);
}


/* method: somFindSMethod */
somMethodPtr   somFindSMethod(somId methodId)
{
/*
 *  Finds the indicated method, which must be a static method supported
 *  by this class, and returns a pointer to its method procedure.
 *  If the method is not supported by the receiver (as a static method
 *  or at all) then a NULL pointer is returned.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somFindSMethod)
	(this,methodId);
}


/* method: somFindSMethodOk */
somMethodPtr   somFindSMethodOk(somId methodId)
{
/*
 *  Uses <somFindSMethod>, and raises an error if the result is NULL.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somFindSMethodOk)
	(this,methodId);
}


/* method: somLookupMethod */
somMethodPtr   somLookupMethod(somId methodId)
{
/*
 *  Like <somFindSMethodOK>, but without restriction to static methods.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somLookupMethod)
	(this,methodId);
}


/* method: somCheckVersion */
boolean   somCheckVersion(long majorVersion, 
		long minorVersion)
{
/*
 *  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.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somCheckVersion)
	(this,majorVersion,minorVersion);
}


/* method: somDescendedFrom */
boolean   somDescendedFrom(SOMClass* aClassObj)
{
/*
 *  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.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somDescendedFrom)
	(this,aClassObj);
}


/* method: somSupportsMethod */
boolean   somSupportsMethod(somId mId)
{
/*
 *  Returns 1 (true) if the indicated method is supported by this
 *  class and 0 (false) otherwise.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somSupportsMethod)
	(this,mId);
}


/* method: somDefinedMethod */
somMethodPtr   somDefinedMethod(somMToken method)
{
/*
 *  if the receiving class either introduces or overrides the
 *  indicated method, then its somMethodPtr is returned, otherwise
 *  NULL is returned.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMClass,somDefinedMethod)
	(this,method);
}


/* method: somOverrideMtab */
void   somOverrideMtab()
{
/*
 *  Overrides the method table pointers to point to the redispatch stubs.
 *  All the methods except somDispatch methods are overriden.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMClass,somOverrideMtab)
	(this);
}


/* method: somDestruct */
void   somDestruct(octet doFree, 
		som3DestructCtrl* ctrl)
{
/*
 *  The default destructor for a SOM object. A nonzero <doFree>
 *  indicates that the object storage should be freed by the
 *  object's class (via somDeallocate) after uninitialization.
 *  As with somDefaultInit, a null ctrl can be passed.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMObject,somDestruct)
	(this,doFree,ctrl);
}


/* initializer method: somDefaultCopyInit */
void   somDefaultCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor. Use this to make copies of objects for
 *  calling methods with "by-value" argument semantics.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultCopyInit)
	(this,ctrl,fromObj);
}


/* method: somDefaultAssign */
SOMRReplicable*  somDefaultAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator. Use this to "assign" the state of one
 *  object to another.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultAssign)
	(this,ctrl,fromObj);
}


/* initializer method: somDefaultConstCopyInit */
void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a const fromObj.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultConstCopyInit)
	(this,ctrl,fromObj);
}


/* initializer method: somDefaultVCopyInit */
void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a volatile fromObj.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultVCopyInit)
	(this,ctrl,fromObj);
}


/* initializer method: somDefaultConstVCopyInit */
void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a const volatile fromObj.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultConstVCopyInit)
	(this,ctrl,fromObj);
}


/* method: somDefaultConstAssign */
SOMRReplicable*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const fromObj.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultConstAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultVAssign */
SOMRReplicable*  somDefaultVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a volatile fromObj.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultVAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultConstVAssign */
SOMRReplicable*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const volatile fromObj.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultConstVAssign)
	(this,ctrl,fromObj);
}


/* method: somInit */
void   somInit()
{
/*
 *  Obsolete but still supported. Override somDefaultInit instead of somInit.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMObject,somInit)
	(this);
}


/* method: somFree */
void   somFree()
{
/*
 *  Use as directed by framework implementations.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMObject,somFree)
	(this);
}


/* method: somUninit */
void   somUninit()
{
/*
 *  Obsolete but still supported. Override somDestruct instead of somUninit.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMObject,somUninit)
	(this);
}


/* method: somGetClass */
SOMClass*   somGetClass()
{
/*
 *  Return the receiver's class.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMObject,somGetClass)
	(this);
}


/* method: somGetClassName */
string   somGetClassName()
{
/*
 *  Return the name of the receiver's class.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMObject,somGetClassName)
	(this);
}


/* method: somGetSize */
long   somGetSize()
{
/*
 *  Return the size of the receiver.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMObject,somGetSize)
	(this);
}


/* method: somIsA */
boolean   somIsA(SOMClass* aClassObj)
{
/*
 *  Returns 1 (true) if the receiver responds to methods
 *  introduced by <aClassObj>, and 0 (false) otherwise.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMObject,somIsA)
	(this,aClassObj);
}


/* method: somIsInstanceOf */
boolean   somIsInstanceOf(SOMClass* aClassObj)
{
/*
 *  Returns 1 (true) if the receiver is an instance of
 *  <aClassObj> and 0 (false) otherwise.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMObject,somIsInstanceOf)
	(this,aClassObj);
}


/* method: somRespondsTo */
boolean   somRespondsTo(somId mId)
{
/*
 *  Returns 1 (true) if the indicated method can be invoked
 *  on the receiver and 0 (false) otherwise.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMObject,somRespondsTo)
	(this,mId);
}


/* va_list method: somDispatch */

/*
 *  This method provides a generic, class-specific dispatch mechanism.
 *  It accepts as input <retValue> a pointer to the memory area to be
 *  loaded with the result of dispatching the method indicated by
 *  <methodId> using the arguments in <ap>. <ap> contains the object
 *  on which the method is to be invoked as the first argument.
 */
/* the va_list invocation form */
boolean   SOMRReplicable_somDispatch(somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatch)
	(this,retValue,methodId,ap);
}

/* the varargs invocation form */
boolean   somDispatch(somToken* retValue, 
		somId methodId, 
		...)
{
/*
 *  This method provides a generic, class-specific dispatch mechanism.
 *  It accepts as input <retValue> a pointer to the memory area to be
 *  loaded with the result of dispatching the method indicated by
 *  <methodId> using the arguments in <ap>. <ap> contains the object
 *  on which the method is to be invoked as the first argument.
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatch)
	(this,retValue,methodId,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somClassDispatch */

/*
 *  Like somDispatch, but method resolution for static methods is done
 *  according to the clsObj instance method table.
 */
/* the va_list invocation form */
boolean   SOMRReplicable_somClassDispatch(SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,SOMRReplicable,SOMObject,somClassDispatch)
	(this,clsObj,retValue,methodId,ap);
}

/* the varargs invocation form */
boolean   somClassDispatch(SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		...)
{
/*
 *  Like somDispatch, but method resolution for static methods is done
 *  according to the clsObj instance method table.
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      SOM_ResolveD(this,SOMRReplicable,SOMObject,somClassDispatch)
	(this,clsObj,retValue,methodId,ap);
   va_end(ap);
   return __somResult;
}


/* method: somCastObj */
boolean   somCastObj(SOMClass* cls)
{
/*
 *  cast the receiving object to cls (which must be an ancestor of the
 *  objects true class. Returns true on success.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMObject,somCastObj)
	(this,cls);
}


/* method: somResetObj */
boolean   somResetObj()
{
/*
 *  reset an object to its true class. Returns true always.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMObject,somResetObj)
	(this);
}


/* va_list method: somDispatchV */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void   SOMRReplicable_somDispatchV(somId methodId, 
		somId descriptor, 
		va_list ap)
{   SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void   somDispatchV(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
   va_end(ap);
}


/* va_list method: somDispatchL */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
long   SOMRReplicable_somDispatchL(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
long   somDispatchL(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   long __somResult = 
      SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchA */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void*   SOMRReplicable_somDispatchA(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void*   somDispatchA(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   void* __somResult = 
      SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchD */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
double   SOMRReplicable_somDispatchD(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
double   somDispatchD(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   double __somResult = 
      SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* method: somPrintSelf */
SOMObject*   somPrintSelf()
{
/*
 *  Uses <SOMOutCharRoutine> to write a brief string with identifying
 *  information about this object.  The default implementation just gives
 *  the object's class name and its address in memory.
 *  <self> is returned.
 */
   return SOM_ResolveD(this,SOMRReplicable,SOMObject,somPrintSelf)
	(this);
}


/* method: somDumpSelf */
void   somDumpSelf(long level)
{
/*
 *  Uses <SOMOutCharRoutine> to write a detailed description of this object
 *  and its current state.
 * 
 *  <level> indicates the nesting level for describing compound objects
 *  it must be greater than or equal to zero.  All lines in the
 *  description will be preceeded by <2*level> spaces.
 * 
 *  This routine only actually writes the data that concerns the object
 *  as a whole, such as class, and uses <somDumpSelfInt> to describe
 *  the object's current state.  This approach allows readable
 *  descriptions of compound objects to be constructed.
 * 
 *  Generally it is not necessary to override this method, if it is
 *  overriden it generally must be completely replaced.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMObject,somDumpSelf)
	(this,level);
}


/* method: somDumpSelfInt */
void   somDumpSelfInt(long level)
{
/*
 *  Uses <SOMOutCharRoutine> to write in the current state of this object.
 *  Generally this method will need to be overridden.  When overriding
 *  it, begin by calling the parent class form of this method and then
 *  write in a description of your class's instance data. This will
 *  result in a description of all the object's instance data going
 *  from its root ancestor class to its specific class.
 */
   SOM_ResolveD(this,SOMRReplicable,SOMObject,somDumpSelfInt)
	(this,level);
}



};   /* SOMRReplicable */



#endif       /* SOM_SOMRReplicable_xh */
