home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / emregdat.xh < prev    next >
Text File  |  1999-02-22  |  29KB  |  919 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: emregdat.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_SOMEEMRegisterData_xh
  26. #define SOM_SOMEEMRegisterData_xh
  27.  
  28. class SOMEEMRegisterData;
  29.  
  30. /*
  31.  *  SOMEEMRegisterData is the class utilized for holding registration
  32.  *  data for events types to be registered with Event Management Framework(EMan)
  33.  */
  34.  
  35. #define SOMEEMRegisterData_MajorVersion 2
  36. #define SOMEEMRegisterData_MinorVersion 1
  37.  
  38. /* C++ SOM defs */
  39. #include <somcls.xh>
  40. #include <somcm.xh>
  41.  
  42. /* C++ parent defs */
  43. #ifndef SOM_SOMObject_xh
  44. #include <somobj.xh>
  45. #endif
  46.  
  47. #ifndef SOMEEMRegisterData_API
  48. #define SOMEEMRegisterData_API
  49. /*
  50.  * -- The Class API
  51.  */
  52.  
  53. /*
  54.  * Start of bindings for IDL types
  55.  */
  56.  
  57. class SOMClass;
  58. class SOMObject;
  59.  
  60. /*
  61.  * End of bindings for IDL types.
  62.  */
  63.  
  64. /* A procedure to create the SOMEEMRegisterData Class */
  65. SOMEXTERN SOMClass * SOMLINK SOMEEMRegisterDataNewClass(
  66.         integer4 majorVersion,
  67.         integer4 minorVersion);
  68.  
  69. /* The API to the SOMEEMRegisterData class object, and the methods it introduces. */
  70. SOMEXTERN struct SOMEEMRegisterDataClassDataStructure {
  71.     SOMClass *classObject;
  72.     somMToken someClearRegData;
  73.     somMToken someSetRegDataClientType;
  74.     somMToken someSetRegDataEventMask;
  75.     somMToken someSetRegDataSink;
  76.     somMToken someSetRegDataSinkMask;
  77.     somMToken someSetRegDataTimerCount;
  78.     somMToken someSetRegDataTimerInterval;
  79. } SOMDLINK SOMEEMRegisterDataClassData;
  80. #define _SOMEEMRegisterData SOMEEMRegisterDataClassData.classObject
  81.  
  82. /* The API to parentMtabs for SOMEEMRegisterData, and the instance data it introduces. */
  83. SOMEXTERN struct SOMEEMRegisterDataCClassDataStructure {
  84.     somMethodTabs parentMtab;
  85.     somDToken              instanceDataToken;
  86. } SOMDLINK SOMEEMRegisterDataCClassData;
  87.  
  88. /*
  89.  * -- Typedefs for SOMEEMRegisterData Method Procedures
  90.  */
  91. SOMEXTERN {
  92. typedef void   SOMLINK somTP_SOMEEMRegisterData_someClearRegData(SOMEEMRegisterData *somSelf, Environment *ev);
  93. typedef somTP_SOMEEMRegisterData_someClearRegData *somTD_SOMEEMRegisterData_someClearRegData;
  94. typedef void   SOMLINK somTP_SOMEEMRegisterData_someSetRegDataClientType(SOMEEMRegisterData *somSelf, Environment *ev, 
  95.         string clientType);
  96. typedef somTP_SOMEEMRegisterData_someSetRegDataClientType *somTD_SOMEEMRegisterData_someSetRegDataClientType;
  97. typedef void   SOMLINK somTP_SOMEEMRegisterData_someSetRegDataEventMask(SOMEEMRegisterData *somSelf, Environment *ev, 
  98.         long eventType, 
  99.         va_list ap);
  100. typedef somTP_SOMEEMRegisterData_someSetRegDataEventMask *somTD_SOMEEMRegisterData_someSetRegDataEventMask;
  101. typedef void   SOMLINK somTP_SOMEEMRegisterData_someSetRegDataSink(SOMEEMRegisterData *somSelf, Environment *ev, 
  102.         long sink);
  103. typedef somTP_SOMEEMRegisterData_someSetRegDataSink *somTD_SOMEEMRegisterData_someSetRegDataSink;
  104. typedef void   SOMLINK somTP_SOMEEMRegisterData_someSetRegDataSinkMask(SOMEEMRegisterData *somSelf, Environment *ev, 
  105.         unsigned long sinkMask);
  106. typedef somTP_SOMEEMRegisterData_someSetRegDataSinkMask *somTD_SOMEEMRegisterData_someSetRegDataSinkMask;
  107. typedef void   SOMLINK somTP_SOMEEMRegisterData_someSetRegDataTimerCount(SOMEEMRegisterData *somSelf, Environment *ev, 
  108.         long count);
  109. typedef somTP_SOMEEMRegisterData_someSetRegDataTimerCount *somTD_SOMEEMRegisterData_someSetRegDataTimerCount;
  110. typedef void   SOMLINK somTP_SOMEEMRegisterData_someSetRegDataTimerInterval(SOMEEMRegisterData *somSelf, Environment *ev, 
  111.         long interval);
  112. typedef somTP_SOMEEMRegisterData_someSetRegDataTimerInterval *somTD_SOMEEMRegisterData_someSetRegDataTimerInterval;
  113.  
  114. /*
  115.  * -- Typedefs for Reintroduced Wrapper Methods
  116.  */
  117. typedef void   SOMLINK somTP_SOMEEMRegisterData_somDefaultInit(SOMEEMRegisterData *somSelf, 
  118.         som3InitCtrl* ctrl);
  119. typedef somTP_SOMEEMRegisterData_somDefaultInit *somTD_SOMEEMRegisterData_somDefaultInit;
  120. typedef void   SOMLINK somTP_SOMEEMRegisterData_somDestruct(SOMEEMRegisterData *somSelf, 
  121.         octet doFree, 
  122.         som3DestructCtrl* ctrl);
  123. typedef somTP_SOMEEMRegisterData_somDestruct *somTD_SOMEEMRegisterData_somDestruct;
  124. typedef void   SOMLINK somTP_SOMEEMRegisterData_somDefaultCopyInit(SOMEEMRegisterData *somSelf, 
  125.         som3InitCtrl* ctrl, 
  126.         SOMObject* fromObj);
  127. typedef somTP_SOMEEMRegisterData_somDefaultCopyInit *somTD_SOMEEMRegisterData_somDefaultCopyInit;
  128. typedef SOMEEMRegisterData*   SOMLINK somTP_SOMEEMRegisterData_somDefaultAssign(SOMEEMRegisterData *somSelf, 
  129.         som3AssignCtrl* ctrl, 
  130.         SOMObject* fromObj);
  131. typedef somTP_SOMEEMRegisterData_somDefaultAssign *somTD_SOMEEMRegisterData_somDefaultAssign;
  132. typedef void   SOMLINK somTP_SOMEEMRegisterData_somDefaultConstCopyInit(SOMEEMRegisterData *somSelf, 
  133.         som3InitCtrl* ctrl, 
  134.         SOMObject* fromObj);
  135. typedef somTP_SOMEEMRegisterData_somDefaultConstCopyInit *somTD_SOMEEMRegisterData_somDefaultConstCopyInit;
  136. typedef void   SOMLINK somTP_SOMEEMRegisterData_somDefaultVCopyInit(SOMEEMRegisterData *somSelf, 
  137.         som3InitCtrl* ctrl, 
  138.         SOMObject* fromObj);
  139. typedef somTP_SOMEEMRegisterData_somDefaultVCopyInit *somTD_SOMEEMRegisterData_somDefaultVCopyInit;
  140. typedef void   SOMLINK somTP_SOMEEMRegisterData_somDefaultConstVCopyInit(SOMEEMRegisterData *somSelf, 
  141.         som3InitCtrl* ctrl, 
  142.         SOMObject* fromObj);
  143. typedef somTP_SOMEEMRegisterData_somDefaultConstVCopyInit *somTD_SOMEEMRegisterData_somDefaultConstVCopyInit;
  144. typedef SOMEEMRegisterData*   SOMLINK somTP_SOMEEMRegisterData_somDefaultConstAssign(SOMEEMRegisterData *somSelf, 
  145.         som3AssignCtrl* ctrl, 
  146.         SOMObject* fromObj);
  147. typedef somTP_SOMEEMRegisterData_somDefaultConstAssign *somTD_SOMEEMRegisterData_somDefaultConstAssign;
  148. typedef SOMEEMRegisterData*   SOMLINK somTP_SOMEEMRegisterData_somDefaultVAssign(SOMEEMRegisterData *somSelf, 
  149.         som3AssignCtrl* ctrl, 
  150.         SOMObject* fromObj);
  151. typedef somTP_SOMEEMRegisterData_somDefaultVAssign *somTD_SOMEEMRegisterData_somDefaultVAssign;
  152. typedef SOMEEMRegisterData*   SOMLINK somTP_SOMEEMRegisterData_somDefaultConstVAssign(SOMEEMRegisterData *somSelf, 
  153.         som3AssignCtrl* ctrl, 
  154.         SOMObject* fromObj);
  155. typedef somTP_SOMEEMRegisterData_somDefaultConstVAssign *somTD_SOMEEMRegisterData_somDefaultConstVAssign;
  156. typedef void   SOMLINK somTP_SOMEEMRegisterData_somInit(SOMEEMRegisterData *somSelf);
  157. typedef somTP_SOMEEMRegisterData_somInit *somTD_SOMEEMRegisterData_somInit;
  158. typedef void   SOMLINK somTP_SOMEEMRegisterData_somFree(SOMEEMRegisterData *somSelf);
  159. typedef somTP_SOMEEMRegisterData_somFree *somTD_SOMEEMRegisterData_somFree;
  160. typedef void   SOMLINK somTP_SOMEEMRegisterData_somUninit(SOMEEMRegisterData *somSelf);
  161. typedef somTP_SOMEEMRegisterData_somUninit *somTD_SOMEEMRegisterData_somUninit;
  162. typedef SOMClass*   SOMLINK somTP_SOMEEMRegisterData_somGetClass(SOMEEMRegisterData *somSelf);
  163. typedef somTP_SOMEEMRegisterData_somGetClass *somTD_SOMEEMRegisterData_somGetClass;
  164. typedef string   SOMLINK somTP_SOMEEMRegisterData_somGetClassName(SOMEEMRegisterData *somSelf);
  165. typedef somTP_SOMEEMRegisterData_somGetClassName *somTD_SOMEEMRegisterData_somGetClassName;
  166. typedef long   SOMLINK somTP_SOMEEMRegisterData_somGetSize(SOMEEMRegisterData *somSelf);
  167. typedef somTP_SOMEEMRegisterData_somGetSize *somTD_SOMEEMRegisterData_somGetSize;
  168. typedef boolean   SOMLINK somTP_SOMEEMRegisterData_somIsA(SOMEEMRegisterData *somSelf, 
  169.         SOMClass* aClassObj);
  170. typedef somTP_SOMEEMRegisterData_somIsA *somTD_SOMEEMRegisterData_somIsA;
  171. typedef boolean   SOMLINK somTP_SOMEEMRegisterData_somIsInstanceOf(SOMEEMRegisterData *somSelf, 
  172.         SOMClass* aClassObj);
  173. typedef somTP_SOMEEMRegisterData_somIsInstanceOf *somTD_SOMEEMRegisterData_somIsInstanceOf;
  174. typedef boolean   SOMLINK somTP_SOMEEMRegisterData_somRespondsTo(SOMEEMRegisterData *somSelf, 
  175.         somId mId);
  176. typedef somTP_SOMEEMRegisterData_somRespondsTo *somTD_SOMEEMRegisterData_somRespondsTo;
  177. typedef boolean   SOMLINK somTP_SOMEEMRegisterData_somDispatch(SOMEEMRegisterData *somSelf, 
  178.         somToken* retValue, 
  179.         somId methodId, 
  180.         va_list ap);
  181. typedef somTP_SOMEEMRegisterData_somDispatch *somTD_SOMEEMRegisterData_somDispatch;
  182. typedef boolean   SOMLINK somTP_SOMEEMRegisterData_somClassDispatch(SOMEEMRegisterData *somSelf, 
  183.         SOMClass* clsObj, 
  184.         somToken* retValue, 
  185.         somId methodId, 
  186.         va_list ap);
  187. typedef somTP_SOMEEMRegisterData_somClassDispatch *somTD_SOMEEMRegisterData_somClassDispatch;
  188. typedef boolean   SOMLINK somTP_SOMEEMRegisterData_somCastObj(SOMEEMRegisterData *somSelf, 
  189.         SOMClass* cls);
  190. typedef somTP_SOMEEMRegisterData_somCastObj *somTD_SOMEEMRegisterData_somCastObj;
  191. typedef boolean   SOMLINK somTP_SOMEEMRegisterData_somResetObj(SOMEEMRegisterData *somSelf);
  192. typedef somTP_SOMEEMRegisterData_somResetObj *somTD_SOMEEMRegisterData_somResetObj;
  193. typedef void   SOMLINK somTP_SOMEEMRegisterData_somDispatchV(SOMEEMRegisterData *somSelf, 
  194.         somId methodId, 
  195.         somId descriptor, 
  196.         va_list ap);
  197. typedef somTP_SOMEEMRegisterData_somDispatchV *somTD_SOMEEMRegisterData_somDispatchV;
  198. typedef long   SOMLINK somTP_SOMEEMRegisterData_somDispatchL(SOMEEMRegisterData *somSelf, 
  199.         somId methodId, 
  200.         somId descriptor, 
  201.         va_list ap);
  202. typedef somTP_SOMEEMRegisterData_somDispatchL *somTD_SOMEEMRegisterData_somDispatchL;
  203. typedef void*   SOMLINK somTP_SOMEEMRegisterData_somDispatchA(SOMEEMRegisterData *somSelf, 
  204.         somId methodId, 
  205.         somId descriptor, 
  206.         va_list ap);
  207. typedef somTP_SOMEEMRegisterData_somDispatchA *somTD_SOMEEMRegisterData_somDispatchA;
  208. typedef double   SOMLINK somTP_SOMEEMRegisterData_somDispatchD(SOMEEMRegisterData *somSelf, 
  209.         somId methodId, 
  210.         somId descriptor, 
  211.         va_list ap);
  212. typedef somTP_SOMEEMRegisterData_somDispatchD *somTD_SOMEEMRegisterData_somDispatchD;
  213. typedef SOMObject*   SOMLINK somTP_SOMEEMRegisterData_somPrintSelf(SOMEEMRegisterData *somSelf);
  214. typedef somTP_SOMEEMRegisterData_somPrintSelf *somTD_SOMEEMRegisterData_somPrintSelf;
  215. typedef void   SOMLINK somTP_SOMEEMRegisterData_somDumpSelf(SOMEEMRegisterData *somSelf, 
  216.         long level);
  217. typedef somTP_SOMEEMRegisterData_somDumpSelf *somTD_SOMEEMRegisterData_somDumpSelf;
  218. typedef void   SOMLINK somTP_SOMEEMRegisterData_somDumpSelfInt(SOMEEMRegisterData *somSelf, 
  219.         long level);
  220. typedef somTP_SOMEEMRegisterData_somDumpSelfInt *somTD_SOMEEMRegisterData_somDumpSelfInt;
  221. }
  222.  
  223. #endif /* SOMEEMRegisterData_API */
  224.  
  225.  
  226. /*
  227.  * -- This emitter treats Method Tokens as Thunks by default.
  228.  * -- Use the sc modifier "nothunks" to change this default
  229.  */
  230. #undef somresolve_
  231. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  232.  
  233. /*
  234.  * -- The C++ Wrapper Class for SOMEEMRegisterData
  235.  */
  236. class SOMEEMRegisterData : public SOMObject
  237. {
  238. /*
  239.  *  SOMEEMRegisterData is the class utilized for holding registration
  240.  *  data for events types to be registered with Event Management Framework(EMan)
  241.  */
  242. public:
  243.  
  244. // SOMEEMRegisterData::new creates the class object if necessary, and then uses somNewNoInit
  245. // to allocate memory and create the object. Initialization is in ctors.
  246. void *operator new(size_t)
  247. {
  248.    if (!_SOMEEMRegisterData) SOMEEMRegisterDataNewClass(SOMEEMRegisterData_MajorVersion,SOMEEMRegisterData_MinorVersion);
  249.    return (void*)
  250.       SOM_Resolve(_SOMEEMRegisterData,SOMClass,somNewNoInit)
  251.          ((SOMClass *)((void*)_SOMEEMRegisterData));
  252. }
  253.  
  254. // SOMEEMRegisterData::delete uses somDestruct.
  255. void operator delete(void * obj)
  256. {
  257.    if (obj && *(void**)obj) {
  258.       SOM_Resolve(obj,SOMObject,somFree)
  259.          ((SOMObject*)obj);
  260.    }
  261. }
  262.  
  263. SOMEEMRegisterData& operator=(SOMEEMRegisterData& fromObj)
  264. {
  265.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  266.    return *this;
  267. }
  268.  
  269. SOMEEMRegisterData()
  270. {
  271.    if (*(void**)this != 
  272.        ((somParentMtabStructPtr)
  273.         (SOMEEMRegisterDataCClassData.parentMtab))->mtab)
  274.       return;
  275.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  276. }
  277.  
  278. SOMEEMRegisterData(SOMEEMRegisterData* fromObj)
  279. {
  280.    if (*(void**)this != 
  281.        ((somParentMtabStructPtr)
  282.         (SOMEEMRegisterDataCClassData.parentMtab))->mtab)
  283.       return;
  284.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  285. }
  286.  
  287. #ifdef __IBMCPP__
  288. #pragma info(nocnv,nopar)
  289. #endif
  290. SOMEEMRegisterData(const SOMEEMRegisterData* fromObj)
  291. {
  292.    if (*(void**)this != 
  293.        ((somParentMtabStructPtr)
  294.         (SOMEEMRegisterDataCClassData.parentMtab))->mtab)
  295.       return;
  296.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  297. }
  298. #ifdef __IBMCPP__
  299. #pragma info(restore)
  300. #endif
  301.  
  302.  
  303. /* method: someClearRegData */
  304. void   someClearRegData(Environment *ev)
  305. {
  306. /*
  307.  *  Clears the registration data
  308.  */
  309.    SOM_ResolveD(this,SOMEEMRegisterData,SOMEEMRegisterData,someClearRegData)
  310.     (this, ev);
  311. }
  312.  
  313.  
  314. /* method: someSetRegDataClientType */
  315. void   someSetRegDataClientType(Environment *ev, 
  316.         string clientType)
  317. {
  318. /*
  319.  *  Sets the client event type within the registration data
  320.  */
  321.    SOM_ResolveD(this,SOMEEMRegisterData,SOMEEMRegisterData,someSetRegDataClientType)
  322.     (this, ev,clientType);
  323. }
  324.  
  325.  
  326. /* va_list method: someSetRegDataEventMask */
  327.  
  328. /*
  329.  *  Sets the generic event mask within the registration data, using NULL terminated
  330.  *  event type list. Event types are defined in eventmsk.h
  331.  */
  332. /* the va_list invocation form */
  333. void   SOMEEMRegisterData_someSetRegDataEventMask(Environment *ev, 
  334.         long eventType, 
  335.         va_list ap)
  336. {   SOM_ResolveD(this,SOMEEMRegisterData,SOMEEMRegisterData,someSetRegDataEventMask)
  337.     (this, ev,eventType,ap);
  338. }
  339.  
  340. /* the varargs invocation form */
  341. void   someSetRegDataEventMask(Environment *ev, 
  342.         long eventType, 
  343.         ...)
  344. {
  345. /*
  346.  *  Sets the generic event mask within the registration data, using NULL terminated
  347.  *  event type list. Event types are defined in eventmsk.h
  348.  */
  349.    va_list ap;
  350.    va_start(ap, eventType);
  351.    SOM_ResolveD(this,SOMEEMRegisterData,SOMEEMRegisterData,someSetRegDataEventMask)
  352.     (this, ev,eventType,ap);
  353.    va_end(ap);
  354. }
  355.  
  356.  
  357. /* method: someSetRegDataSink */
  358. void   someSetRegDataSink(Environment *ev, 
  359.         long sink)
  360. {
  361. /*
  362.  *  Sets the sink, or source i/o file descriptor, within the registration data
  363.  */
  364.    SOM_ResolveD(this,SOMEEMRegisterData,SOMEEMRegisterData,someSetRegDataSink)
  365.     (this, ev,sink);
  366. }
  367.  
  368.  
  369. /* method: someSetRegDataSinkMask */
  370. void   someSetRegDataSinkMask(Environment *ev, 
  371.         unsigned long sinkMask)
  372. {
  373. /*
  374.  *  Sets the sink mask within the registration data
  375.  */
  376.    SOM_ResolveD(this,SOMEEMRegisterData,SOMEEMRegisterData,someSetRegDataSinkMask)
  377.     (this, ev,sinkMask);
  378. }
  379.  
  380.  
  381. /* method: someSetRegDataTimerCount */
  382. void   someSetRegDataTimerCount(Environment *ev, 
  383.         long count)
  384. {
  385. /*
  386.  *  Sets the number of times the timer will trigger, within the registration data.
  387.  *  The default behavior is for the timer to trigger indefinitely.
  388.  */
  389.    SOM_ResolveD(this,SOMEEMRegisterData,SOMEEMRegisterData,someSetRegDataTimerCount)
  390.     (this, ev,count);
  391. }
  392.  
  393.  
  394. /* method: someSetRegDataTimerInterval */
  395. void   someSetRegDataTimerInterval(Environment *ev, 
  396.         long interval)
  397. {
  398. /*
  399.  *  Sets the timer interval within the registration data.
  400.  *  Interval specification is in milliseconds
  401.  */
  402.    SOM_ResolveD(this,SOMEEMRegisterData,SOMEEMRegisterData,someSetRegDataTimerInterval)
  403.     (this, ev,interval);
  404. }
  405.  
  406.  
  407. /*
  408.  * Reintroduce inherited methods
  409.  */
  410.  
  411. /* initializer method: somDefaultInit */
  412. void   somDefaultInit(som3InitCtrl* ctrl)
  413. {
  414. /*
  415.  *  A default initializer for a SOM object. Passing a null ctrl
  416.  *  indicates to the receiver that its class is the class of the
  417.  *  object being initialized, whereby the initializer will determine
  418.  *  an appropriate control structure.
  419.  */
  420.    SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDefaultInit)
  421.     (this,ctrl);
  422. }
  423.  
  424.  
  425. /* method: somDestruct */
  426. void   somDestruct(octet doFree, 
  427.         som3DestructCtrl* ctrl)
  428. {
  429. /*
  430.  *  The default destructor for a SOM object. A nonzero <doFree>
  431.  *  indicates that the object storage should be freed by the
  432.  *  object's class (via somDeallocate) after uninitialization.
  433.  *  As with somDefaultInit, a null ctrl can be passed.
  434.  */
  435.    SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDestruct)
  436.     (this,doFree,ctrl);
  437. }
  438.  
  439.  
  440. /* initializer method: somDefaultCopyInit */
  441. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  442.         SOMObject* fromObj)
  443. {
  444. /*
  445.  *  A default copy constructor. Use this to make copies of objects for
  446.  *  calling methods with "by-value" argument semantics.
  447.  */
  448.    SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDefaultCopyInit)
  449.     (this,ctrl,fromObj);
  450. }
  451.  
  452.  
  453. /* method: somDefaultAssign */
  454. SOMEEMRegisterData*  somDefaultAssign(som3AssignCtrl* ctrl, 
  455.         SOMObject* fromObj)
  456. {
  457. /*
  458.  *  A default assignment operator. Use this to "assign" the state of one
  459.  *  object to another.
  460.  */
  461.    return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDefaultAssign)
  462.     (this,ctrl,fromObj);
  463. }
  464.  
  465.  
  466. /* initializer method: somDefaultConstCopyInit */
  467. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  468.         SOMObject* fromObj)
  469. {
  470. /*
  471.  *  A default copy constructor that uses a const fromObj.
  472.  */
  473.    SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDefaultConstCopyInit)
  474.     (this,ctrl,fromObj);
  475. }
  476.  
  477.  
  478. /* initializer method: somDefaultVCopyInit */
  479. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  480.         SOMObject* fromObj)
  481. {
  482. /*
  483.  *  A default copy constructor that uses a volatile fromObj.
  484.  */
  485.    SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDefaultVCopyInit)
  486.     (this,ctrl,fromObj);
  487. }
  488.  
  489.  
  490. /* initializer method: somDefaultConstVCopyInit */
  491. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  492.         SOMObject* fromObj)
  493. {
  494. /*
  495.  *  A default copy constructor that uses a const volatile fromObj.
  496.  */
  497.    SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDefaultConstVCopyInit)
  498.     (this,ctrl,fromObj);
  499. }
  500.  
  501.  
  502. /* method: somDefaultConstAssign */
  503. SOMEEMRegisterData*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  504.         SOMObject* fromObj)
  505. {
  506. /*
  507.  *  A default assignment operator that uses a const fromObj.
  508.  */
  509.    return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDefaultConstAssign)
  510.     (this,ctrl,fromObj);
  511. }
  512.  
  513.  
  514. /* method: somDefaultVAssign */
  515. SOMEEMRegisterData*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  516.         SOMObject* fromObj)
  517. {
  518. /*
  519.  *  A default assignment operator that uses a volatile fromObj.
  520.  */
  521.    return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDefaultVAssign)
  522.     (this,ctrl,fromObj);
  523. }
  524.  
  525.  
  526. /* method: somDefaultConstVAssign */
  527. SOMEEMRegisterData*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  528.         SOMObject* fromObj)
  529. {
  530. /*
  531.  *  A default assignment operator that uses a const volatile fromObj.
  532.  */
  533.    return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDefaultConstVAssign)
  534.     (this,ctrl,fromObj);
  535. }
  536.  
  537.  
  538. /* method: somInit */
  539. void   somInit()
  540. {
  541. /*
  542.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  543.  */
  544.    SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somInit)
  545.     (this);
  546. }
  547.  
  548.  
  549. /* method: somFree */
  550. void   somFree()
  551. {
  552. /*
  553.  *  Use as directed by framework implementations.
  554.  */
  555.    SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somFree)
  556.     (this);
  557. }
  558.  
  559.  
  560. /* method: somUninit */
  561. void   somUninit()
  562. {
  563. /*
  564.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  565.  */
  566.    SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somUninit)
  567.     (this);
  568. }
  569.  
  570.  
  571. /* method: somGetClass */
  572. SOMClass*   somGetClass()
  573. {
  574. /*
  575.  *  Return the receiver's class.
  576.  */
  577.    return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somGetClass)
  578.     (this);
  579. }
  580.  
  581.  
  582. /* method: somGetClassName */
  583. string   somGetClassName()
  584. {
  585. /*
  586.  *  Return the name of the receiver's class.
  587.  */
  588.    return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somGetClassName)
  589.     (this);
  590. }
  591.  
  592.  
  593. /* method: somGetSize */
  594. long   somGetSize()
  595. {
  596. /*
  597.  *  Return the size of the receiver.
  598.  */
  599.    return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somGetSize)
  600.     (this);
  601. }
  602.  
  603.  
  604. /* method: somIsA */
  605. boolean   somIsA(SOMClass* aClassObj)
  606. {
  607. /*
  608.  *  Returns 1 (true) if the receiver responds to methods
  609.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  610.  */
  611.    return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somIsA)
  612.     (this,aClassObj);
  613. }
  614.  
  615.  
  616. /* method: somIsInstanceOf */
  617. boolean   somIsInstanceOf(SOMClass* aClassObj)
  618. {
  619. /*
  620.  *  Returns 1 (true) if the receiver is an instance of
  621.  *  <aClassObj> and 0 (false) otherwise.
  622.  */
  623.    return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somIsInstanceOf)
  624.     (this,aClassObj);
  625. }
  626.  
  627.  
  628. /* method: somRespondsTo */
  629. boolean   somRespondsTo(somId mId)
  630. {
  631. /*
  632.  *  Returns 1 (true) if the indicated method can be invoked
  633.  *  on the receiver and 0 (false) otherwise.
  634.  */
  635.    return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somRespondsTo)
  636.     (this,mId);
  637. }
  638.  
  639.  
  640. /* va_list method: somDispatch */
  641.  
  642. /*
  643.  *  This method provides a generic, class-specific dispatch mechanism.
  644.  *  It accepts as input <retValue> a pointer to the memory area to be
  645.  *  loaded with the result of dispatching the method indicated by
  646.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  647.  *  on which the method is to be invoked as the first argument.
  648.  */
  649. /* the va_list invocation form */
  650. boolean   SOMEEMRegisterData_somDispatch(somToken* retValue, 
  651.         somId methodId, 
  652.         va_list ap)
  653. {return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDispatch)
  654.     (this,retValue,methodId,ap);
  655. }
  656.  
  657. /* the varargs invocation form */
  658. boolean   somDispatch(somToken* retValue, 
  659.         somId methodId, 
  660.         ...)
  661. {
  662. /*
  663.  *  This method provides a generic, class-specific dispatch mechanism.
  664.  *  It accepts as input <retValue> a pointer to the memory area to be
  665.  *  loaded with the result of dispatching the method indicated by
  666.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  667.  *  on which the method is to be invoked as the first argument.
  668.  */
  669.    va_list ap;
  670.    va_start(ap, methodId);
  671.    boolean __somResult = 
  672.       SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDispatch)
  673.     (this,retValue,methodId,ap);
  674.    va_end(ap);
  675.    return __somResult;
  676. }
  677.  
  678.  
  679. /* va_list method: somClassDispatch */
  680.  
  681. /*
  682.  *  Like somDispatch, but method resolution for static methods is done
  683.  *  according to the clsObj instance method table.
  684.  */
  685. /* the va_list invocation form */
  686. boolean   SOMEEMRegisterData_somClassDispatch(SOMClass* clsObj, 
  687.         somToken* retValue, 
  688.         somId methodId, 
  689.         va_list ap)
  690. {return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somClassDispatch)
  691.     (this,clsObj,retValue,methodId,ap);
  692. }
  693.  
  694. /* the varargs invocation form */
  695. boolean   somClassDispatch(SOMClass* clsObj, 
  696.         somToken* retValue, 
  697.         somId methodId, 
  698.         ...)
  699. {
  700. /*
  701.  *  Like somDispatch, but method resolution for static methods is done
  702.  *  according to the clsObj instance method table.
  703.  */
  704.    va_list ap;
  705.    va_start(ap, methodId);
  706.    boolean __somResult = 
  707.       SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somClassDispatch)
  708.     (this,clsObj,retValue,methodId,ap);
  709.    va_end(ap);
  710.    return __somResult;
  711. }
  712.  
  713.  
  714. /* method: somCastObj */
  715. boolean   somCastObj(SOMClass* cls)
  716. {
  717. /*
  718.  *  cast the receiving object to cls (which must be an ancestor of the
  719.  *  objects true class. Returns true on success.
  720.  */
  721.    return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somCastObj)
  722.     (this,cls);
  723. }
  724.  
  725.  
  726. /* method: somResetObj */
  727. boolean   somResetObj()
  728. {
  729. /*
  730.  *  reset an object to its true class. Returns true always.
  731.  */
  732.    return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somResetObj)
  733.     (this);
  734. }
  735.  
  736.  
  737. /* va_list method: somDispatchV */
  738.  
  739. /*
  740.  *  Obsolete. Use somDispatch instead.
  741.  */
  742. /* the va_list invocation form */
  743. void   SOMEEMRegisterData_somDispatchV(somId methodId, 
  744.         somId descriptor, 
  745.         va_list ap)
  746. {   SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDispatchV)
  747.     (this,methodId,descriptor,ap);
  748. }
  749.  
  750. /* the varargs invocation form */
  751. void   somDispatchV(somId methodId, 
  752.         somId descriptor, 
  753.         ...)
  754. {
  755. /*
  756.  *  Obsolete. Use somDispatch instead.
  757.  */
  758.    va_list ap;
  759.    va_start(ap, descriptor);
  760.    SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDispatchV)
  761.     (this,methodId,descriptor,ap);
  762.    va_end(ap);
  763. }
  764.  
  765.  
  766. /* va_list method: somDispatchL */
  767.  
  768. /*
  769.  *  Obsolete. Use somDispatch instead.
  770.  */
  771. /* the va_list invocation form */
  772. long   SOMEEMRegisterData_somDispatchL(somId methodId, 
  773.         somId descriptor, 
  774.         va_list ap)
  775. {return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDispatchL)
  776.     (this,methodId,descriptor,ap);
  777. }
  778.  
  779. /* the varargs invocation form */
  780. long   somDispatchL(somId methodId, 
  781.         somId descriptor, 
  782.         ...)
  783. {
  784. /*
  785.  *  Obsolete. Use somDispatch instead.
  786.  */
  787.    va_list ap;
  788.    va_start(ap, descriptor);
  789.    long __somResult = 
  790.       SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDispatchL)
  791.     (this,methodId,descriptor,ap);
  792.    va_end(ap);
  793.    return __somResult;
  794. }
  795.  
  796.  
  797. /* va_list method: somDispatchA */
  798.  
  799. /*
  800.  *  Obsolete. Use somDispatch instead.
  801.  */
  802. /* the va_list invocation form */
  803. void*   SOMEEMRegisterData_somDispatchA(somId methodId, 
  804.         somId descriptor, 
  805.         va_list ap)
  806. {return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDispatchA)
  807.     (this,methodId,descriptor,ap);
  808. }
  809.  
  810. /* the varargs invocation form */
  811. void*   somDispatchA(somId methodId, 
  812.         somId descriptor, 
  813.         ...)
  814. {
  815. /*
  816.  *  Obsolete. Use somDispatch instead.
  817.  */
  818.    va_list ap;
  819.    va_start(ap, descriptor);
  820.    void* __somResult = 
  821.       SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDispatchA)
  822.     (this,methodId,descriptor,ap);
  823.    va_end(ap);
  824.    return __somResult;
  825. }
  826.  
  827.  
  828. /* va_list method: somDispatchD */
  829.  
  830. /*
  831.  *  Obsolete. Use somDispatch instead.
  832.  */
  833. /* the va_list invocation form */
  834. double   SOMEEMRegisterData_somDispatchD(somId methodId, 
  835.         somId descriptor, 
  836.         va_list ap)
  837. {return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDispatchD)
  838.     (this,methodId,descriptor,ap);
  839. }
  840.  
  841. /* the varargs invocation form */
  842. double   somDispatchD(somId methodId, 
  843.         somId descriptor, 
  844.         ...)
  845. {
  846. /*
  847.  *  Obsolete. Use somDispatch instead.
  848.  */
  849.    va_list ap;
  850.    va_start(ap, descriptor);
  851.    double __somResult = 
  852.       SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDispatchD)
  853.     (this,methodId,descriptor,ap);
  854.    va_end(ap);
  855.    return __somResult;
  856. }
  857.  
  858.  
  859. /* method: somPrintSelf */
  860. SOMObject*   somPrintSelf()
  861. {
  862. /*
  863.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  864.  *  information about this object.  The default implementation just gives
  865.  *  the object's class name and its address in memory.
  866.  *  <self> is returned.
  867.  */
  868.    return SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somPrintSelf)
  869.     (this);
  870. }
  871.  
  872.  
  873. /* method: somDumpSelf */
  874. void   somDumpSelf(long level)
  875. {
  876. /*
  877.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  878.  *  and its current state.
  879.  * 
  880.  *  <level> indicates the nesting level for describing compound objects
  881.  *  it must be greater than or equal to zero.  All lines in the
  882.  *  description will be preceeded by <2*level> spaces.
  883.  * 
  884.  *  This routine only actually writes the data that concerns the object
  885.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  886.  *  the object's current state.  This approach allows readable
  887.  *  descriptions of compound objects to be constructed.
  888.  * 
  889.  *  Generally it is not necessary to override this method, if it is
  890.  *  overriden it generally must be completely replaced.
  891.  */
  892.    SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDumpSelf)
  893.     (this,level);
  894. }
  895.  
  896.  
  897. /* method: somDumpSelfInt */
  898. void   somDumpSelfInt(long level)
  899. {
  900. /*
  901.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  902.  *  Generally this method will need to be overridden.  When overriding
  903.  *  it, begin by calling the parent class form of this method and then
  904.  *  write in a description of your class's instance data. This will
  905.  *  result in a description of all the object's instance data going
  906.  *  from its root ancestor class to its specific class.
  907.  */
  908.    SOM_ResolveD(this,SOMEEMRegisterData,SOMObject,somDumpSelfInt)
  909.     (this,level);
  910. }
  911.  
  912.  
  913.  
  914. };   /* SOMEEMRegisterData */
  915.  
  916.  
  917.  
  918. #endif       /* SOM_SOMEEMRegisterData_xh */
  919.