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