home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / workprev.xh < prev   
Text File  |  1999-02-22  |  26KB  |  855 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: workprev.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_SOMEWorkProcEvent_xh
  26. #define SOM_SOMEWorkProcEvent_xh
  27.  
  28. class SOMEWorkProcEvent;
  29.  
  30. /*
  31.  *  SOMEWorkProcEvent is the class for generic workProc events within the Event Manager.
  32.  *  This class should be queried for events of the following type(s):
  33.  *       EMWorkProcEvent
  34.  *  An instance of this class is initialized and passed to the callback
  35.  *  of a workproc event.
  36.  *  Although at present this class has no methods, its parent methods can be
  37.  *  called to verify that the event type is EMWorkProcEvent.
  38.  */
  39.  
  40. #define SOMEWorkProcEvent_MajorVersion 2
  41. #define SOMEWorkProcEvent_MinorVersion 1
  42.  
  43. /* C++ SOM defs */
  44. #include <somcls.xh>
  45. #include <somcm.xh>
  46.  
  47. /* C++ parent defs */
  48. #ifndef SOM_SOMEEvent_xh
  49. #include <event.xh>
  50. #endif
  51.  
  52. #ifndef SOMEWorkProcEvent_API
  53. #define SOMEWorkProcEvent_API
  54. /*
  55.  * -- The Class API
  56.  */
  57.  
  58. /*
  59.  * Start of bindings for IDL types
  60.  */
  61.  
  62. class SOMClass;
  63. class SOMObject;
  64.  
  65. /*
  66.  * End of bindings for IDL types.
  67.  */
  68.  
  69. /*
  70.  * Passthru lines: File: "C.xh", "after"
  71.  */
  72. #include <eventmsk.h>
  73.  
  74. /* A procedure to create the SOMEWorkProcEvent Class */
  75. SOMEXTERN SOMClass * SOMLINK SOMEWorkProcEventNewClass(
  76.         integer4 majorVersion,
  77.         integer4 minorVersion);
  78.  
  79. /* The API to the SOMEWorkProcEvent class object, and the methods it introduces. */
  80. SOMEXTERN struct SOMEWorkProcEventClassDataStructure {
  81.     SOMClass *classObject;
  82. } SOMDLINK SOMEWorkProcEventClassData;
  83. #define _SOMEWorkProcEvent SOMEWorkProcEventClassData.classObject
  84.  
  85. /* The API to parentMtabs for SOMEWorkProcEvent, and the instance data it introduces. */
  86. SOMEXTERN struct SOMEWorkProcEventCClassDataStructure {
  87.     somMethodTabs parentMtab;
  88.     somDToken              instanceDataToken;
  89. } SOMDLINK SOMEWorkProcEventCClassData;
  90.  
  91. /*
  92.  * -- Typedefs for SOMEWorkProcEvent Method Procedures
  93.  */
  94. SOMEXTERN {
  95.  
  96. /*
  97.  * -- Typedefs for Reintroduced Wrapper Methods
  98.  */
  99. typedef unsigned long   SOMLINK somTP_SOMEWorkProcEvent_somevGetEventTime(SOMEWorkProcEvent *somSelf, Environment *ev);
  100. typedef somTP_SOMEWorkProcEvent_somevGetEventTime *somTD_SOMEWorkProcEvent_somevGetEventTime;
  101. typedef unsigned long   SOMLINK somTP_SOMEWorkProcEvent_somevGetEventType(SOMEWorkProcEvent *somSelf, Environment *ev);
  102. typedef somTP_SOMEWorkProcEvent_somevGetEventType *somTD_SOMEWorkProcEvent_somevGetEventType;
  103. typedef void   SOMLINK somTP_SOMEWorkProcEvent_somevSetEventTime(SOMEWorkProcEvent *somSelf, Environment *ev, 
  104.         unsigned long time);
  105. typedef somTP_SOMEWorkProcEvent_somevSetEventTime *somTD_SOMEWorkProcEvent_somevSetEventTime;
  106. typedef void   SOMLINK somTP_SOMEWorkProcEvent_somevSetEventType(SOMEWorkProcEvent *somSelf, Environment *ev, 
  107.         unsigned long type);
  108. typedef somTP_SOMEWorkProcEvent_somevSetEventType *somTD_SOMEWorkProcEvent_somevSetEventType;
  109. typedef void   SOMLINK somTP_SOMEWorkProcEvent_somInit(SOMEWorkProcEvent *somSelf);
  110. typedef somTP_SOMEWorkProcEvent_somInit *somTD_SOMEWorkProcEvent_somInit;
  111. typedef void   SOMLINK somTP_SOMEWorkProcEvent_somDefaultInit(SOMEWorkProcEvent *somSelf, 
  112.         som3InitCtrl* ctrl);
  113. typedef somTP_SOMEWorkProcEvent_somDefaultInit *somTD_SOMEWorkProcEvent_somDefaultInit;
  114. typedef void   SOMLINK somTP_SOMEWorkProcEvent_somDestruct(SOMEWorkProcEvent *somSelf, 
  115.         octet doFree, 
  116.         som3DestructCtrl* ctrl);
  117. typedef somTP_SOMEWorkProcEvent_somDestruct *somTD_SOMEWorkProcEvent_somDestruct;
  118. typedef void   SOMLINK somTP_SOMEWorkProcEvent_somDefaultCopyInit(SOMEWorkProcEvent *somSelf, 
  119.         som3InitCtrl* ctrl, 
  120.         SOMObject* fromObj);
  121. typedef somTP_SOMEWorkProcEvent_somDefaultCopyInit *somTD_SOMEWorkProcEvent_somDefaultCopyInit;
  122. typedef SOMEWorkProcEvent*   SOMLINK somTP_SOMEWorkProcEvent_somDefaultAssign(SOMEWorkProcEvent *somSelf, 
  123.         som3AssignCtrl* ctrl, 
  124.         SOMObject* fromObj);
  125. typedef somTP_SOMEWorkProcEvent_somDefaultAssign *somTD_SOMEWorkProcEvent_somDefaultAssign;
  126. typedef void   SOMLINK somTP_SOMEWorkProcEvent_somDefaultConstCopyInit(SOMEWorkProcEvent *somSelf, 
  127.         som3InitCtrl* ctrl, 
  128.         SOMObject* fromObj);
  129. typedef somTP_SOMEWorkProcEvent_somDefaultConstCopyInit *somTD_SOMEWorkProcEvent_somDefaultConstCopyInit;
  130. typedef void   SOMLINK somTP_SOMEWorkProcEvent_somDefaultVCopyInit(SOMEWorkProcEvent *somSelf, 
  131.         som3InitCtrl* ctrl, 
  132.         SOMObject* fromObj);
  133. typedef somTP_SOMEWorkProcEvent_somDefaultVCopyInit *somTD_SOMEWorkProcEvent_somDefaultVCopyInit;
  134. typedef void   SOMLINK somTP_SOMEWorkProcEvent_somDefaultConstVCopyInit(SOMEWorkProcEvent *somSelf, 
  135.         som3InitCtrl* ctrl, 
  136.         SOMObject* fromObj);
  137. typedef somTP_SOMEWorkProcEvent_somDefaultConstVCopyInit *somTD_SOMEWorkProcEvent_somDefaultConstVCopyInit;
  138. typedef SOMEWorkProcEvent*   SOMLINK somTP_SOMEWorkProcEvent_somDefaultConstAssign(SOMEWorkProcEvent *somSelf, 
  139.         som3AssignCtrl* ctrl, 
  140.         SOMObject* fromObj);
  141. typedef somTP_SOMEWorkProcEvent_somDefaultConstAssign *somTD_SOMEWorkProcEvent_somDefaultConstAssign;
  142. typedef SOMEWorkProcEvent*   SOMLINK somTP_SOMEWorkProcEvent_somDefaultVAssign(SOMEWorkProcEvent *somSelf, 
  143.         som3AssignCtrl* ctrl, 
  144.         SOMObject* fromObj);
  145. typedef somTP_SOMEWorkProcEvent_somDefaultVAssign *somTD_SOMEWorkProcEvent_somDefaultVAssign;
  146. typedef SOMEWorkProcEvent*   SOMLINK somTP_SOMEWorkProcEvent_somDefaultConstVAssign(SOMEWorkProcEvent *somSelf, 
  147.         som3AssignCtrl* ctrl, 
  148.         SOMObject* fromObj);
  149. typedef somTP_SOMEWorkProcEvent_somDefaultConstVAssign *somTD_SOMEWorkProcEvent_somDefaultConstVAssign;
  150. typedef void   SOMLINK somTP_SOMEWorkProcEvent_somFree(SOMEWorkProcEvent *somSelf);
  151. typedef somTP_SOMEWorkProcEvent_somFree *somTD_SOMEWorkProcEvent_somFree;
  152. typedef void   SOMLINK somTP_SOMEWorkProcEvent_somUninit(SOMEWorkProcEvent *somSelf);
  153. typedef somTP_SOMEWorkProcEvent_somUninit *somTD_SOMEWorkProcEvent_somUninit;
  154. typedef SOMClass*   SOMLINK somTP_SOMEWorkProcEvent_somGetClass(SOMEWorkProcEvent *somSelf);
  155. typedef somTP_SOMEWorkProcEvent_somGetClass *somTD_SOMEWorkProcEvent_somGetClass;
  156. typedef string   SOMLINK somTP_SOMEWorkProcEvent_somGetClassName(SOMEWorkProcEvent *somSelf);
  157. typedef somTP_SOMEWorkProcEvent_somGetClassName *somTD_SOMEWorkProcEvent_somGetClassName;
  158. typedef long   SOMLINK somTP_SOMEWorkProcEvent_somGetSize(SOMEWorkProcEvent *somSelf);
  159. typedef somTP_SOMEWorkProcEvent_somGetSize *somTD_SOMEWorkProcEvent_somGetSize;
  160. typedef boolean   SOMLINK somTP_SOMEWorkProcEvent_somIsA(SOMEWorkProcEvent *somSelf, 
  161.         SOMClass* aClassObj);
  162. typedef somTP_SOMEWorkProcEvent_somIsA *somTD_SOMEWorkProcEvent_somIsA;
  163. typedef boolean   SOMLINK somTP_SOMEWorkProcEvent_somIsInstanceOf(SOMEWorkProcEvent *somSelf, 
  164.         SOMClass* aClassObj);
  165. typedef somTP_SOMEWorkProcEvent_somIsInstanceOf *somTD_SOMEWorkProcEvent_somIsInstanceOf;
  166. typedef boolean   SOMLINK somTP_SOMEWorkProcEvent_somRespondsTo(SOMEWorkProcEvent *somSelf, 
  167.         somId mId);
  168. typedef somTP_SOMEWorkProcEvent_somRespondsTo *somTD_SOMEWorkProcEvent_somRespondsTo;
  169. typedef boolean   SOMLINK somTP_SOMEWorkProcEvent_somDispatch(SOMEWorkProcEvent *somSelf, 
  170.         somToken* retValue, 
  171.         somId methodId, 
  172.         va_list ap);
  173. typedef somTP_SOMEWorkProcEvent_somDispatch *somTD_SOMEWorkProcEvent_somDispatch;
  174. typedef boolean   SOMLINK somTP_SOMEWorkProcEvent_somClassDispatch(SOMEWorkProcEvent *somSelf, 
  175.         SOMClass* clsObj, 
  176.         somToken* retValue, 
  177.         somId methodId, 
  178.         va_list ap);
  179. typedef somTP_SOMEWorkProcEvent_somClassDispatch *somTD_SOMEWorkProcEvent_somClassDispatch;
  180. typedef boolean   SOMLINK somTP_SOMEWorkProcEvent_somCastObj(SOMEWorkProcEvent *somSelf, 
  181.         SOMClass* cls);
  182. typedef somTP_SOMEWorkProcEvent_somCastObj *somTD_SOMEWorkProcEvent_somCastObj;
  183. typedef boolean   SOMLINK somTP_SOMEWorkProcEvent_somResetObj(SOMEWorkProcEvent *somSelf);
  184. typedef somTP_SOMEWorkProcEvent_somResetObj *somTD_SOMEWorkProcEvent_somResetObj;
  185. typedef void   SOMLINK somTP_SOMEWorkProcEvent_somDispatchV(SOMEWorkProcEvent *somSelf, 
  186.         somId methodId, 
  187.         somId descriptor, 
  188.         va_list ap);
  189. typedef somTP_SOMEWorkProcEvent_somDispatchV *somTD_SOMEWorkProcEvent_somDispatchV;
  190. typedef long   SOMLINK somTP_SOMEWorkProcEvent_somDispatchL(SOMEWorkProcEvent *somSelf, 
  191.         somId methodId, 
  192.         somId descriptor, 
  193.         va_list ap);
  194. typedef somTP_SOMEWorkProcEvent_somDispatchL *somTD_SOMEWorkProcEvent_somDispatchL;
  195. typedef void*   SOMLINK somTP_SOMEWorkProcEvent_somDispatchA(SOMEWorkProcEvent *somSelf, 
  196.         somId methodId, 
  197.         somId descriptor, 
  198.         va_list ap);
  199. typedef somTP_SOMEWorkProcEvent_somDispatchA *somTD_SOMEWorkProcEvent_somDispatchA;
  200. typedef double   SOMLINK somTP_SOMEWorkProcEvent_somDispatchD(SOMEWorkProcEvent *somSelf, 
  201.         somId methodId, 
  202.         somId descriptor, 
  203.         va_list ap);
  204. typedef somTP_SOMEWorkProcEvent_somDispatchD *somTD_SOMEWorkProcEvent_somDispatchD;
  205. typedef SOMObject*   SOMLINK somTP_SOMEWorkProcEvent_somPrintSelf(SOMEWorkProcEvent *somSelf);
  206. typedef somTP_SOMEWorkProcEvent_somPrintSelf *somTD_SOMEWorkProcEvent_somPrintSelf;
  207. typedef void   SOMLINK somTP_SOMEWorkProcEvent_somDumpSelf(SOMEWorkProcEvent *somSelf, 
  208.         long level);
  209. typedef somTP_SOMEWorkProcEvent_somDumpSelf *somTD_SOMEWorkProcEvent_somDumpSelf;
  210. typedef void   SOMLINK somTP_SOMEWorkProcEvent_somDumpSelfInt(SOMEWorkProcEvent *somSelf, 
  211.         long level);
  212. typedef somTP_SOMEWorkProcEvent_somDumpSelfInt *somTD_SOMEWorkProcEvent_somDumpSelfInt;
  213. }
  214.  
  215. #endif /* SOMEWorkProcEvent_API */
  216.  
  217.  
  218. /*
  219.  * -- This emitter treats Method Tokens as Thunks by default.
  220.  * -- Use the sc modifier "nothunks" to change this default
  221.  */
  222. #undef somresolve_
  223. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  224.  
  225. /*
  226.  * -- The C++ Wrapper Class for SOMEWorkProcEvent
  227.  */
  228. class SOMEWorkProcEvent : public SOMEEvent
  229. {
  230. /*
  231.  *  SOMEWorkProcEvent is the class for generic workProc events within the Event Manager.
  232.  *  This class should be queried for events of the following type(s):
  233.  *       EMWorkProcEvent
  234.  *  An instance of this class is initialized and passed to the callback
  235.  *  of a workproc event.
  236.  *  Although at present this class has no methods, its parent methods can be
  237.  *  called to verify that the event type is EMWorkProcEvent.
  238.  */
  239. public:
  240.  
  241. // SOMEWorkProcEvent::new creates the class object if necessary, and then uses somNewNoInit
  242. // to allocate memory and create the object. Initialization is in ctors.
  243. void *operator new(size_t)
  244. {
  245.    if (!_SOMEWorkProcEvent) SOMEWorkProcEventNewClass(SOMEWorkProcEvent_MajorVersion,SOMEWorkProcEvent_MinorVersion);
  246.    return (void*)
  247.       SOM_Resolve(_SOMEWorkProcEvent,SOMClass,somNewNoInit)
  248.          ((SOMClass *)((void*)_SOMEWorkProcEvent));
  249. }
  250.  
  251. // SOMEWorkProcEvent::delete uses somDestruct.
  252. void operator delete(void * obj)
  253. {
  254.    if (obj && *(void**)obj) {
  255.       SOM_Resolve(obj,SOMObject,somFree)
  256.          ((SOMObject*)obj);
  257.    }
  258. }
  259.  
  260. SOMEWorkProcEvent& operator=(SOMEWorkProcEvent& fromObj)
  261. {
  262.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  263.    return *this;
  264. }
  265.  
  266. SOMEWorkProcEvent()
  267. {
  268.    if (*(void**)this != 
  269.        ((somParentMtabStructPtr)
  270.         (SOMEWorkProcEventCClassData.parentMtab))->mtab)
  271.       return;
  272.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  273. }
  274.  
  275. SOMEWorkProcEvent(SOMEWorkProcEvent* fromObj)
  276. {
  277.    if (*(void**)this != 
  278.        ((somParentMtabStructPtr)
  279.         (SOMEWorkProcEventCClassData.parentMtab))->mtab)
  280.       return;
  281.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  282. }
  283.  
  284. #ifdef __IBMCPP__
  285. #pragma info(nocnv,nopar)
  286. #endif
  287. SOMEWorkProcEvent(const SOMEWorkProcEvent* fromObj)
  288. {
  289.    if (*(void**)this != 
  290.        ((somParentMtabStructPtr)
  291.         (SOMEWorkProcEventCClassData.parentMtab))->mtab)
  292.       return;
  293.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  294. }
  295. #ifdef __IBMCPP__
  296. #pragma info(restore)
  297. #endif
  298.  
  299.  
  300. /*
  301.  * Reintroduce inherited methods
  302.  */
  303.  
  304. /* method: somevGetEventTime */
  305. unsigned long   somevGetEventTime(Environment *ev)
  306. {
  307. /*
  308.  *  Returns the time of the generic event in milliseconds
  309.  */
  310.    return SOM_ResolveD(this,SOMEWorkProcEvent,SOMEEvent,somevGetEventTime)
  311.     (this, ev);
  312. }
  313.  
  314.  
  315. /* method: somevGetEventType */
  316. unsigned long   somevGetEventType(Environment *ev)
  317. {
  318. /*
  319.  *  Returns the type of generic event
  320.  */
  321.    return SOM_ResolveD(this,SOMEWorkProcEvent,SOMEEvent,somevGetEventType)
  322.     (this, ev);
  323. }
  324.  
  325.  
  326. /* method: somevSetEventTime */
  327. void   somevSetEventTime(Environment *ev, 
  328.         unsigned long time)
  329. {
  330. /*
  331.  *  Sets the time of the generic event (time is in milliseconds)
  332.  */
  333.    SOM_ResolveD(this,SOMEWorkProcEvent,SOMEEvent,somevSetEventTime)
  334.     (this, ev,time);
  335. }
  336.  
  337.  
  338. /* method: somevSetEventType */
  339. void   somevSetEventType(Environment *ev, 
  340.         unsigned long type)
  341. {
  342. /*
  343.  *  Sets the type of generic event
  344.  */
  345.    SOM_ResolveD(this,SOMEWorkProcEvent,SOMEEvent,somevSetEventType)
  346.     (this, ev,type);
  347. }
  348.  
  349.  
  350. /* method: somInit */
  351. void   somInit()
  352. {
  353.    SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somInit)
  354.     (this);
  355. }
  356.  
  357.  
  358. /* initializer method: somDefaultInit */
  359. void   somDefaultInit(som3InitCtrl* ctrl)
  360. {
  361. /*
  362.  *  A default initializer for a SOM object. Passing a null ctrl
  363.  *  indicates to the receiver that its class is the class of the
  364.  *  object being initialized, whereby the initializer will determine
  365.  *  an appropriate control structure.
  366.  */
  367.    SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDefaultInit)
  368.     (this,ctrl);
  369. }
  370.  
  371.  
  372. /* method: somDestruct */
  373. void   somDestruct(octet doFree, 
  374.         som3DestructCtrl* ctrl)
  375. {
  376. /*
  377.  *  The default destructor for a SOM object. A nonzero <doFree>
  378.  *  indicates that the object storage should be freed by the
  379.  *  object's class (via somDeallocate) after uninitialization.
  380.  *  As with somDefaultInit, a null ctrl can be passed.
  381.  */
  382.    SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDestruct)
  383.     (this,doFree,ctrl);
  384. }
  385.  
  386.  
  387. /* initializer method: somDefaultCopyInit */
  388. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  389.         SOMObject* fromObj)
  390. {
  391. /*
  392.  *  A default copy constructor. Use this to make copies of objects for
  393.  *  calling methods with "by-value" argument semantics.
  394.  */
  395.    SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDefaultCopyInit)
  396.     (this,ctrl,fromObj);
  397. }
  398.  
  399.  
  400. /* method: somDefaultAssign */
  401. SOMEWorkProcEvent*  somDefaultAssign(som3AssignCtrl* ctrl, 
  402.         SOMObject* fromObj)
  403. {
  404. /*
  405.  *  A default assignment operator. Use this to "assign" the state of one
  406.  *  object to another.
  407.  */
  408.    return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDefaultAssign)
  409.     (this,ctrl,fromObj);
  410. }
  411.  
  412.  
  413. /* initializer method: somDefaultConstCopyInit */
  414. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  415.         SOMObject* fromObj)
  416. {
  417. /*
  418.  *  A default copy constructor that uses a const fromObj.
  419.  */
  420.    SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDefaultConstCopyInit)
  421.     (this,ctrl,fromObj);
  422. }
  423.  
  424.  
  425. /* initializer method: somDefaultVCopyInit */
  426. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  427.         SOMObject* fromObj)
  428. {
  429. /*
  430.  *  A default copy constructor that uses a volatile fromObj.
  431.  */
  432.    SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDefaultVCopyInit)
  433.     (this,ctrl,fromObj);
  434. }
  435.  
  436.  
  437. /* initializer method: somDefaultConstVCopyInit */
  438. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  439.         SOMObject* fromObj)
  440. {
  441. /*
  442.  *  A default copy constructor that uses a const volatile fromObj.
  443.  */
  444.    SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDefaultConstVCopyInit)
  445.     (this,ctrl,fromObj);
  446. }
  447.  
  448.  
  449. /* method: somDefaultConstAssign */
  450. SOMEWorkProcEvent*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  451.         SOMObject* fromObj)
  452. {
  453. /*
  454.  *  A default assignment operator that uses a const fromObj.
  455.  */
  456.    return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDefaultConstAssign)
  457.     (this,ctrl,fromObj);
  458. }
  459.  
  460.  
  461. /* method: somDefaultVAssign */
  462. SOMEWorkProcEvent*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  463.         SOMObject* fromObj)
  464. {
  465. /*
  466.  *  A default assignment operator that uses a volatile fromObj.
  467.  */
  468.    return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDefaultVAssign)
  469.     (this,ctrl,fromObj);
  470. }
  471.  
  472.  
  473. /* method: somDefaultConstVAssign */
  474. SOMEWorkProcEvent*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  475.         SOMObject* fromObj)
  476. {
  477. /*
  478.  *  A default assignment operator that uses a const volatile fromObj.
  479.  */
  480.    return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDefaultConstVAssign)
  481.     (this,ctrl,fromObj);
  482. }
  483.  
  484.  
  485. /* method: somFree */
  486. void   somFree()
  487. {
  488. /*
  489.  *  Use as directed by framework implementations.
  490.  */
  491.    SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somFree)
  492.     (this);
  493. }
  494.  
  495.  
  496. /* method: somUninit */
  497. void   somUninit()
  498. {
  499. /*
  500.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  501.  */
  502.    SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somUninit)
  503.     (this);
  504. }
  505.  
  506.  
  507. /* method: somGetClass */
  508. SOMClass*   somGetClass()
  509. {
  510. /*
  511.  *  Return the receiver's class.
  512.  */
  513.    return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somGetClass)
  514.     (this);
  515. }
  516.  
  517.  
  518. /* method: somGetClassName */
  519. string   somGetClassName()
  520. {
  521. /*
  522.  *  Return the name of the receiver's class.
  523.  */
  524.    return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somGetClassName)
  525.     (this);
  526. }
  527.  
  528.  
  529. /* method: somGetSize */
  530. long   somGetSize()
  531. {
  532. /*
  533.  *  Return the size of the receiver.
  534.  */
  535.    return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somGetSize)
  536.     (this);
  537. }
  538.  
  539.  
  540. /* method: somIsA */
  541. boolean   somIsA(SOMClass* aClassObj)
  542. {
  543. /*
  544.  *  Returns 1 (true) if the receiver responds to methods
  545.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  546.  */
  547.    return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somIsA)
  548.     (this,aClassObj);
  549. }
  550.  
  551.  
  552. /* method: somIsInstanceOf */
  553. boolean   somIsInstanceOf(SOMClass* aClassObj)
  554. {
  555. /*
  556.  *  Returns 1 (true) if the receiver is an instance of
  557.  *  <aClassObj> and 0 (false) otherwise.
  558.  */
  559.    return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somIsInstanceOf)
  560.     (this,aClassObj);
  561. }
  562.  
  563.  
  564. /* method: somRespondsTo */
  565. boolean   somRespondsTo(somId mId)
  566. {
  567. /*
  568.  *  Returns 1 (true) if the indicated method can be invoked
  569.  *  on the receiver and 0 (false) otherwise.
  570.  */
  571.    return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somRespondsTo)
  572.     (this,mId);
  573. }
  574.  
  575.  
  576. /* va_list method: somDispatch */
  577.  
  578. /*
  579.  *  This method provides a generic, class-specific dispatch mechanism.
  580.  *  It accepts as input <retValue> a pointer to the memory area to be
  581.  *  loaded with the result of dispatching the method indicated by
  582.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  583.  *  on which the method is to be invoked as the first argument.
  584.  */
  585. /* the va_list invocation form */
  586. boolean   SOMEWorkProcEvent_somDispatch(somToken* retValue, 
  587.         somId methodId, 
  588.         va_list ap)
  589. {return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDispatch)
  590.     (this,retValue,methodId,ap);
  591. }
  592.  
  593. /* the varargs invocation form */
  594. boolean   somDispatch(somToken* retValue, 
  595.         somId methodId, 
  596.         ...)
  597. {
  598. /*
  599.  *  This method provides a generic, class-specific dispatch mechanism.
  600.  *  It accepts as input <retValue> a pointer to the memory area to be
  601.  *  loaded with the result of dispatching the method indicated by
  602.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  603.  *  on which the method is to be invoked as the first argument.
  604.  */
  605.    va_list ap;
  606.    va_start(ap, methodId);
  607.    boolean __somResult = 
  608.       SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDispatch)
  609.     (this,retValue,methodId,ap);
  610.    va_end(ap);
  611.    return __somResult;
  612. }
  613.  
  614.  
  615. /* va_list method: somClassDispatch */
  616.  
  617. /*
  618.  *  Like somDispatch, but method resolution for static methods is done
  619.  *  according to the clsObj instance method table.
  620.  */
  621. /* the va_list invocation form */
  622. boolean   SOMEWorkProcEvent_somClassDispatch(SOMClass* clsObj, 
  623.         somToken* retValue, 
  624.         somId methodId, 
  625.         va_list ap)
  626. {return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somClassDispatch)
  627.     (this,clsObj,retValue,methodId,ap);
  628. }
  629.  
  630. /* the varargs invocation form */
  631. boolean   somClassDispatch(SOMClass* clsObj, 
  632.         somToken* retValue, 
  633.         somId methodId, 
  634.         ...)
  635. {
  636. /*
  637.  *  Like somDispatch, but method resolution for static methods is done
  638.  *  according to the clsObj instance method table.
  639.  */
  640.    va_list ap;
  641.    va_start(ap, methodId);
  642.    boolean __somResult = 
  643.       SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somClassDispatch)
  644.     (this,clsObj,retValue,methodId,ap);
  645.    va_end(ap);
  646.    return __somResult;
  647. }
  648.  
  649.  
  650. /* method: somCastObj */
  651. boolean   somCastObj(SOMClass* cls)
  652. {
  653. /*
  654.  *  cast the receiving object to cls (which must be an ancestor of the
  655.  *  objects true class. Returns true on success.
  656.  */
  657.    return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somCastObj)
  658.     (this,cls);
  659. }
  660.  
  661.  
  662. /* method: somResetObj */
  663. boolean   somResetObj()
  664. {
  665. /*
  666.  *  reset an object to its true class. Returns true always.
  667.  */
  668.    return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somResetObj)
  669.     (this);
  670. }
  671.  
  672.  
  673. /* va_list method: somDispatchV */
  674.  
  675. /*
  676.  *  Obsolete. Use somDispatch instead.
  677.  */
  678. /* the va_list invocation form */
  679. void   SOMEWorkProcEvent_somDispatchV(somId methodId, 
  680.         somId descriptor, 
  681.         va_list ap)
  682. {   SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDispatchV)
  683.     (this,methodId,descriptor,ap);
  684. }
  685.  
  686. /* the varargs invocation form */
  687. void   somDispatchV(somId methodId, 
  688.         somId descriptor, 
  689.         ...)
  690. {
  691. /*
  692.  *  Obsolete. Use somDispatch instead.
  693.  */
  694.    va_list ap;
  695.    va_start(ap, descriptor);
  696.    SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDispatchV)
  697.     (this,methodId,descriptor,ap);
  698.    va_end(ap);
  699. }
  700.  
  701.  
  702. /* va_list method: somDispatchL */
  703.  
  704. /*
  705.  *  Obsolete. Use somDispatch instead.
  706.  */
  707. /* the va_list invocation form */
  708. long   SOMEWorkProcEvent_somDispatchL(somId methodId, 
  709.         somId descriptor, 
  710.         va_list ap)
  711. {return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDispatchL)
  712.     (this,methodId,descriptor,ap);
  713. }
  714.  
  715. /* the varargs invocation form */
  716. long   somDispatchL(somId methodId, 
  717.         somId descriptor, 
  718.         ...)
  719. {
  720. /*
  721.  *  Obsolete. Use somDispatch instead.
  722.  */
  723.    va_list ap;
  724.    va_start(ap, descriptor);
  725.    long __somResult = 
  726.       SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDispatchL)
  727.     (this,methodId,descriptor,ap);
  728.    va_end(ap);
  729.    return __somResult;
  730. }
  731.  
  732.  
  733. /* va_list method: somDispatchA */
  734.  
  735. /*
  736.  *  Obsolete. Use somDispatch instead.
  737.  */
  738. /* the va_list invocation form */
  739. void*   SOMEWorkProcEvent_somDispatchA(somId methodId, 
  740.         somId descriptor, 
  741.         va_list ap)
  742. {return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDispatchA)
  743.     (this,methodId,descriptor,ap);
  744. }
  745.  
  746. /* the varargs invocation form */
  747. void*   somDispatchA(somId methodId, 
  748.         somId descriptor, 
  749.         ...)
  750. {
  751. /*
  752.  *  Obsolete. Use somDispatch instead.
  753.  */
  754.    va_list ap;
  755.    va_start(ap, descriptor);
  756.    void* __somResult = 
  757.       SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDispatchA)
  758.     (this,methodId,descriptor,ap);
  759.    va_end(ap);
  760.    return __somResult;
  761. }
  762.  
  763.  
  764. /* va_list method: somDispatchD */
  765.  
  766. /*
  767.  *  Obsolete. Use somDispatch instead.
  768.  */
  769. /* the va_list invocation form */
  770. double   SOMEWorkProcEvent_somDispatchD(somId methodId, 
  771.         somId descriptor, 
  772.         va_list ap)
  773. {return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDispatchD)
  774.     (this,methodId,descriptor,ap);
  775. }
  776.  
  777. /* the varargs invocation form */
  778. double   somDispatchD(somId methodId, 
  779.         somId descriptor, 
  780.         ...)
  781. {
  782. /*
  783.  *  Obsolete. Use somDispatch instead.
  784.  */
  785.    va_list ap;
  786.    va_start(ap, descriptor);
  787.    double __somResult = 
  788.       SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDispatchD)
  789.     (this,methodId,descriptor,ap);
  790.    va_end(ap);
  791.    return __somResult;
  792. }
  793.  
  794.  
  795. /* method: somPrintSelf */
  796. SOMObject*   somPrintSelf()
  797. {
  798. /*
  799.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  800.  *  information about this object.  The default implementation just gives
  801.  *  the object's class name and its address in memory.
  802.  *  <self> is returned.
  803.  */
  804.    return SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somPrintSelf)
  805.     (this);
  806. }
  807.  
  808.  
  809. /* method: somDumpSelf */
  810. void   somDumpSelf(long level)
  811. {
  812. /*
  813.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  814.  *  and its current state.
  815.  * 
  816.  *  <level> indicates the nesting level for describing compound objects
  817.  *  it must be greater than or equal to zero.  All lines in the
  818.  *  description will be preceeded by <2*level> spaces.
  819.  * 
  820.  *  This routine only actually writes the data that concerns the object
  821.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  822.  *  the object's current state.  This approach allows readable
  823.  *  descriptions of compound objects to be constructed.
  824.  * 
  825.  *  Generally it is not necessary to override this method, if it is
  826.  *  overriden it generally must be completely replaced.
  827.  */
  828.    SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDumpSelf)
  829.     (this,level);
  830. }
  831.  
  832.  
  833. /* method: somDumpSelfInt */
  834. void   somDumpSelfInt(long level)
  835. {
  836. /*
  837.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  838.  *  Generally this method will need to be overridden.  When overriding
  839.  *  it, begin by calling the parent class form of this method and then
  840.  *  write in a description of your class's instance data. This will
  841.  *  result in a description of all the object's instance data going
  842.  *  from its root ancestor class to its specific class.
  843.  */
  844.    SOM_ResolveD(this,SOMEWorkProcEvent,SOMObject,somDumpSelfInt)
  845.     (this,level);
  846. }
  847.  
  848.  
  849.  
  850. };   /* SOMEWorkProcEvent */
  851.  
  852.  
  853.  
  854. #endif       /* SOM_SOMEWorkProcEvent_xh */
  855.