home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / somrmcls.xh < prev    next >
Text File  |  1999-02-22  |  55KB  |  1,708 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: somrmcls.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.17
  7.  *     SOM Emitter emitxh: 2.47
  8.  */
  9.  
  10. /*
  11.  *    COMPONENT_NAME: somr
  12.  * 
  13.  *    ORIGINS: 27
  14.  * 
  15.  * 
  16.  *    10H9767, 10H9769  (C) COPYRIGHT International Business Machines Corp. 1992,1994
  17.  *    All Rights Reserved
  18.  *    Licensed Materials - Property of IBM
  19.  *    US Government Users Restricted Rights - Use, duplication or
  20.  *    disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  21.  * 
  22.  */
  23.  
  24.  
  25. #ifndef SOM_SOMRReplicable_xh
  26. #define SOM_SOMRReplicable_xh
  27.  
  28. class SOMRReplicable;
  29.  
  30. /*
  31.  * 
  32.  */
  33.  
  34. #define SOMRReplicable_MajorVersion 2
  35. #define SOMRReplicable_MinorVersion 1
  36.  
  37. /* C++ SOM defs */
  38. #include <somcls.xh>
  39. #include <somcm.xh>
  40.  
  41. /* C++ parent defs */
  42. #ifndef SOM_SOMMBeforeAfter_xh
  43. #include <sombacls.xh>
  44. #endif
  45.  
  46. #ifndef SOMRReplicable_API
  47. #define SOMRReplicable_API
  48. /*
  49.  * -- The Class API
  50.  */
  51.  
  52. /*
  53.  * Start of bindings for IDL types
  54.  */
  55.  
  56. class SOMClass;
  57. class SOMObject;
  58.  
  59. /*
  60.  * End of bindings for IDL types.
  61.  */
  62.  
  63. /* A procedure to create the SOMRReplicable Class */
  64. SOMEXTERN SOMClass * SOMLINK SOMRReplicableNewClass(
  65.         integer4 majorVersion,
  66.         integer4 minorVersion);
  67.  
  68. /* The API to the SOMRReplicable class object, and the methods it introduces. */
  69. SOMEXTERN struct SOMRReplicableClassDataStructure {
  70.     SOMClass *classObject;
  71. } SOMDLINK SOMRReplicableClassData;
  72. #define _SOMRReplicable SOMRReplicableClassData.classObject
  73.  
  74. /* The API to parentMtabs for SOMRReplicable, and the instance data it introduces. */
  75. SOMEXTERN struct SOMRReplicableCClassDataStructure {
  76.     somMethodTabs parentMtab;
  77.     somDToken              instanceDataToken;
  78. } SOMDLINK SOMRReplicableCClassData;
  79.  
  80. /*
  81.  * -- Typedefs for SOMRReplicable Method Procedures
  82.  */
  83. SOMEXTERN {
  84.  
  85. /*
  86.  * -- Typedefs for Reintroduced Wrapper Methods
  87.  */
  88. typedef boolean   SOMLINK somTP_SOMRReplicable_sommBeforeMethod(SOMRReplicable *somSelf, Environment *ev, 
  89.         SOMObject* object, 
  90.         somId methodId, 
  91.         va_list ap);
  92. typedef somTP_SOMRReplicable_sommBeforeMethod *somTD_SOMRReplicable_sommBeforeMethod;
  93. typedef void   SOMLINK somTP_SOMRReplicable_sommAfterMethod(SOMRReplicable *somSelf, Environment *ev, 
  94.         SOMObject* object, 
  95.         somId methodId, 
  96.         somToken returnedvalue, 
  97.         va_list ap);
  98. typedef somTP_SOMRReplicable_sommAfterMethod *somTD_SOMRReplicable_sommAfterMethod;
  99. typedef void   SOMLINK somTP_SOMRReplicable_somDefaultInit(SOMRReplicable *somSelf, 
  100.         som3InitCtrl* ctrl);
  101. typedef somTP_SOMRReplicable_somDefaultInit *somTD_SOMRReplicable_somDefaultInit;
  102. typedef void   SOMLINK somTP_SOMRReplicable_somInitMIClass(SOMRReplicable *somSelf, 
  103.         long inherit_vars, 
  104.         string className, 
  105.         SOMClass_SOMClassSequence* parentClasses, 
  106.         long dataSize, 
  107.         long dataAlignment, 
  108.         long maxStaticMethods, 
  109.         long majorVersion, 
  110.         long minorVersion);
  111. typedef somTP_SOMRReplicable_somInitMIClass *somTD_SOMRReplicable_somInitMIClass;
  112. typedef long   SOMLINK somTP_SOMRReplicable__get_somDataAlignment(SOMRReplicable *somSelf);
  113. typedef somTP_SOMRReplicable__get_somDataAlignment *somTD_SOMRReplicable__get_somDataAlignment;
  114. typedef SOMClass_somOffsets   SOMLINK somTP_SOMRReplicable__get_somInstanceDataOffsets(SOMRReplicable *somSelf);
  115. typedef somTP_SOMRReplicable__get_somInstanceDataOffsets *somTD_SOMRReplicable__get_somInstanceDataOffsets;
  116. typedef SOMClass_SOMClassSequence   SOMLINK somTP_SOMRReplicable__get_somDirectInitClasses(SOMRReplicable *somSelf);
  117. typedef somTP_SOMRReplicable__get_somDirectInitClasses *somTD_SOMRReplicable__get_somDirectInitClasses;
  118. typedef SOMObject*   SOMLINK somTP_SOMRReplicable_somNew(SOMRReplicable *somSelf);
  119. typedef somTP_SOMRReplicable_somNew *somTD_SOMRReplicable_somNew;
  120. typedef SOMObject*   SOMLINK somTP_SOMRReplicable_somNewNoInit(SOMRReplicable *somSelf);
  121. typedef somTP_SOMRReplicable_somNewNoInit *somTD_SOMRReplicable_somNewNoInit;
  122. typedef SOMObject*   SOMLINK somTP_SOMRReplicable_somRenew(SOMRReplicable *somSelf, 
  123.         void* obj);
  124. typedef somTP_SOMRReplicable_somRenew *somTD_SOMRReplicable_somRenew;
  125. typedef SOMObject*   SOMLINK somTP_SOMRReplicable_somRenewNoInit(SOMRReplicable *somSelf, 
  126.         void* obj);
  127. typedef somTP_SOMRReplicable_somRenewNoInit *somTD_SOMRReplicable_somRenewNoInit;
  128. typedef SOMObject*   SOMLINK somTP_SOMRReplicable_somRenewNoZero(SOMRReplicable *somSelf, 
  129.         void* obj);
  130. typedef somTP_SOMRReplicable_somRenewNoZero *somTD_SOMRReplicable_somRenewNoZero;
  131. typedef SOMObject*   SOMLINK somTP_SOMRReplicable_somRenewNoInitNoZero(SOMRReplicable *somSelf, 
  132.         void* obj);
  133. typedef somTP_SOMRReplicable_somRenewNoInitNoZero *somTD_SOMRReplicable_somRenewNoInitNoZero;
  134. typedef somToken   SOMLINK somTP_SOMRReplicable_somAllocate(SOMRReplicable *somSelf, 
  135.         long size);
  136. typedef somTP_SOMRReplicable_somAllocate *somTD_SOMRReplicable_somAllocate;
  137. typedef void   SOMLINK somTP_SOMRReplicable_somDeallocate(SOMRReplicable *somSelf, 
  138.         somToken memptr);
  139. typedef somTP_SOMRReplicable_somDeallocate *somTD_SOMRReplicable_somDeallocate;
  140. typedef void   SOMLINK somTP_SOMRReplicable_somInitClass(SOMRReplicable *somSelf, 
  141.         string className, 
  142.         SOMClass* parentClass, 
  143.         long dataSize, 
  144.         long maxStaticMethods, 
  145.         long majorVersion, 
  146.         long minorVersion);
  147. typedef somTP_SOMRReplicable_somInitClass *somTD_SOMRReplicable_somInitClass;
  148. typedef somMToken   SOMLINK somTP_SOMRReplicable_somAddStaticMethod(SOMRReplicable *somSelf, 
  149.         somId methodId, 
  150.         somId methodDescriptor, 
  151.         somMethodPtr method, 
  152.         somMethodPtr redispatchStub, 
  153.         somMethodPtr applyStub);
  154. typedef somTP_SOMRReplicable_somAddStaticMethod *somTD_SOMRReplicable_somAddStaticMethod;
  155. typedef void   SOMLINK somTP_SOMRReplicable_somAddDynamicMethod(SOMRReplicable *somSelf, 
  156.         somId methodId, 
  157.         somId methodDescriptor, 
  158.         somMethodPtr method, 
  159.         somMethodPtr applyStub);
  160. typedef somTP_SOMRReplicable_somAddDynamicMethod *somTD_SOMRReplicable_somAddDynamicMethod;
  161. typedef void   SOMLINK somTP_SOMRReplicable_somOverrideSMethod(SOMRReplicable *somSelf, 
  162.         somId methodId, 
  163.         somMethodPtr method);
  164. typedef somTP_SOMRReplicable_somOverrideSMethod *somTD_SOMRReplicable_somOverrideSMethod;
  165. typedef void   SOMLINK somTP_SOMRReplicable_somClassReady(SOMRReplicable *somSelf);
  166. typedef somTP_SOMRReplicable_somClassReady *somTD_SOMRReplicable_somClassReady;
  167. typedef somMethodPtr   SOMLINK somTP_SOMRReplicable_somGetApplyStub(SOMRReplicable *somSelf, 
  168.         somId methodId);
  169. typedef somTP_SOMRReplicable_somGetApplyStub *somTD_SOMRReplicable_somGetApplyStub;
  170. typedef somClassDataStructure*   SOMLINK somTP_SOMRReplicable_somGetClassData(SOMRReplicable *somSelf);
  171. typedef somTP_SOMRReplicable_somGetClassData *somTD_SOMRReplicable_somGetClassData;
  172. typedef void   SOMLINK somTP_SOMRReplicable_somSetClassData(SOMRReplicable *somSelf, 
  173.         somClassDataStructure* cds);
  174. typedef somTP_SOMRReplicable_somSetClassData *somTD_SOMRReplicable_somSetClassData;
  175. typedef somMethodTab*   SOMLINK somTP_SOMRReplicable_somGetClassMtab(SOMRReplicable *somSelf);
  176. typedef somTP_SOMRReplicable_somGetClassMtab *somTD_SOMRReplicable_somGetClassMtab;
  177. typedef long   SOMLINK somTP_SOMRReplicable_somGetInstanceOffset(SOMRReplicable *somSelf);
  178. typedef somTP_SOMRReplicable_somGetInstanceOffset *somTD_SOMRReplicable_somGetInstanceOffset;
  179. typedef long   SOMLINK somTP_SOMRReplicable_somGetInstancePartSize(SOMRReplicable *somSelf);
  180. typedef somTP_SOMRReplicable_somGetInstancePartSize *somTD_SOMRReplicable_somGetInstancePartSize;
  181. typedef long   SOMLINK somTP_SOMRReplicable_somGetInstanceSize(SOMRReplicable *somSelf);
  182. typedef somTP_SOMRReplicable_somGetInstanceSize *somTD_SOMRReplicable_somGetInstanceSize;
  183. typedef somDToken   SOMLINK somTP_SOMRReplicable_somGetInstanceToken(SOMRReplicable *somSelf);
  184. typedef somTP_SOMRReplicable_somGetInstanceToken *somTD_SOMRReplicable_somGetInstanceToken;
  185. typedef somDToken   SOMLINK somTP_SOMRReplicable_somGetMemberToken(SOMRReplicable *somSelf, 
  186.         long memberOffset, 
  187.         somDToken instanceToken);
  188. typedef somTP_SOMRReplicable_somGetMemberToken *somTD_SOMRReplicable_somGetMemberToken;
  189. typedef boolean   SOMLINK somTP_SOMRReplicable_somGetMethodData(SOMRReplicable *somSelf, 
  190.         somId methodId, 
  191.         somMethodData* md);
  192. typedef somTP_SOMRReplicable_somGetMethodData *somTD_SOMRReplicable_somGetMethodData;
  193. typedef somMethodProc*   SOMLINK somTP_SOMRReplicable_somGetRdStub(SOMRReplicable *somSelf, 
  194.         somId methodId);
  195. typedef somTP_SOMRReplicable_somGetRdStub *somTD_SOMRReplicable_somGetRdStub;
  196. typedef somId   SOMLINK somTP_SOMRReplicable_somGetMethodDescriptor(SOMRReplicable *somSelf, 
  197.         somId methodId);
  198. typedef somTP_SOMRReplicable_somGetMethodDescriptor *somTD_SOMRReplicable_somGetMethodDescriptor;
  199. typedef long   SOMLINK somTP_SOMRReplicable_somGetMethodIndex(SOMRReplicable *somSelf, 
  200.         somId id);
  201. typedef somTP_SOMRReplicable_somGetMethodIndex *somTD_SOMRReplicable_somGetMethodIndex;
  202. typedef somMToken   SOMLINK somTP_SOMRReplicable_somGetMethodToken(SOMRReplicable *somSelf, 
  203.         somId methodId);
  204. typedef somTP_SOMRReplicable_somGetMethodToken *somTD_SOMRReplicable_somGetMethodToken;
  205. typedef string   SOMLINK somTP_SOMRReplicable_somGetName(SOMRReplicable *somSelf);
  206. typedef somTP_SOMRReplicable_somGetName *somTD_SOMRReplicable_somGetName;
  207. typedef boolean   SOMLINK somTP_SOMRReplicable_somGetNthMethodData(SOMRReplicable *somSelf, 
  208.         long n, 
  209.         somMethodData* md);
  210. typedef somTP_SOMRReplicable_somGetNthMethodData *somTD_SOMRReplicable_somGetNthMethodData;
  211. typedef somId   SOMLINK somTP_SOMRReplicable_somGetNthMethodInfo(SOMRReplicable *somSelf, 
  212.         long n, 
  213.         somId* descriptor);
  214. typedef somTP_SOMRReplicable_somGetNthMethodInfo *somTD_SOMRReplicable_somGetNthMethodInfo;
  215. typedef long   SOMLINK somTP_SOMRReplicable_somGetNumMethods(SOMRReplicable *somSelf);
  216. typedef somTP_SOMRReplicable_somGetNumMethods *somTD_SOMRReplicable_somGetNumMethods;
  217. typedef long   SOMLINK somTP_SOMRReplicable_somGetNumStaticMethods(SOMRReplicable *somSelf);
  218. typedef somTP_SOMRReplicable_somGetNumStaticMethods *somTD_SOMRReplicable_somGetNumStaticMethods;
  219. typedef SOMClass*   SOMLINK somTP_SOMRReplicable_somGetParent(SOMRReplicable *somSelf);
  220. typedef somTP_SOMRReplicable_somGetParent *somTD_SOMRReplicable_somGetParent;
  221. typedef SOMClass_SOMClassSequence   SOMLINK somTP_SOMRReplicable_somGetParents(SOMRReplicable *somSelf);
  222. typedef somTP_SOMRReplicable_somGetParents *somTD_SOMRReplicable_somGetParents;
  223. typedef void   SOMLINK somTP_SOMRReplicable_somGetVersionNumbers(SOMRReplicable *somSelf, 
  224.         long* majorVersion, 
  225.         long* minorVersion);
  226. typedef somTP_SOMRReplicable_somGetVersionNumbers *somTD_SOMRReplicable_somGetVersionNumbers;
  227. typedef boolean   SOMLINK somTP_SOMRReplicable_somFindMethod(SOMRReplicable *somSelf, 
  228.         somId methodId, 
  229.         somMethodPtr* m);
  230. typedef somTP_SOMRReplicable_somFindMethod *somTD_SOMRReplicable_somFindMethod;
  231. typedef boolean   SOMLINK somTP_SOMRReplicable_somFindMethodOk(SOMRReplicable *somSelf, 
  232.         somId methodId, 
  233.         somMethodPtr* m);
  234. typedef somTP_SOMRReplicable_somFindMethodOk *somTD_SOMRReplicable_somFindMethodOk;
  235. typedef somMethodPtr   SOMLINK somTP_SOMRReplicable_somFindSMethod(SOMRReplicable *somSelf, 
  236.         somId methodId);
  237. typedef somTP_SOMRReplicable_somFindSMethod *somTD_SOMRReplicable_somFindSMethod;
  238. typedef somMethodPtr   SOMLINK somTP_SOMRReplicable_somFindSMethodOk(SOMRReplicable *somSelf, 
  239.         somId methodId);
  240. typedef somTP_SOMRReplicable_somFindSMethodOk *somTD_SOMRReplicable_somFindSMethodOk;
  241. typedef somMethodPtr   SOMLINK somTP_SOMRReplicable_somLookupMethod(SOMRReplicable *somSelf, 
  242.         somId methodId);
  243. typedef somTP_SOMRReplicable_somLookupMethod *somTD_SOMRReplicable_somLookupMethod;
  244. typedef boolean   SOMLINK somTP_SOMRReplicable_somCheckVersion(SOMRReplicable *somSelf, 
  245.         long majorVersion, 
  246.         long minorVersion);
  247. typedef somTP_SOMRReplicable_somCheckVersion *somTD_SOMRReplicable_somCheckVersion;
  248. typedef boolean   SOMLINK somTP_SOMRReplicable_somDescendedFrom(SOMRReplicable *somSelf, 
  249.         SOMClass* aClassObj);
  250. typedef somTP_SOMRReplicable_somDescendedFrom *somTD_SOMRReplicable_somDescendedFrom;
  251. typedef boolean   SOMLINK somTP_SOMRReplicable_somSupportsMethod(SOMRReplicable *somSelf, 
  252.         somId mId);
  253. typedef somTP_SOMRReplicable_somSupportsMethod *somTD_SOMRReplicable_somSupportsMethod;
  254. typedef somMethodPtr   SOMLINK somTP_SOMRReplicable_somDefinedMethod(SOMRReplicable *somSelf, 
  255.         somMToken method);
  256. typedef somTP_SOMRReplicable_somDefinedMethod *somTD_SOMRReplicable_somDefinedMethod;
  257. typedef void   SOMLINK somTP_SOMRReplicable_somOverrideMtab(SOMRReplicable *somSelf);
  258. typedef somTP_SOMRReplicable_somOverrideMtab *somTD_SOMRReplicable_somOverrideMtab;
  259. typedef void   SOMLINK somTP_SOMRReplicable_somDestruct(SOMRReplicable *somSelf, 
  260.         octet doFree, 
  261.         som3DestructCtrl* ctrl);
  262. typedef somTP_SOMRReplicable_somDestruct *somTD_SOMRReplicable_somDestruct;
  263. typedef void   SOMLINK somTP_SOMRReplicable_somDefaultCopyInit(SOMRReplicable *somSelf, 
  264.         som3InitCtrl* ctrl, 
  265.         SOMObject* fromObj);
  266. typedef somTP_SOMRReplicable_somDefaultCopyInit *somTD_SOMRReplicable_somDefaultCopyInit;
  267. typedef SOMRReplicable*   SOMLINK somTP_SOMRReplicable_somDefaultAssign(SOMRReplicable *somSelf, 
  268.         som3AssignCtrl* ctrl, 
  269.         SOMObject* fromObj);
  270. typedef somTP_SOMRReplicable_somDefaultAssign *somTD_SOMRReplicable_somDefaultAssign;
  271. typedef void   SOMLINK somTP_SOMRReplicable_somDefaultConstCopyInit(SOMRReplicable *somSelf, 
  272.         som3InitCtrl* ctrl, 
  273.         SOMObject* fromObj);
  274. typedef somTP_SOMRReplicable_somDefaultConstCopyInit *somTD_SOMRReplicable_somDefaultConstCopyInit;
  275. typedef void   SOMLINK somTP_SOMRReplicable_somDefaultVCopyInit(SOMRReplicable *somSelf, 
  276.         som3InitCtrl* ctrl, 
  277.         SOMObject* fromObj);
  278. typedef somTP_SOMRReplicable_somDefaultVCopyInit *somTD_SOMRReplicable_somDefaultVCopyInit;
  279. typedef void   SOMLINK somTP_SOMRReplicable_somDefaultConstVCopyInit(SOMRReplicable *somSelf, 
  280.         som3InitCtrl* ctrl, 
  281.         SOMObject* fromObj);
  282. typedef somTP_SOMRReplicable_somDefaultConstVCopyInit *somTD_SOMRReplicable_somDefaultConstVCopyInit;
  283. typedef SOMRReplicable*   SOMLINK somTP_SOMRReplicable_somDefaultConstAssign(SOMRReplicable *somSelf, 
  284.         som3AssignCtrl* ctrl, 
  285.         SOMObject* fromObj);
  286. typedef somTP_SOMRReplicable_somDefaultConstAssign *somTD_SOMRReplicable_somDefaultConstAssign;
  287. typedef SOMRReplicable*   SOMLINK somTP_SOMRReplicable_somDefaultVAssign(SOMRReplicable *somSelf, 
  288.         som3AssignCtrl* ctrl, 
  289.         SOMObject* fromObj);
  290. typedef somTP_SOMRReplicable_somDefaultVAssign *somTD_SOMRReplicable_somDefaultVAssign;
  291. typedef SOMRReplicable*   SOMLINK somTP_SOMRReplicable_somDefaultConstVAssign(SOMRReplicable *somSelf, 
  292.         som3AssignCtrl* ctrl, 
  293.         SOMObject* fromObj);
  294. typedef somTP_SOMRReplicable_somDefaultConstVAssign *somTD_SOMRReplicable_somDefaultConstVAssign;
  295. typedef void   SOMLINK somTP_SOMRReplicable_somInit(SOMRReplicable *somSelf);
  296. typedef somTP_SOMRReplicable_somInit *somTD_SOMRReplicable_somInit;
  297. typedef void   SOMLINK somTP_SOMRReplicable_somFree(SOMRReplicable *somSelf);
  298. typedef somTP_SOMRReplicable_somFree *somTD_SOMRReplicable_somFree;
  299. typedef void   SOMLINK somTP_SOMRReplicable_somUninit(SOMRReplicable *somSelf);
  300. typedef somTP_SOMRReplicable_somUninit *somTD_SOMRReplicable_somUninit;
  301. typedef SOMClass*   SOMLINK somTP_SOMRReplicable_somGetClass(SOMRReplicable *somSelf);
  302. typedef somTP_SOMRReplicable_somGetClass *somTD_SOMRReplicable_somGetClass;
  303. typedef string   SOMLINK somTP_SOMRReplicable_somGetClassName(SOMRReplicable *somSelf);
  304. typedef somTP_SOMRReplicable_somGetClassName *somTD_SOMRReplicable_somGetClassName;
  305. typedef long   SOMLINK somTP_SOMRReplicable_somGetSize(SOMRReplicable *somSelf);
  306. typedef somTP_SOMRReplicable_somGetSize *somTD_SOMRReplicable_somGetSize;
  307. typedef boolean   SOMLINK somTP_SOMRReplicable_somIsA(SOMRReplicable *somSelf, 
  308.         SOMClass* aClassObj);
  309. typedef somTP_SOMRReplicable_somIsA *somTD_SOMRReplicable_somIsA;
  310. typedef boolean   SOMLINK somTP_SOMRReplicable_somIsInstanceOf(SOMRReplicable *somSelf, 
  311.         SOMClass* aClassObj);
  312. typedef somTP_SOMRReplicable_somIsInstanceOf *somTD_SOMRReplicable_somIsInstanceOf;
  313. typedef boolean   SOMLINK somTP_SOMRReplicable_somRespondsTo(SOMRReplicable *somSelf, 
  314.         somId mId);
  315. typedef somTP_SOMRReplicable_somRespondsTo *somTD_SOMRReplicable_somRespondsTo;
  316. typedef boolean   SOMLINK somTP_SOMRReplicable_somDispatch(SOMRReplicable *somSelf, 
  317.         somToken* retValue, 
  318.         somId methodId, 
  319.         va_list ap);
  320. typedef somTP_SOMRReplicable_somDispatch *somTD_SOMRReplicable_somDispatch;
  321. typedef boolean   SOMLINK somTP_SOMRReplicable_somClassDispatch(SOMRReplicable *somSelf, 
  322.         SOMClass* clsObj, 
  323.         somToken* retValue, 
  324.         somId methodId, 
  325.         va_list ap);
  326. typedef somTP_SOMRReplicable_somClassDispatch *somTD_SOMRReplicable_somClassDispatch;
  327. typedef boolean   SOMLINK somTP_SOMRReplicable_somCastObj(SOMRReplicable *somSelf, 
  328.         SOMClass* cls);
  329. typedef somTP_SOMRReplicable_somCastObj *somTD_SOMRReplicable_somCastObj;
  330. typedef boolean   SOMLINK somTP_SOMRReplicable_somResetObj(SOMRReplicable *somSelf);
  331. typedef somTP_SOMRReplicable_somResetObj *somTD_SOMRReplicable_somResetObj;
  332. typedef void   SOMLINK somTP_SOMRReplicable_somDispatchV(SOMRReplicable *somSelf, 
  333.         somId methodId, 
  334.         somId descriptor, 
  335.         va_list ap);
  336. typedef somTP_SOMRReplicable_somDispatchV *somTD_SOMRReplicable_somDispatchV;
  337. typedef long   SOMLINK somTP_SOMRReplicable_somDispatchL(SOMRReplicable *somSelf, 
  338.         somId methodId, 
  339.         somId descriptor, 
  340.         va_list ap);
  341. typedef somTP_SOMRReplicable_somDispatchL *somTD_SOMRReplicable_somDispatchL;
  342. typedef void*   SOMLINK somTP_SOMRReplicable_somDispatchA(SOMRReplicable *somSelf, 
  343.         somId methodId, 
  344.         somId descriptor, 
  345.         va_list ap);
  346. typedef somTP_SOMRReplicable_somDispatchA *somTD_SOMRReplicable_somDispatchA;
  347. typedef double   SOMLINK somTP_SOMRReplicable_somDispatchD(SOMRReplicable *somSelf, 
  348.         somId methodId, 
  349.         somId descriptor, 
  350.         va_list ap);
  351. typedef somTP_SOMRReplicable_somDispatchD *somTD_SOMRReplicable_somDispatchD;
  352. typedef SOMObject*   SOMLINK somTP_SOMRReplicable_somPrintSelf(SOMRReplicable *somSelf);
  353. typedef somTP_SOMRReplicable_somPrintSelf *somTD_SOMRReplicable_somPrintSelf;
  354. typedef void   SOMLINK somTP_SOMRReplicable_somDumpSelf(SOMRReplicable *somSelf, 
  355.         long level);
  356. typedef somTP_SOMRReplicable_somDumpSelf *somTD_SOMRReplicable_somDumpSelf;
  357. typedef void   SOMLINK somTP_SOMRReplicable_somDumpSelfInt(SOMRReplicable *somSelf, 
  358.         long level);
  359. typedef somTP_SOMRReplicable_somDumpSelfInt *somTD_SOMRReplicable_somDumpSelfInt;
  360. }
  361.  
  362. #endif /* SOMRReplicable_API */
  363.  
  364.  
  365. /*
  366.  * -- This emitter treats Method Tokens as Thunks by default.
  367.  * -- Use the sc modifier "nothunks" to change this default
  368.  */
  369. #undef somresolve_
  370. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  371.  
  372. /*
  373.  * -- The C++ Wrapper Class for SOMRReplicable
  374.  */
  375. class SOMRReplicable : public SOMMBeforeAfter
  376. {
  377. /*
  378.  * 
  379.  */
  380. public:
  381.  
  382. // SOMRReplicable::new creates the class object if necessary, and then uses somNewNoInit
  383. // to allocate memory and create the object. Initialization is in ctors.
  384. void *operator new(size_t)
  385. {
  386.    if (!_SOMRReplicable) SOMRReplicableNewClass(SOMRReplicable_MajorVersion,SOMRReplicable_MinorVersion);
  387.    return (void*)
  388.       SOM_Resolve(_SOMRReplicable,SOMClass,somNewNoInit)
  389.          ((SOMClass *)((void*)_SOMRReplicable));
  390. }
  391.  
  392. // SOMRReplicable::delete uses somDestruct.
  393. void operator delete(void * obj)
  394. {
  395.    if (obj && *(void**)obj) {
  396.       SOM_Resolve(obj,SOMObject,somFree)
  397.          ((SOMObject*)obj);
  398.    }
  399. }
  400.  
  401. SOMRReplicable& operator=(SOMRReplicable& fromObj)
  402. {
  403.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  404.    return *this;
  405. }
  406.  
  407. SOMRReplicable()
  408. {
  409.    if (*(void**)this != 
  410.        ((somParentMtabStructPtr)
  411.         (SOMRReplicableCClassData.parentMtab))->mtab)
  412.       return;
  413.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  414. }
  415.  
  416. SOMRReplicable(SOMRReplicable* fromObj)
  417. {
  418.    if (*(void**)this != 
  419.        ((somParentMtabStructPtr)
  420.         (SOMRReplicableCClassData.parentMtab))->mtab)
  421.       return;
  422.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  423. }
  424.  
  425. #ifdef __IBMCPP__
  426. #pragma info(nocnv,nopar)
  427. #endif
  428. SOMRReplicable(const SOMRReplicable* fromObj)
  429. {
  430.    if (*(void**)this != 
  431.        ((somParentMtabStructPtr)
  432.         (SOMRReplicableCClassData.parentMtab))->mtab)
  433.       return;
  434.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  435. }
  436. #ifdef __IBMCPP__
  437. #pragma info(restore)
  438. #endif
  439.  
  440.  
  441. /*
  442.  * Reintroduce inherited methods
  443.  */
  444.  
  445. /* va_list method: sommBeforeMethod */
  446.  
  447. /*
  448.  *  returns one of the following values:
  449.  *       TRUE  --  continue Before/After processing
  450.  *       FALSE --  skip to executing the corresponding After method
  451.  *                 (this includes skipping the requested method)
  452.  */
  453. /* the va_list invocation form */
  454. boolean   SOMRReplicable_sommBeforeMethod(Environment *ev, 
  455.         SOMObject* object, 
  456.         somId methodId, 
  457.         va_list ap)
  458. {return SOM_ResolveD(this,SOMRReplicable,SOMMBeforeAfter,sommBeforeMethod)
  459.     (this, ev,object,methodId,ap);
  460. }
  461.  
  462. /* the varargs invocation form */
  463. boolean   sommBeforeMethod(Environment *ev, 
  464.         SOMObject* object, 
  465.         somId methodId, 
  466.         ...)
  467. {
  468. /*
  469.  *  returns one of the following values:
  470.  *       TRUE  --  continue Before/After processing
  471.  *       FALSE --  skip to executing the corresponding After method
  472.  *                 (this includes skipping the requested method)
  473.  */
  474.    va_list ap;
  475.    va_start(ap, methodId);
  476.    boolean __somResult = 
  477.       SOM_ResolveD(this,SOMRReplicable,SOMMBeforeAfter,sommBeforeMethod)
  478.     (this, ev,object,methodId,ap);
  479.    va_end(ap);
  480.    return __somResult;
  481. }
  482.  
  483.  
  484. /* va_list method: sommAfterMethod */
  485.  
  486. /* the va_list invocation form */
  487. void   SOMRReplicable_sommAfterMethod(Environment *ev, 
  488.         SOMObject* object, 
  489.         somId methodId, 
  490.         somToken returnedvalue, 
  491.         va_list ap)
  492. {   SOM_ResolveD(this,SOMRReplicable,SOMMBeforeAfter,sommAfterMethod)
  493.     (this, ev,object,methodId,returnedvalue,ap);
  494. }
  495.  
  496. /* the varargs invocation form */
  497. void   sommAfterMethod(Environment *ev, 
  498.         SOMObject* object, 
  499.         somId methodId, 
  500.         somToken returnedvalue, 
  501.         ...)
  502. {
  503.    va_list ap;
  504.    va_start(ap, returnedvalue);
  505.    SOM_ResolveD(this,SOMRReplicable,SOMMBeforeAfter,sommAfterMethod)
  506.     (this, ev,object,methodId,returnedvalue,ap);
  507.    va_end(ap);
  508. }
  509.  
  510.  
  511. /* initializer method: somDefaultInit */
  512. void   somDefaultInit(som3InitCtrl* ctrl)
  513. {
  514.    SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultInit)
  515.     (this,ctrl);
  516. }
  517.  
  518.  
  519. /* method: somInitMIClass */
  520. void   somInitMIClass(long inherit_vars, 
  521.         string className, 
  522.         SOMClass_SOMClassSequence* parentClasses, 
  523.         long dataSize, 
  524.         long dataAlignment, 
  525.         long maxStaticMethods, 
  526.         long majorVersion, 
  527.         long minorVersion)
  528. {
  529.    SOM_ResolveD(this,SOMRReplicable,SOMClass,somInitMIClass)
  530.     (this,inherit_vars,className,parentClasses,dataSize,dataAlignment,maxStaticMethods,majorVersion,minorVersion);
  531. }
  532.  
  533.  
  534. /* method: _get_somDataAlignment */
  535. long   _get_somDataAlignment()
  536. {
  537. /*
  538.  *  The alignment required for the instance data structure
  539.  *  introduced by the receiving class.
  540.  */
  541.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,_get_somDataAlignment)
  542.     (this);
  543. }
  544.  
  545.  
  546. /* nonstatic method: _get_somInstanceDataOffsets */
  547. SOMClass_somOffsets   _get_somInstanceDataOffsets()
  548. {
  549. /*
  550.  *  A sequence of the instance data offsets for all classes used in
  551.  *  the derivation of the receiving class (including the receiver).
  552.  */
  553.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,_get_somInstanceDataOffsets)
  554.     (this);
  555. }
  556.  
  557.  
  558. /* nonstatic method: _get_somDirectInitClasses */
  559. SOMClass_SOMClassSequence   _get_somDirectInitClasses()
  560. {
  561. /*
  562.  *  The ancestors whose initializers the receiving
  563.  *  class wants to directly invoke.
  564.  */
  565.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,_get_somDirectInitClasses)
  566.     (this);
  567. }
  568.  
  569.  
  570. /* method: somNew */
  571. SOMObject*   somNew()
  572. {
  573. /*
  574.  *  Uses SOMMalloc to allocate storage for a new instance of the
  575.  *  receiving class, and then calls somRenewNoInitNoZero to load the
  576.  *  new object's method table pointer. Then somDefaultInit is called to
  577.  *  initialize the new object.  Note: If the instance is a class object,
  578.  *  somInitMIClass must then be invoked to declare parents and
  579.  *  initialize the class's instance method table. Upon failure, NULL
  580.  *  is returned.
  581.  */
  582.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somNew)
  583.     (this);
  584. }
  585.  
  586.  
  587. /* method: somNewNoInit */
  588. SOMObject*   somNewNoInit()
  589. {
  590. /*
  591.  *  Equivalent to somNew except that somDefaultInit is not called.
  592.  */
  593.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somNewNoInit)
  594.     (this);
  595. }
  596.  
  597.  
  598. /* method: somRenew */
  599. SOMObject*   somRenew(void* obj)
  600. {
  601. /*
  602.  *  Equivalent to somNew except that storage is not allocated.
  603.  *  <obj> is taken as the address of the new object.
  604.  */
  605.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somRenew)
  606.     (this,obj);
  607. }
  608.  
  609.  
  610. /* method: somRenewNoInit */
  611. SOMObject*   somRenewNoInit(void* obj)
  612. {
  613. /*
  614.  *  Equivalent to somRenew except that somDefaultInit is not called.
  615.  */
  616.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somRenewNoInit)
  617.     (this,obj);
  618. }
  619.  
  620.  
  621. /* method: somRenewNoZero */
  622. SOMObject*   somRenewNoZero(void* obj)
  623. {
  624. /*
  625.  *  Equivalent to somRenew except that memory is not zeroed out.
  626.  */
  627.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somRenewNoZero)
  628.     (this,obj);
  629. }
  630.  
  631.  
  632. /* method: somRenewNoInitNoZero */
  633. SOMObject*   somRenewNoInitNoZero(void* obj)
  634. {
  635. /*
  636.  *  The purpose of this method is to load an object's method table.
  637.  *  The SOM API requires that somRenewNoInitNoZero always be
  638.  *  called when creating a new object whose metaclass is not SOMClass.
  639.  *  This is because metaclasses must be guaranteed that they can use
  640.  *  somRenewNoInitNoZero to track object creation if this is desired.
  641.  */
  642.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somRenewNoInitNoZero)
  643.     (this,obj);
  644. }
  645.  
  646.  
  647. /* nonstatic method: somAllocate */
  648. somToken   somAllocate(long size)
  649. {
  650. /*
  651.  *  Allocates memory to hold an object and returns a pointer to this memory.
  652.  *  This is a nonstatic method, and cannot be overridden. The default
  653.  *  implementation calls SOMMalloc, but a class designer can specify a
  654.  *  different implementation using the somallocate modifier in IDL. The
  655.  *  allocator takes the same parameters as this method.
  656.  */
  657.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somAllocate)
  658.     (this,size);
  659. }
  660.  
  661.  
  662. /* nonstatic method: somDeallocate */
  663. void   somDeallocate(somToken memptr)
  664. {
  665. /*
  666.  *  Zeros out the method table pointer stored in the word pointed to by
  667.  *  memptr, and then deallocates the block of memory pointed to by memptr.
  668.  *  This is a nonstatic method and cannot be overridden. The default
  669.  *  deallocator called is SOMFree, but a class designer can specify a
  670.  *  different deallocator using the somdeallocate modifier in IDL. The
  671.  *  deallocator takes a char* (memptr) and a long (size) as arguments.
  672.  */
  673.    SOM_ResolveD(this,SOMRReplicable,SOMClass,somDeallocate)
  674.     (this,memptr);
  675. }
  676.  
  677.  
  678. /* method: somInitClass */
  679. void   somInitClass(string className, 
  680.         SOMClass* parentClass, 
  681.         long dataSize, 
  682.         long maxStaticMethods, 
  683.         long majorVersion, 
  684.         long minorVersion)
  685. {
  686. /*
  687.  *  somInitClass is obsolete, and should no longer be used. The SOM 2.0
  688.  *  kernel provides special handling for redispatch stubs in the case
  689.  *  of SOM 1.0 classes, and use of this method is what tells the kernel
  690.  *  that old-style redispatch stubs will be registered.
  691.  */
  692.    SOM_ResolveD(this,SOMRReplicable,SOMClass,somInitClass)
  693.     (this,className,parentClass,dataSize,maxStaticMethods,majorVersion,minorVersion);
  694. }
  695.  
  696.  
  697. /* method: somAddStaticMethod */
  698. somMToken   somAddStaticMethod(somId methodId, 
  699.         somId methodDescriptor, 
  700.         somMethodPtr method, 
  701.         somMethodPtr redispatchStub, 
  702.         somMethodPtr applyStub)
  703. {
  704. /*
  705.  *  Adds the indicated method, creating and returning a new method token.
  706.  * 
  707.  *  <methodDescriptor> is the somId for an identifier that can be used
  708.  *  to access signature information about the method from an interface
  709.  *  repository.
  710.  * 
  711.  *  <method> is the actual method procedure for this method
  712.  * 
  713.  *  <redispatchStub> is a procedure with the same calling sequence as
  714.  *  <method> that invokes somDispatch for the method.
  715.  * 
  716.  *  <applyStub> is a procedure used to support somApply.
  717.  */
  718.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somAddStaticMethod)
  719.     (this,methodId,methodDescriptor,method,redispatchStub,applyStub);
  720. }
  721.  
  722.  
  723. /* method: somAddDynamicMethod */
  724. void   somAddDynamicMethod(somId methodId, 
  725.         somId methodDescriptor, 
  726.         somMethodPtr method, 
  727.         somMethodPtr applyStub)
  728. {
  729. /*
  730.  *  Adds the indicated method to the class's name lookup list.
  731.  *  If this happens to override a static method then this operation is
  732.  *  equivalent to <somOverrideSMethod> and the <methodDescriptor> and
  733.  *  <applyStub> arguments are ignored (the overridden method's values
  734.  *  will be used).
  735.  * 
  736.  *  <methodDescriptor> is the somId for an identifier that can be used
  737.  *  to access signature information about the method from an interface
  738.  *  repository.
  739.  * 
  740.  *  <method> is the actual method procedure for this method
  741.  * 
  742.  *  <applyStub> is a procedure that takes a standard variable argument
  743.  *  list data structure applies it to its target object by calling
  744.  *  <method> with arguments derived from the data structure.  Its
  745.  *  calling sequence is the same as the calling sequence of the
  746.  *  dispatch methods defined in SOMObject.  This stub is used in the
  747.  *  support of the dispatch methods used in some classes.  In classes
  748.  *  where the dispatch functions do not need such a function this
  749.  *  parameter may be null.
  750.  */
  751.    SOM_ResolveD(this,SOMRReplicable,SOMClass,somAddDynamicMethod)
  752.     (this,methodId,methodDescriptor,method,applyStub);
  753. }
  754.  
  755.  
  756. /* method: somOverrideSMethod */
  757. void   somOverrideSMethod(somId methodId, 
  758.         somMethodPtr method)
  759. {
  760. /*
  761.  *  This method can be used instead of <somAddStaticMethod> or
  762.  *  <somAddDynamicMethod> when it is known that the class' parent
  763.  *  class already supports this method.  This call does not require the
  764.  *  method descriptor and stub methods that the others do.
  765.  */
  766.    SOM_ResolveD(this,SOMRReplicable,SOMClass,somOverrideSMethod)
  767.     (this,methodId,method);
  768. }
  769.  
  770.  
  771. /* method: somClassReady */
  772. void   somClassReady()
  773. {
  774. /*
  775.  *  This method is invoked when all of the static initialization for
  776.  *  the class has been finished.  The default implementation simply
  777.  *  registers the newly constructed class with the SOMClassMgr.
  778.  */
  779.    SOM_ResolveD(this,SOMRReplicable,SOMClass,somClassReady)
  780.     (this);
  781. }
  782.  
  783.  
  784. /* method: somGetApplyStub */
  785. somMethodPtr   somGetApplyStub(somId methodId)
  786. {
  787. /*
  788.  *  Returns the apply stub associated with the specified method,
  789.  *  if one exists; otherwise NULL is returned. This method is obsolete,
  790.  *  and retained for binary compatability. In SOMr2, users never access
  791.  *  apply stubs directly; The function somApply is used to invoke apply
  792.  *  stubs. See somApply documentation for further information on apply
  793.  *  stubs, and see somAddStaticMethod documentation for information
  794.  *  on how apply stubs are registered by class implementations.
  795.  */
  796.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetApplyStub)
  797.     (this,methodId);
  798. }
  799.  
  800.  
  801. /* method: somGetClassData */
  802. somClassDataStructure*   somGetClassData()
  803. {
  804.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetClassData)
  805.     (this);
  806. }
  807.  
  808.  
  809. /* method: somSetClassData */
  810. void   somSetClassData(somClassDataStructure* cds)
  811. {
  812. /*
  813.  *  The class' pointer to the static <className>ClassData structure.
  814.  */
  815.    SOM_ResolveD(this,SOMRReplicable,SOMClass,somSetClassData)
  816.     (this,cds);
  817. }
  818.  
  819.  
  820. /* method: somGetClassMtab */
  821. somMethodTab*   somGetClassMtab()
  822. {
  823. /*
  824.  *  A pointer to the method table used by instances of this class. This
  825.  *  method was misnamed; it should have been called somGetInstanceMtab.
  826.  */
  827.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetClassMtab)
  828.     (this);
  829. }
  830.  
  831.  
  832. /* method: somGetInstanceOffset */
  833. long   somGetInstanceOffset()
  834. {
  835. /*
  836.  *  Returns the offset of instance data introduced by the receiver in
  837.  *  an instance of the receiver. This method is obsolete and not useful in
  838.  *  multiple-inheritance situations. The attribute somInstanceDataOffsets
  839.  *  replaces this method.
  840.  */
  841.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetInstanceOffset)
  842.     (this);
  843. }
  844.  
  845.  
  846. /* method: somGetInstancePartSize */
  847. long   somGetInstancePartSize()
  848. {
  849. /*
  850.  *  The size in bytes of the instance data introduced by the receiving
  851.  *  class.
  852.  */
  853.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetInstancePartSize)
  854.     (this);
  855. }
  856.  
  857.  
  858. /* method: somGetInstanceSize */
  859. long   somGetInstanceSize()
  860. {
  861. /*
  862.  *  The total size of an instance of the receiving class.
  863.  */
  864.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetInstanceSize)
  865.     (this);
  866. }
  867.  
  868.  
  869. /* method: somGetInstanceToken */
  870. somDToken   somGetInstanceToken()
  871. {
  872. /*
  873.  *  A data token that identifies the introduced portion of this class
  874.  *  within itself or any derived class.  This token can be subsequently
  875.  *  passed to the run-time somDataResolve function to locate the instance
  876.  *  data introduced by this class in any object derived from this class.
  877.  */
  878.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetInstanceToken)
  879.     (this);
  880. }
  881.  
  882.  
  883. /* method: somGetMemberToken */
  884. somDToken   somGetMemberToken(long memberOffset, 
  885.         somDToken instanceToken)
  886. {
  887. /*
  888.  *  Returns a data token that for the data member at offset
  889.  *  "memberOffset" within the introduced portion of the class identified
  890.  *  by instanceToken.  The instance token must have been obtained from a
  891.  *  previous invocation of somGetInstanceToken.  The returned member
  892.  *  token can be subsequently passed to the run-time somDataResolve
  893.  *  function to locate the data member.
  894.  */
  895.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetMemberToken)
  896.     (this,memberOffset,instanceToken);
  897. }
  898.  
  899.  
  900. /* method: somGetMethodData */
  901. boolean   somGetMethodData(somId methodId, 
  902.         somMethodData* md)
  903. {
  904. /*
  905.  *  If a method with id <methodId> is supported by the target class,
  906.  *  the structure pointed to by <md> is loaded with method information
  907.  *  and the value 1 is returned. In this case, if the method is not
  908.  *  dynamic, md->method is loaded with the result of somClassResolve on
  909.  *  the target class for the method. If the method is not supported,
  910.  *  md->id is loaded with 0, and the value 0 is returned.
  911.  */
  912.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetMethodData)
  913.     (this,methodId,md);
  914. }
  915.  
  916.  
  917. /* method: somGetRdStub */
  918. somMethodProc*   somGetRdStub(somId methodId)
  919. {
  920. /*
  921.  *  Returns a redispatch stub for the indicated method, if possible.
  922.  *  If not possible (because a valid redispatch stub has not been
  923.  *  registered, and there is insufficient information to dynamically
  924.  *  construct one), then a NULL is returned.
  925.  */
  926.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetRdStub)
  927.     (this,methodId);
  928. }
  929.  
  930.  
  931. /* method: somGetMethodDescriptor */
  932. somId   somGetMethodDescriptor(somId methodId)
  933. {
  934. /*
  935.  *  Returns the method descriptor for the indicated method.    If
  936.  *  this object does not support the indicated method then NULL is
  937.  *  returned.
  938.  */
  939.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetMethodDescriptor)
  940.     (this,methodId);
  941. }
  942.  
  943.  
  944. /* method: somGetMethodIndex */
  945. long   somGetMethodIndex(somId id)
  946. {
  947. /*
  948.  *  Returns the index for the specified method. (A number that may
  949.  *  change if any methods are added or deleted to this class object or
  950.  *  any of its ancestors).  This number is the basis for other calls to
  951.  *  get info about the method. Indexes start at 0. A -1 is returned if
  952.  *  the method cannot be found.
  953.  */
  954.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetMethodIndex)
  955.     (this,id);
  956. }
  957.  
  958.  
  959. /* method: somGetMethodToken */
  960. somMToken   somGetMethodToken(somId methodId)
  961. {
  962. /*
  963.  *  Returns the specified method's access token. This token can then
  964.  *  be passed to method resolution routines, which use the token
  965.  *  to select a method pointer from a method table.
  966.  */
  967.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetMethodToken)
  968.     (this,methodId);
  969. }
  970.  
  971.  
  972. /* method: somGetName */
  973. string   somGetName()
  974. {
  975. /*
  976.  *  This object's class name as a NULL terminated string.
  977.  */
  978.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetName)
  979.     (this);
  980. }
  981.  
  982.  
  983. /* method: somGetNthMethodData */
  984. boolean   somGetNthMethodData(long n, 
  985.         somMethodData* md)
  986. {
  987. /*
  988.  *  loads *md with the method data associated with the the nth method,
  989.  *  or NULL if there is no such method. Returns true is successful;
  990.  *  false otherwise.
  991.  */
  992.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetNthMethodData)
  993.     (this,n,md);
  994. }
  995.  
  996.  
  997. /* method: somGetNthMethodInfo */
  998. somId   somGetNthMethodInfo(long n, 
  999.         somId* descriptor)
  1000. {
  1001. /*
  1002.  *  Returns the id of the <n>th method if one exists and NULL
  1003.  *  otherwise.
  1004.  * 
  1005.  *  The ordering of the methods is unpredictable, but will not change
  1006.  *  unless some change is made to the class or one of its ancestor classes.
  1007.  * 
  1008.  *  See CORBA documentation for info on method descriptors.
  1009.  */
  1010.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetNthMethodInfo)
  1011.     (this,n,descriptor);
  1012. }
  1013.  
  1014.  
  1015. /* method: somGetNumMethods */
  1016. long   somGetNumMethods()
  1017. {
  1018. /*
  1019.  *  The number of methods currently supported by this class,
  1020.  *  including inherited methods (both static and dynamic).
  1021.  */
  1022.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetNumMethods)
  1023.     (this);
  1024. }
  1025.  
  1026.  
  1027. /* method: somGetNumStaticMethods */
  1028. long   somGetNumStaticMethods()
  1029. {
  1030. /*
  1031.  *  The number of static methods that this class has.  Can
  1032.  *  be used by a child class when initializing its method table.
  1033.  */
  1034.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetNumStaticMethods)
  1035.     (this);
  1036. }
  1037.  
  1038.  
  1039. /* method: somGetParent */
  1040. SOMClass*   somGetParent()
  1041. {
  1042. /*
  1043.  *  Returns the parent class of self (along its "left-hand" derivation
  1044.  *  path), if one exists and NULL otherwise.
  1045.  */
  1046.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetParent)
  1047.     (this);
  1048. }
  1049.  
  1050.  
  1051. /* method: somGetParents */
  1052. SOMClass_SOMClassSequence   somGetParents()
  1053. {
  1054. /*
  1055.  *  The parent classes of self.
  1056.  */
  1057.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetParents)
  1058.     (this);
  1059. }
  1060.  
  1061.  
  1062. /* method: somGetVersionNumbers */
  1063. void   somGetVersionNumbers(long* majorVersion, 
  1064.         long* minorVersion)
  1065. {
  1066. /*
  1067.  *  Returns the class' major and minor version numbers in the corresponding
  1068.  *  output parameters.
  1069.  */
  1070.    SOM_ResolveD(this,SOMRReplicable,SOMClass,somGetVersionNumbers)
  1071.     (this,majorVersion,minorVersion);
  1072. }
  1073.  
  1074.  
  1075. /* method: somFindMethod */
  1076. boolean   somFindMethod(somId methodId, 
  1077.         somMethodPtr* m)
  1078. {
  1079. /*
  1080.  *  Finds the method procedure associated with <methodId> for this
  1081.  *  class and sets <m> to it.  1 (true) is returned when the
  1082.  *  method procedure is a static method and 0 (false) is returned
  1083.  *  when the method procedure is dynamic method.
  1084.  * 
  1085.  *  If the class does not support the specified method then
  1086.  *  <m> is set to NULL and the return value is meaningless.
  1087.  * 
  1088.  */
  1089.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somFindMethod)
  1090.     (this,methodId,m);
  1091. }
  1092.  
  1093.  
  1094. /* method: somFindMethodOk */
  1095. boolean   somFindMethodOk(somId methodId, 
  1096.         somMethodPtr* m)
  1097. {
  1098. /*
  1099.  *  Just like <somFindMethod> except that if the method is not
  1100.  *  supported then an error is raised and execution is halted.
  1101.  */
  1102.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somFindMethodOk)
  1103.     (this,methodId,m);
  1104. }
  1105.  
  1106.  
  1107. /* method: somFindSMethod */
  1108. somMethodPtr   somFindSMethod(somId methodId)
  1109. {
  1110. /*
  1111.  *  Finds the indicated method, which must be a static method supported
  1112.  *  by this class, and returns a pointer to its method procedure.
  1113.  *  If the method is not supported by the receiver (as a static method
  1114.  *  or at all) then a NULL pointer is returned.
  1115.  */
  1116.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somFindSMethod)
  1117.     (this,methodId);
  1118. }
  1119.  
  1120.  
  1121. /* method: somFindSMethodOk */
  1122. somMethodPtr   somFindSMethodOk(somId methodId)
  1123. {
  1124. /*
  1125.  *  Uses <somFindSMethod>, and raises an error if the result is NULL.
  1126.  */
  1127.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somFindSMethodOk)
  1128.     (this,methodId);
  1129. }
  1130.  
  1131.  
  1132. /* method: somLookupMethod */
  1133. somMethodPtr   somLookupMethod(somId methodId)
  1134. {
  1135. /*
  1136.  *  Like <somFindSMethodOK>, but without restriction to static methods.
  1137.  */
  1138.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somLookupMethod)
  1139.     (this,methodId);
  1140. }
  1141.  
  1142.  
  1143. /* method: somCheckVersion */
  1144. boolean   somCheckVersion(long majorVersion, 
  1145.         long minorVersion)
  1146. {
  1147. /*
  1148.  *  Returns 1 (true) if the implementation of this class is
  1149.  *  compatible with the specified major and minor version number and
  1150.  *  false (0) otherwise.  An implementation is compatible with the
  1151.  *  specified version numbers if it has the same major version number
  1152.  *  and a minor version number that is equal to or greater than
  1153.  *  <minorVersion>.    The major, minor version number pair (0,0) is
  1154.  *  considered to match any version.  This method is usually called
  1155.  *  immediately after creating the class object to verify that a
  1156.  *  dynamically loaded class definition is compatible with a using
  1157.  *  application.
  1158.  */
  1159.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somCheckVersion)
  1160.     (this,majorVersion,minorVersion);
  1161. }
  1162.  
  1163.  
  1164. /* method: somDescendedFrom */
  1165. boolean   somDescendedFrom(SOMClass* aClassObj)
  1166. {
  1167. /*
  1168.  *  Returns 1 (true) if <self> is a descendent class of <aClassObj> and
  1169.  *  0 (false) otherwise.  Note: a class object is considered to be
  1170.  *  descended itself for the purposes of this method.
  1171.  */
  1172.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somDescendedFrom)
  1173.     (this,aClassObj);
  1174. }
  1175.  
  1176.  
  1177. /* method: somSupportsMethod */
  1178. boolean   somSupportsMethod(somId mId)
  1179. {
  1180. /*
  1181.  *  Returns 1 (true) if the indicated method is supported by this
  1182.  *  class and 0 (false) otherwise.
  1183.  */
  1184.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somSupportsMethod)
  1185.     (this,mId);
  1186. }
  1187.  
  1188.  
  1189. /* method: somDefinedMethod */
  1190. somMethodPtr   somDefinedMethod(somMToken method)
  1191. {
  1192. /*
  1193.  *  if the receiving class either introduces or overrides the
  1194.  *  indicated method, then its somMethodPtr is returned, otherwise
  1195.  *  NULL is returned.
  1196.  */
  1197.    return SOM_ResolveD(this,SOMRReplicable,SOMClass,somDefinedMethod)
  1198.     (this,method);
  1199. }
  1200.  
  1201.  
  1202. /* method: somOverrideMtab */
  1203. void   somOverrideMtab()
  1204. {
  1205. /*
  1206.  *  Overrides the method table pointers to point to the redispatch stubs.
  1207.  *  All the methods except somDispatch methods are overriden.
  1208.  */
  1209.    SOM_ResolveD(this,SOMRReplicable,SOMClass,somOverrideMtab)
  1210.     (this);
  1211. }
  1212.  
  1213.  
  1214. /* method: somDestruct */
  1215. void   somDestruct(octet doFree, 
  1216.         som3DestructCtrl* ctrl)
  1217. {
  1218. /*
  1219.  *  The default destructor for a SOM object. A nonzero <doFree>
  1220.  *  indicates that the object storage should be freed by the
  1221.  *  object's class (via somDeallocate) after uninitialization.
  1222.  *  As with somDefaultInit, a null ctrl can be passed.
  1223.  */
  1224.    SOM_ResolveD(this,SOMRReplicable,SOMObject,somDestruct)
  1225.     (this,doFree,ctrl);
  1226. }
  1227.  
  1228.  
  1229. /* initializer method: somDefaultCopyInit */
  1230. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  1231.         SOMObject* fromObj)
  1232. {
  1233. /*
  1234.  *  A default copy constructor. Use this to make copies of objects for
  1235.  *  calling methods with "by-value" argument semantics.
  1236.  */
  1237.    SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultCopyInit)
  1238.     (this,ctrl,fromObj);
  1239. }
  1240.  
  1241.  
  1242. /* method: somDefaultAssign */
  1243. SOMRReplicable*  somDefaultAssign(som3AssignCtrl* ctrl, 
  1244.         SOMObject* fromObj)
  1245. {
  1246. /*
  1247.  *  A default assignment operator. Use this to "assign" the state of one
  1248.  *  object to another.
  1249.  */
  1250.    return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultAssign)
  1251.     (this,ctrl,fromObj);
  1252. }
  1253.  
  1254.  
  1255. /* initializer method: somDefaultConstCopyInit */
  1256. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  1257.         SOMObject* fromObj)
  1258. {
  1259. /*
  1260.  *  A default copy constructor that uses a const fromObj.
  1261.  */
  1262.    SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultConstCopyInit)
  1263.     (this,ctrl,fromObj);
  1264. }
  1265.  
  1266.  
  1267. /* initializer method: somDefaultVCopyInit */
  1268. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  1269.         SOMObject* fromObj)
  1270. {
  1271. /*
  1272.  *  A default copy constructor that uses a volatile fromObj.
  1273.  */
  1274.    SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultVCopyInit)
  1275.     (this,ctrl,fromObj);
  1276. }
  1277.  
  1278.  
  1279. /* initializer method: somDefaultConstVCopyInit */
  1280. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  1281.         SOMObject* fromObj)
  1282. {
  1283. /*
  1284.  *  A default copy constructor that uses a const volatile fromObj.
  1285.  */
  1286.    SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultConstVCopyInit)
  1287.     (this,ctrl,fromObj);
  1288. }
  1289.  
  1290.  
  1291. /* method: somDefaultConstAssign */
  1292. SOMRReplicable*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  1293.         SOMObject* fromObj)
  1294. {
  1295. /*
  1296.  *  A default assignment operator that uses a const fromObj.
  1297.  */
  1298.    return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultConstAssign)
  1299.     (this,ctrl,fromObj);
  1300. }
  1301.  
  1302.  
  1303. /* method: somDefaultVAssign */
  1304. SOMRReplicable*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  1305.         SOMObject* fromObj)
  1306. {
  1307. /*
  1308.  *  A default assignment operator that uses a volatile fromObj.
  1309.  */
  1310.    return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultVAssign)
  1311.     (this,ctrl,fromObj);
  1312. }
  1313.  
  1314.  
  1315. /* method: somDefaultConstVAssign */
  1316. SOMRReplicable*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  1317.         SOMObject* fromObj)
  1318. {
  1319. /*
  1320.  *  A default assignment operator that uses a const volatile fromObj.
  1321.  */
  1322.    return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDefaultConstVAssign)
  1323.     (this,ctrl,fromObj);
  1324. }
  1325.  
  1326.  
  1327. /* method: somInit */
  1328. void   somInit()
  1329. {
  1330. /*
  1331.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  1332.  */
  1333.    SOM_ResolveD(this,SOMRReplicable,SOMObject,somInit)
  1334.     (this);
  1335. }
  1336.  
  1337.  
  1338. /* method: somFree */
  1339. void   somFree()
  1340. {
  1341. /*
  1342.  *  Use as directed by framework implementations.
  1343.  */
  1344.    SOM_ResolveD(this,SOMRReplicable,SOMObject,somFree)
  1345.     (this);
  1346. }
  1347.  
  1348.  
  1349. /* method: somUninit */
  1350. void   somUninit()
  1351. {
  1352. /*
  1353.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  1354.  */
  1355.    SOM_ResolveD(this,SOMRReplicable,SOMObject,somUninit)
  1356.     (this);
  1357. }
  1358.  
  1359.  
  1360. /* method: somGetClass */
  1361. SOMClass*   somGetClass()
  1362. {
  1363. /*
  1364.  *  Return the receiver's class.
  1365.  */
  1366.    return SOM_ResolveD(this,SOMRReplicable,SOMObject,somGetClass)
  1367.     (this);
  1368. }
  1369.  
  1370.  
  1371. /* method: somGetClassName */
  1372. string   somGetClassName()
  1373. {
  1374. /*
  1375.  *  Return the name of the receiver's class.
  1376.  */
  1377.    return SOM_ResolveD(this,SOMRReplicable,SOMObject,somGetClassName)
  1378.     (this);
  1379. }
  1380.  
  1381.  
  1382. /* method: somGetSize */
  1383. long   somGetSize()
  1384. {
  1385. /*
  1386.  *  Return the size of the receiver.
  1387.  */
  1388.    return SOM_ResolveD(this,SOMRReplicable,SOMObject,somGetSize)
  1389.     (this);
  1390. }
  1391.  
  1392.  
  1393. /* method: somIsA */
  1394. boolean   somIsA(SOMClass* aClassObj)
  1395. {
  1396. /*
  1397.  *  Returns 1 (true) if the receiver responds to methods
  1398.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  1399.  */
  1400.    return SOM_ResolveD(this,SOMRReplicable,SOMObject,somIsA)
  1401.     (this,aClassObj);
  1402. }
  1403.  
  1404.  
  1405. /* method: somIsInstanceOf */
  1406. boolean   somIsInstanceOf(SOMClass* aClassObj)
  1407. {
  1408. /*
  1409.  *  Returns 1 (true) if the receiver is an instance of
  1410.  *  <aClassObj> and 0 (false) otherwise.
  1411.  */
  1412.    return SOM_ResolveD(this,SOMRReplicable,SOMObject,somIsInstanceOf)
  1413.     (this,aClassObj);
  1414. }
  1415.  
  1416.  
  1417. /* method: somRespondsTo */
  1418. boolean   somRespondsTo(somId mId)
  1419. {
  1420. /*
  1421.  *  Returns 1 (true) if the indicated method can be invoked
  1422.  *  on the receiver and 0 (false) otherwise.
  1423.  */
  1424.    return SOM_ResolveD(this,SOMRReplicable,SOMObject,somRespondsTo)
  1425.     (this,mId);
  1426. }
  1427.  
  1428.  
  1429. /* va_list method: somDispatch */
  1430.  
  1431. /*
  1432.  *  This method provides a generic, class-specific dispatch mechanism.
  1433.  *  It accepts as input <retValue> a pointer to the memory area to be
  1434.  *  loaded with the result of dispatching the method indicated by
  1435.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  1436.  *  on which the method is to be invoked as the first argument.
  1437.  */
  1438. /* the va_list invocation form */
  1439. boolean   SOMRReplicable_somDispatch(somToken* retValue, 
  1440.         somId methodId, 
  1441.         va_list ap)
  1442. {return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatch)
  1443.     (this,retValue,methodId,ap);
  1444. }
  1445.  
  1446. /* the varargs invocation form */
  1447. boolean   somDispatch(somToken* retValue, 
  1448.         somId methodId, 
  1449.         ...)
  1450. {
  1451. /*
  1452.  *  This method provides a generic, class-specific dispatch mechanism.
  1453.  *  It accepts as input <retValue> a pointer to the memory area to be
  1454.  *  loaded with the result of dispatching the method indicated by
  1455.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  1456.  *  on which the method is to be invoked as the first argument.
  1457.  */
  1458.    va_list ap;
  1459.    va_start(ap, methodId);
  1460.    boolean __somResult = 
  1461.       SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatch)
  1462.     (this,retValue,methodId,ap);
  1463.    va_end(ap);
  1464.    return __somResult;
  1465. }
  1466.  
  1467.  
  1468. /* va_list method: somClassDispatch */
  1469.  
  1470. /*
  1471.  *  Like somDispatch, but method resolution for static methods is done
  1472.  *  according to the clsObj instance method table.
  1473.  */
  1474. /* the va_list invocation form */
  1475. boolean   SOMRReplicable_somClassDispatch(SOMClass* clsObj, 
  1476.         somToken* retValue, 
  1477.         somId methodId, 
  1478.         va_list ap)
  1479. {return SOM_ResolveD(this,SOMRReplicable,SOMObject,somClassDispatch)
  1480.     (this,clsObj,retValue,methodId,ap);
  1481. }
  1482.  
  1483. /* the varargs invocation form */
  1484. boolean   somClassDispatch(SOMClass* clsObj, 
  1485.         somToken* retValue, 
  1486.         somId methodId, 
  1487.         ...)
  1488. {
  1489. /*
  1490.  *  Like somDispatch, but method resolution for static methods is done
  1491.  *  according to the clsObj instance method table.
  1492.  */
  1493.    va_list ap;
  1494.    va_start(ap, methodId);
  1495.    boolean __somResult = 
  1496.       SOM_ResolveD(this,SOMRReplicable,SOMObject,somClassDispatch)
  1497.     (this,clsObj,retValue,methodId,ap);
  1498.    va_end(ap);
  1499.    return __somResult;
  1500. }
  1501.  
  1502.  
  1503. /* method: somCastObj */
  1504. boolean   somCastObj(SOMClass* cls)
  1505. {
  1506. /*
  1507.  *  cast the receiving object to cls (which must be an ancestor of the
  1508.  *  objects true class. Returns true on success.
  1509.  */
  1510.    return SOM_ResolveD(this,SOMRReplicable,SOMObject,somCastObj)
  1511.     (this,cls);
  1512. }
  1513.  
  1514.  
  1515. /* method: somResetObj */
  1516. boolean   somResetObj()
  1517. {
  1518. /*
  1519.  *  reset an object to its true class. Returns true always.
  1520.  */
  1521.    return SOM_ResolveD(this,SOMRReplicable,SOMObject,somResetObj)
  1522.     (this);
  1523. }
  1524.  
  1525.  
  1526. /* va_list method: somDispatchV */
  1527.  
  1528. /*
  1529.  *  Obsolete. Use somDispatch instead.
  1530.  */
  1531. /* the va_list invocation form */
  1532. void   SOMRReplicable_somDispatchV(somId methodId, 
  1533.         somId descriptor, 
  1534.         va_list ap)
  1535. {   SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchV)
  1536.     (this,methodId,descriptor,ap);
  1537. }
  1538.  
  1539. /* the varargs invocation form */
  1540. void   somDispatchV(somId methodId, 
  1541.         somId descriptor, 
  1542.         ...)
  1543. {
  1544. /*
  1545.  *  Obsolete. Use somDispatch instead.
  1546.  */
  1547.    va_list ap;
  1548.    va_start(ap, descriptor);
  1549.    SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchV)
  1550.     (this,methodId,descriptor,ap);
  1551.    va_end(ap);
  1552. }
  1553.  
  1554.  
  1555. /* va_list method: somDispatchL */
  1556.  
  1557. /*
  1558.  *  Obsolete. Use somDispatch instead.
  1559.  */
  1560. /* the va_list invocation form */
  1561. long   SOMRReplicable_somDispatchL(somId methodId, 
  1562.         somId descriptor, 
  1563.         va_list ap)
  1564. {return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchL)
  1565.     (this,methodId,descriptor,ap);
  1566. }
  1567.  
  1568. /* the varargs invocation form */
  1569. long   somDispatchL(somId methodId, 
  1570.         somId descriptor, 
  1571.         ...)
  1572. {
  1573. /*
  1574.  *  Obsolete. Use somDispatch instead.
  1575.  */
  1576.    va_list ap;
  1577.    va_start(ap, descriptor);
  1578.    long __somResult = 
  1579.       SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchL)
  1580.     (this,methodId,descriptor,ap);
  1581.    va_end(ap);
  1582.    return __somResult;
  1583. }
  1584.  
  1585.  
  1586. /* va_list method: somDispatchA */
  1587.  
  1588. /*
  1589.  *  Obsolete. Use somDispatch instead.
  1590.  */
  1591. /* the va_list invocation form */
  1592. void*   SOMRReplicable_somDispatchA(somId methodId, 
  1593.         somId descriptor, 
  1594.         va_list ap)
  1595. {return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchA)
  1596.     (this,methodId,descriptor,ap);
  1597. }
  1598.  
  1599. /* the varargs invocation form */
  1600. void*   somDispatchA(somId methodId, 
  1601.         somId descriptor, 
  1602.         ...)
  1603. {
  1604. /*
  1605.  *  Obsolete. Use somDispatch instead.
  1606.  */
  1607.    va_list ap;
  1608.    va_start(ap, descriptor);
  1609.    void* __somResult = 
  1610.       SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchA)
  1611.     (this,methodId,descriptor,ap);
  1612.    va_end(ap);
  1613.    return __somResult;
  1614. }
  1615.  
  1616.  
  1617. /* va_list method: somDispatchD */
  1618.  
  1619. /*
  1620.  *  Obsolete. Use somDispatch instead.
  1621.  */
  1622. /* the va_list invocation form */
  1623. double   SOMRReplicable_somDispatchD(somId methodId, 
  1624.         somId descriptor, 
  1625.         va_list ap)
  1626. {return SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchD)
  1627.     (this,methodId,descriptor,ap);
  1628. }
  1629.  
  1630. /* the varargs invocation form */
  1631. double   somDispatchD(somId methodId, 
  1632.         somId descriptor, 
  1633.         ...)
  1634. {
  1635. /*
  1636.  *  Obsolete. Use somDispatch instead.
  1637.  */
  1638.    va_list ap;
  1639.    va_start(ap, descriptor);
  1640.    double __somResult = 
  1641.       SOM_ResolveD(this,SOMRReplicable,SOMObject,somDispatchD)
  1642.     (this,methodId,descriptor,ap);
  1643.    va_end(ap);
  1644.    return __somResult;
  1645. }
  1646.  
  1647.  
  1648. /* method: somPrintSelf */
  1649. SOMObject*   somPrintSelf()
  1650. {
  1651. /*
  1652.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  1653.  *  information about this object.  The default implementation just gives
  1654.  *  the object's class name and its address in memory.
  1655.  *  <self> is returned.
  1656.  */
  1657.    return SOM_ResolveD(this,SOMRReplicable,SOMObject,somPrintSelf)
  1658.     (this);
  1659. }
  1660.  
  1661.  
  1662. /* method: somDumpSelf */
  1663. void   somDumpSelf(long level)
  1664. {
  1665. /*
  1666.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  1667.  *  and its current state.
  1668.  * 
  1669.  *  <level> indicates the nesting level for describing compound objects
  1670.  *  it must be greater than or equal to zero.  All lines in the
  1671.  *  description will be preceeded by <2*level> spaces.
  1672.  * 
  1673.  *  This routine only actually writes the data that concerns the object
  1674.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  1675.  *  the object's current state.  This approach allows readable
  1676.  *  descriptions of compound objects to be constructed.
  1677.  * 
  1678.  *  Generally it is not necessary to override this method, if it is
  1679.  *  overriden it generally must be completely replaced.
  1680.  */
  1681.    SOM_ResolveD(this,SOMRReplicable,SOMObject,somDumpSelf)
  1682.     (this,level);
  1683. }
  1684.  
  1685.  
  1686. /* method: somDumpSelfInt */
  1687. void   somDumpSelfInt(long level)
  1688. {
  1689. /*
  1690.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  1691.  *  Generally this method will need to be overridden.  When overriding
  1692.  *  it, begin by calling the parent class form of this method and then
  1693.  *  write in a description of your class's instance data. This will
  1694.  *  result in a description of all the object's instance data going
  1695.  *  from its root ancestor class to its specific class.
  1696.  */
  1697.    SOM_ResolveD(this,SOMRReplicable,SOMObject,somDumpSelfInt)
  1698.     (this,level);
  1699. }
  1700.  
  1701.  
  1702.  
  1703. };   /* SOMRReplicable */
  1704.  
  1705.  
  1706.  
  1707. #endif       /* SOM_SOMRReplicable_xh */
  1708.