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