home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / warptlk3.zip / TOOLKIT / SOM / INCLUDE / SINKEV.XH < prev    next >
Text File  |  1995-08-30  |  18KB  |  667 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.2
  7.  *     SOM Emitter emitxh: 2.41
  8.  */
  9.  
  10. /*
  11.  * 
  12.  *    COMPONENT_NAME: somu
  13.  * 
  14.  *    ORIGINS: 27
  15.  * 
  16.  * 
  17.  *    10H9767, 10H9769  (C) COPYRIGHT International Business Machines Corp. 1992,1994
  18.  *    All Rights Reserved
  19.  *    Licensed Materials - Property of IBM
  20.  *    US Government Users Restricted Rights - Use, duplication or
  21.  *    disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  22.  * 
  23.  */
  24.  
  25.  
  26. #ifndef SOM_SOMESinkEvent_xh
  27. #define SOM_SOMESinkEvent_xh
  28.  
  29. class SOMESinkEvent;
  30.  
  31. /*
  32.  *  SOMESinkEvent is the class for generic sink events within the Event Manager.
  33.  *  This class should be queried for events of the following type(s):
  34.  *       EMSinkEvent (for files, pipes, and sockets)
  35.  *       EMMsgQEvent (for AIX message queues)
  36.  * 
  37.  *  On AIX, an instance of this class is created, initialized and passed to the
  38.  *  callback routine  for events (input/output/exception) associated with files,
  39.  *  sockets, pipes and Message Queues. On OS/2, the same is done for sockets only.
  40.  */
  41.  
  42. #define SOMESinkEvent_MajorVersion 2
  43. #define SOMESinkEvent_MinorVersion 1
  44.  
  45. /* C++ SOM defs */
  46. #include <somcls.xh>
  47. #include <somcm.xh>
  48.  
  49. /* C++ parent defs */
  50. #ifndef SOM_SOMEEvent_xh
  51. #include <event.xh>
  52. #endif
  53.  
  54. #ifndef SOMESinkEvent_API
  55. #define SOMESinkEvent_API
  56. /*
  57.  * -- The Class API
  58.  */
  59.  
  60. /*
  61.  * Start of user-defined types:
  62.  */
  63. class SOMClass;
  64. class SOMObject;
  65.  
  66. /*
  67.  * End of user-defined 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 * somTD_SOMESinkEvent_somevGetEventSink)(SOMESinkEvent *somSelf, Environment *ev);
  94. typedef void   (SOMLINK * somTD_SOMESinkEvent_somevSetEventSink)(SOMESinkEvent *somSelf, Environment *ev,
  95.         long sink);
  96.  
  97. /*
  98.  * -- Typedefs for Reintroduced Wrapper Methods
  99.  */
  100. typedef unsigned long   (SOMLINK * somTD_SOMESinkEvent_somevGetEventTime)(SOMESinkEvent *somSelf, Environment *ev);
  101. typedef unsigned long   (SOMLINK * somTD_SOMESinkEvent_somevGetEventType)(SOMESinkEvent *somSelf, Environment *ev);
  102. typedef void   (SOMLINK * somTD_SOMESinkEvent_somevSetEventTime)(SOMESinkEvent *somSelf, Environment *ev,
  103.         unsigned long time);
  104. typedef void   (SOMLINK * somTD_SOMESinkEvent_somevSetEventType)(SOMESinkEvent *somSelf, Environment *ev,
  105.         unsigned long type);
  106. typedef void   (SOMLINK * somTD_SOMESinkEvent_somInit)(SOMESinkEvent *somSelf);
  107. typedef void   (SOMLINK * somTD_SOMESinkEvent_somDefaultInit)(SOMESinkEvent *somSelf,
  108.         somInitCtrl* ctrl);
  109. typedef void   (SOMLINK * somTD_SOMESinkEvent_somDestruct)(SOMESinkEvent *somSelf,
  110.         octet doFree,
  111.         somDestructCtrl* ctrl);
  112. typedef void   (SOMLINK * somTD_SOMESinkEvent_somDefaultCopyInit)(SOMESinkEvent *somSelf,
  113.         somInitCtrl* ctrl,
  114.         SOMObject* fromObj);
  115. typedef SOMESinkEvent*   (SOMLINK * somTD_SOMESinkEvent_somDefaultAssign)(SOMESinkEvent *somSelf,
  116.         somAssignCtrl* ctrl,
  117.         SOMObject* fromObj);
  118. typedef void   (SOMLINK * somTD_SOMESinkEvent_somDefaultConstCopyInit)(SOMESinkEvent *somSelf,
  119.         somInitCtrl* ctrl,
  120.         SOMObject* fromObj);
  121. typedef void   (SOMLINK * somTD_SOMESinkEvent_somDefaultVCopyInit)(SOMESinkEvent *somSelf,
  122.         somInitCtrl* ctrl,
  123.         SOMObject* fromObj);
  124. typedef void   (SOMLINK * somTD_SOMESinkEvent_somDefaultConstVCopyInit)(SOMESinkEvent *somSelf,
  125.         somInitCtrl* ctrl,
  126.         SOMObject* fromObj);
  127. typedef SOMESinkEvent*   (SOMLINK * somTD_SOMESinkEvent_somDefaultConstAssign)(SOMESinkEvent *somSelf,
  128.         somAssignCtrl* ctrl,
  129.         SOMObject* fromObj);
  130. typedef SOMESinkEvent*   (SOMLINK * somTD_SOMESinkEvent_somDefaultVAssign)(SOMESinkEvent *somSelf,
  131.         somAssignCtrl* ctrl,
  132.         SOMObject* fromObj);
  133. typedef SOMESinkEvent*   (SOMLINK * somTD_SOMESinkEvent_somDefaultConstVAssign)(SOMESinkEvent *somSelf,
  134.         somAssignCtrl* ctrl,
  135.         SOMObject* fromObj);
  136. typedef void   (SOMLINK * somTD_SOMESinkEvent_somFree)(SOMESinkEvent *somSelf);
  137. typedef void   (SOMLINK * somTD_SOMESinkEvent_somUninit)(SOMESinkEvent *somSelf);
  138. typedef SOMClass*   (SOMLINK * somTD_SOMESinkEvent_somGetClass)(SOMESinkEvent *somSelf);
  139. typedef string   (SOMLINK * somTD_SOMESinkEvent_somGetClassName)(SOMESinkEvent *somSelf);
  140. typedef long   (SOMLINK * somTD_SOMESinkEvent_somGetSize)(SOMESinkEvent *somSelf);
  141. typedef boolean   (SOMLINK * somTD_SOMESinkEvent_somIsA)(SOMESinkEvent *somSelf,
  142.         SOMClass* aClassObj);
  143. typedef boolean   (SOMLINK * somTD_SOMESinkEvent_somIsInstanceOf)(SOMESinkEvent *somSelf,
  144.         SOMClass* aClassObj);
  145. typedef boolean   (SOMLINK * somTD_SOMESinkEvent_somRespondsTo)(SOMESinkEvent *somSelf,
  146.         somId mId);
  147. typedef boolean   (SOMLINK * somTD_SOMESinkEvent_somDispatch)(SOMESinkEvent *somSelf,
  148.         somToken* retValue,
  149.         somId methodId,
  150.         va_list ap);
  151. typedef boolean   (SOMLINK * somTD_SOMESinkEvent_somClassDispatch)(SOMESinkEvent *somSelf,
  152.         SOMClass* clsObj,
  153.         somToken* retValue,
  154.         somId methodId,
  155.         va_list ap);
  156. typedef boolean   (SOMLINK * somTD_SOMESinkEvent_somCastObj)(SOMESinkEvent *somSelf,
  157.         SOMClass* cls);
  158. typedef boolean   (SOMLINK * somTD_SOMESinkEvent_somResetObj)(SOMESinkEvent *somSelf);
  159. typedef void   (SOMLINK * somTD_SOMESinkEvent_somDispatchV)(SOMESinkEvent *somSelf,
  160.         somId methodId,
  161.         somId descriptor,
  162.         va_list ap);
  163. typedef long   (SOMLINK * somTD_SOMESinkEvent_somDispatchL)(SOMESinkEvent *somSelf,
  164.         somId methodId,
  165.         somId descriptor,
  166.         va_list ap);
  167. typedef void*   (SOMLINK * somTD_SOMESinkEvent_somDispatchA)(SOMESinkEvent *somSelf,
  168.         somId methodId,
  169.         somId descriptor,
  170.         va_list ap);
  171. typedef double   (SOMLINK * somTD_SOMESinkEvent_somDispatchD)(SOMESinkEvent *somSelf,
  172.         somId methodId,
  173.         somId descriptor,
  174.         va_list ap);
  175. typedef SOMObject*   (SOMLINK * somTD_SOMESinkEvent_somPrintSelf)(SOMESinkEvent *somSelf);
  176. typedef void   (SOMLINK * somTD_SOMESinkEvent_somDumpSelf)(SOMESinkEvent *somSelf,
  177.         long level);
  178. typedef void   (SOMLINK * somTD_SOMESinkEvent_somDumpSelfInt)(SOMESinkEvent *somSelf,
  179.         long level);
  180. }
  181.  
  182. #endif /* SOMESinkEvent_API */
  183.  
  184.  
  185. /*
  186.  * -- This emitter treats Method Tokens as Thunks by default.
  187.  * -- Use the sc modifier "nothunks" to change this default
  188.  */
  189. #undef somresolve_
  190. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  191.  
  192. /*
  193.  * -- The C++ Wrapper Class for SOMESinkEvent
  194.  */
  195. class SOMESinkEvent : public SOMEEvent
  196. {
  197. public:
  198.  
  199. // SOMESinkEvent::new creates the class object if necessary, and then uses somNewNoInit
  200. // to allocate memory and create the object. Initialization is in ctors.
  201. void *operator new(size_t size)
  202. {
  203.    SOM_IgnoreWarning(size);
  204.    if (!_SOMESinkEvent) SOMESinkEventNewClass(SOMESinkEvent_MajorVersion,SOMESinkEvent_MinorVersion);
  205.    return (void*)
  206.       SOM_Resolve(_SOMESinkEvent,SOMClass,somNewNoInit)
  207.          ((SOMClass *)((void*)_SOMESinkEvent));
  208. }
  209.  
  210. // SOMESinkEvent::delete uses the default deallocator for the object's class.
  211. void operator delete(void * obj)
  212. {
  213.    somToken objCls = obj ? *(void**)obj : (somToken) NULL;
  214.    if (somIsObj(objCls)) {
  215.       SOM_Resolve(objCls,SOMClass,somDeallocate)
  216.          ((SOMClass*)objCls, (string)obj);
  217.    }
  218. }
  219.  
  220. SOMESinkEvent()
  221. {
  222.    if (*(void**)this != 
  223.        ((somParentMtabStructPtr)
  224.         (SOMESinkEventCClassData.parentMtab))->mtab)
  225.       return;
  226.    somDefaultInit(0);
  227. }
  228.  
  229. SOMESinkEvent(SOMESinkEvent* fromObj)
  230. {
  231.    if (*(void**)this != 
  232.        ((somParentMtabStructPtr)
  233.         (SOMESinkEventCClassData.parentMtab))->mtab)
  234.       return;
  235.    somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  236. }
  237.  
  238. SOMESinkEvent(const SOMESinkEvent* fromObj)
  239. {
  240.    if (*(void**)this != 
  241.        ((somParentMtabStructPtr)
  242.         (SOMESinkEventCClassData.parentMtab))->mtab)
  243.       return;
  244.    somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  245. }
  246.  
  247. ~SOMESinkEvent()
  248. {
  249.    if (!somIsObj(this)) return;
  250.    somDestruct(0,0);
  251.    *(void**)this = **(void***)this;
  252. }
  253.  
  254.  
  255. /* method: somevGetEventSink */
  256. long   somevGetEventSink(Environment *ev)
  257. {
  258.    return SOM_ResolveD(this,SOMESinkEvent,SOMESinkEvent,somevGetEventSink)
  259.     (this, ev);
  260. }
  261.  
  262.  
  263. /* method: somevSetEventSink */
  264. void   somevSetEventSink(Environment *ev,
  265.         long sink)
  266. {
  267.    SOM_ResolveD(this,SOMESinkEvent,SOMESinkEvent,somevSetEventSink)
  268.     (this, ev,sink);
  269. }
  270.  
  271.  
  272. /*
  273.  * Reintroduce inherited methods
  274.  */
  275.  
  276. /* method: somevGetEventTime */
  277. unsigned long   somevGetEventTime(Environment *ev)
  278. {
  279.    return SOM_ResolveD(this,SOMESinkEvent,SOMEEvent,somevGetEventTime)
  280.     (this, ev);
  281. }
  282.  
  283.  
  284. /* method: somevGetEventType */
  285. unsigned long   somevGetEventType(Environment *ev)
  286. {
  287.    return SOM_ResolveD(this,SOMESinkEvent,SOMEEvent,somevGetEventType)
  288.     (this, ev);
  289. }
  290.  
  291.  
  292. /* method: somevSetEventTime */
  293. void   somevSetEventTime(Environment *ev,
  294.         unsigned long time)
  295. {
  296.    SOM_ResolveD(this,SOMESinkEvent,SOMEEvent,somevSetEventTime)
  297.     (this, ev,time);
  298. }
  299.  
  300.  
  301. /* method: somevSetEventType */
  302. void   somevSetEventType(Environment *ev,
  303.         unsigned long type)
  304. {
  305.    SOM_ResolveD(this,SOMESinkEvent,SOMEEvent,somevSetEventType)
  306.     (this, ev,type);
  307. }
  308.  
  309.  
  310. /* method: somInit */
  311. void   somInit()
  312. {
  313.    SOM_ResolveD(this,SOMESinkEvent,SOMObject,somInit)
  314.     (this);
  315. }
  316.  
  317.  
  318. /* initializer method: somDefaultInit */
  319. void   somDefaultInit(somInitCtrl* ctrl)
  320. {
  321.    SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDefaultInit)
  322.     (this,ctrl);
  323. }
  324.  
  325.  
  326. /* method: somDestruct */
  327. void   somDestruct(octet doFree,
  328.         somDestructCtrl* ctrl)
  329. {
  330.    SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDestruct)
  331.     (this,doFree,ctrl);
  332. }
  333.  
  334.  
  335. /* method: somDefaultCopyInit */
  336. void   somDefaultCopyInit(somInitCtrl* ctrl,
  337.         SOMObject* fromObj)
  338. {
  339.    SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDefaultCopyInit)
  340.     (this,ctrl,fromObj);
  341. }
  342.  
  343.  
  344. /* method: somDefaultAssign */
  345. SOMESinkEvent*  somDefaultAssign(somAssignCtrl* ctrl,
  346.         SOMObject* fromObj)
  347. {
  348.    return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDefaultAssign)
  349.     (this,ctrl,fromObj);
  350. }
  351.  
  352.  
  353. /* method: somDefaultConstCopyInit */
  354. void   somDefaultConstCopyInit(somInitCtrl* ctrl,
  355.         SOMObject* fromObj)
  356. {
  357.    SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDefaultConstCopyInit)
  358.     (this,ctrl,fromObj);
  359. }
  360.  
  361.  
  362. /* method: somDefaultVCopyInit */
  363. void   somDefaultVCopyInit(somInitCtrl* ctrl,
  364.         SOMObject* fromObj)
  365. {
  366.    SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDefaultVCopyInit)
  367.     (this,ctrl,fromObj);
  368. }
  369.  
  370.  
  371. /* method: somDefaultConstVCopyInit */
  372. void   somDefaultConstVCopyInit(somInitCtrl* ctrl,
  373.         SOMObject* fromObj)
  374. {
  375.    SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDefaultConstVCopyInit)
  376.     (this,ctrl,fromObj);
  377. }
  378.  
  379.  
  380. /* method: somDefaultConstAssign */
  381. SOMESinkEvent*  somDefaultConstAssign(somAssignCtrl* ctrl,
  382.         SOMObject* fromObj)
  383. {
  384.    return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDefaultConstAssign)
  385.     (this,ctrl,fromObj);
  386. }
  387.  
  388.  
  389. /* method: somDefaultVAssign */
  390. SOMESinkEvent*  somDefaultVAssign(somAssignCtrl* ctrl,
  391.         SOMObject* fromObj)
  392. {
  393.    return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDefaultVAssign)
  394.     (this,ctrl,fromObj);
  395. }
  396.  
  397.  
  398. /* method: somDefaultConstVAssign */
  399. SOMESinkEvent*  somDefaultConstVAssign(somAssignCtrl* ctrl,
  400.         SOMObject* fromObj)
  401. {
  402.    return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDefaultConstVAssign)
  403.     (this,ctrl,fromObj);
  404. }
  405.  
  406.  
  407. /* method: somFree */
  408. void   somFree()
  409. {
  410.    SOM_ResolveD(this,SOMESinkEvent,SOMObject,somFree)
  411.     (this);
  412. }
  413.  
  414.  
  415. /* method: somUninit */
  416. void   somUninit()
  417. {
  418.    SOM_ResolveD(this,SOMESinkEvent,SOMObject,somUninit)
  419.     (this);
  420. }
  421.  
  422.  
  423. /* method: somGetClass */
  424. SOMClass*   somGetClass()
  425. {
  426.    return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somGetClass)
  427.     (this);
  428. }
  429.  
  430.  
  431. /* method: somGetClassName */
  432. string   somGetClassName()
  433. {
  434.    return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somGetClassName)
  435.     (this);
  436. }
  437.  
  438.  
  439. /* method: somGetSize */
  440. long   somGetSize()
  441. {
  442.    return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somGetSize)
  443.     (this);
  444. }
  445.  
  446.  
  447. /* method: somIsA */
  448. boolean   somIsA(SOMClass* aClassObj)
  449. {
  450.    return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somIsA)
  451.     (this,aClassObj);
  452. }
  453.  
  454.  
  455. /* method: somIsInstanceOf */
  456. boolean   somIsInstanceOf(SOMClass* aClassObj)
  457. {
  458.    return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somIsInstanceOf)
  459.     (this,aClassObj);
  460. }
  461.  
  462.  
  463. /* method: somRespondsTo */
  464. boolean   somRespondsTo(somId mId)
  465. {
  466.    return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somRespondsTo)
  467.     (this,mId);
  468. }
  469.  
  470.  
  471. /* va_list method: somDispatch */
  472. /* the va_list invocation form */
  473. boolean   SOMESinkEvent_somDispatch(somToken* retValue,
  474.         somId methodId,
  475.         va_list ap)
  476. {
  477. return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDispatch)
  478.     (this,retValue,methodId,ap);
  479. }
  480.  
  481. /* the varargs invocation form */
  482. boolean   somDispatch(somToken* retValue,
  483.         somId methodId,
  484.         ...)
  485. {
  486.    va_list ap;
  487.    va_start(ap, methodId);
  488.    boolean __somResult = 
  489.       SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDispatch)
  490.     (this,retValue,methodId,ap);
  491.    va_end(ap);
  492.    return __somResult;
  493. }
  494.  
  495.  
  496. /* va_list method: somClassDispatch */
  497. /* the va_list invocation form */
  498. boolean   SOMESinkEvent_somClassDispatch(SOMClass* clsObj,
  499.         somToken* retValue,
  500.         somId methodId,
  501.         va_list ap)
  502. {
  503. return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somClassDispatch)
  504.     (this,clsObj,retValue,methodId,ap);
  505. }
  506.  
  507. /* the varargs invocation form */
  508. boolean   somClassDispatch(SOMClass* clsObj,
  509.         somToken* retValue,
  510.         somId methodId,
  511.         ...)
  512. {
  513.    va_list ap;
  514.    va_start(ap, methodId);
  515.    boolean __somResult = 
  516.       SOM_ResolveD(this,SOMESinkEvent,SOMObject,somClassDispatch)
  517.     (this,clsObj,retValue,methodId,ap);
  518.    va_end(ap);
  519.    return __somResult;
  520. }
  521.  
  522.  
  523. /* method: somCastObj */
  524. boolean   somCastObj(SOMClass* cls)
  525. {
  526.    return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somCastObj)
  527.     (this,cls);
  528. }
  529.  
  530.  
  531. /* method: somResetObj */
  532. boolean   somResetObj()
  533. {
  534.    return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somResetObj)
  535.     (this);
  536. }
  537.  
  538.  
  539. /* va_list method: somDispatchV */
  540. /* the va_list invocation form */
  541. void   SOMESinkEvent_somDispatchV(somId methodId,
  542.         somId descriptor,
  543.         va_list ap)
  544. {
  545.    SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDispatchV)
  546.     (this,methodId,descriptor,ap);
  547. }
  548.  
  549. /* the varargs invocation form */
  550. void   somDispatchV(somId methodId,
  551.         somId descriptor,
  552.         ...)
  553. {
  554.    va_list ap;
  555.    va_start(ap, descriptor);
  556.    SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDispatchV)
  557.     (this,methodId,descriptor,ap);
  558.    va_end(ap);
  559. }
  560.  
  561.  
  562. /* va_list method: somDispatchL */
  563. /* the va_list invocation form */
  564. long   SOMESinkEvent_somDispatchL(somId methodId,
  565.         somId descriptor,
  566.         va_list ap)
  567. {
  568. return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDispatchL)
  569.     (this,methodId,descriptor,ap);
  570. }
  571.  
  572. /* the varargs invocation form */
  573. long   somDispatchL(somId methodId,
  574.         somId descriptor,
  575.         ...)
  576. {
  577.    va_list ap;
  578.    va_start(ap, descriptor);
  579.    long __somResult = 
  580.       SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDispatchL)
  581.     (this,methodId,descriptor,ap);
  582.    va_end(ap);
  583.    return __somResult;
  584. }
  585.  
  586.  
  587. /* va_list method: somDispatchA */
  588. /* the va_list invocation form */
  589. void*   SOMESinkEvent_somDispatchA(somId methodId,
  590.         somId descriptor,
  591.         va_list ap)
  592. {
  593. return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDispatchA)
  594.     (this,methodId,descriptor,ap);
  595. }
  596.  
  597. /* the varargs invocation form */
  598. void*   somDispatchA(somId methodId,
  599.         somId descriptor,
  600.         ...)
  601. {
  602.    va_list ap;
  603.    va_start(ap, descriptor);
  604.    void* __somResult = 
  605.       SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDispatchA)
  606.     (this,methodId,descriptor,ap);
  607.    va_end(ap);
  608.    return __somResult;
  609. }
  610.  
  611.  
  612. /* va_list method: somDispatchD */
  613. /* the va_list invocation form */
  614. double   SOMESinkEvent_somDispatchD(somId methodId,
  615.         somId descriptor,
  616.         va_list ap)
  617. {
  618. return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDispatchD)
  619.     (this,methodId,descriptor,ap);
  620. }
  621.  
  622. /* the varargs invocation form */
  623. double   somDispatchD(somId methodId,
  624.         somId descriptor,
  625.         ...)
  626. {
  627.    va_list ap;
  628.    va_start(ap, descriptor);
  629.    double __somResult = 
  630.       SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDispatchD)
  631.     (this,methodId,descriptor,ap);
  632.    va_end(ap);
  633.    return __somResult;
  634. }
  635.  
  636.  
  637. /* method: somPrintSelf */
  638. SOMObject*   somPrintSelf()
  639. {
  640.    return SOM_ResolveD(this,SOMESinkEvent,SOMObject,somPrintSelf)
  641.     (this);
  642. }
  643.  
  644.  
  645. /* method: somDumpSelf */
  646. void   somDumpSelf(long level)
  647. {
  648.    SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDumpSelf)
  649.     (this,level);
  650. }
  651.  
  652.  
  653. /* method: somDumpSelfInt */
  654. void   somDumpSelfInt(long level)
  655. {
  656.    SOM_ResolveD(this,SOMESinkEvent,SOMObject,somDumpSelfInt)
  657.     (this,level);
  658. }
  659.  
  660.  
  661.  
  662. };   /* SOMESinkEvent */
  663.  
  664.  
  665.  
  666. #endif       /* SOM_SOMESinkEvent_xh */
  667.