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