home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / eman.xh < prev    next >
Text File  |  1999-02-22  |  32KB  |  1,052 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: eman.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_SOMEEMan_xh
  26. #define SOM_SOMEEMan_xh
  27.  
  28. class SOMEEMan;
  29.  
  30. /*
  31.  *  The Event Manager class (EMan for short) is used to handle several input
  32.  *  events. The main purpose of this class is to provide a service that can do
  33.  *  a blocked (or timed) wait on several event sources concurrently.  Typically,
  34.  *  in a main program,  one registers an interest in an event type with EMan and
  35.  *  specifies a callback (a procedure or a method) to be invoked when the event
  36.  *  of interest occurs. After all the necessary registrations are done, the main
  37.  *  program is ended by a call to process events in EMan. This call is non-returning.
  38.  *  Eman then waits on multiple registered sources of events. The application is then
  39.  *  completely event driven. I.E., it does something only when an event occurs.
  40.  *  The control returns to EMan after processing each event. Further registrations
  41.  *  can be done inside of callback routines. So also unregistrations.
  42.  * 
  43.  *  AIX Specifics:
  44.  *  On AIX this event manager supports Timer, Sink (any file, pipe,
  45.  *  socket and Message Queue), Client and WorkProc events.
  46.  * 
  47.  *  OS/2 Specifics:
  48.  *  On OS/2 this event manager supports Timer, Sink(sockets only). Client and
  49.  *  WorkProc events.
  50.  *  To cope with multi-threaded applications on OS/2, the event manager
  51.  *  methods are mutually exclusive (i.e., at any time only one thread can be
  52.  *  executing inside of EMan).
  53.  *  If an application thread needs to stop EMan from running (i.e., achieve
  54.  *  mutual exclusion with EMan), it can use the two methods someGetEmanSem
  55.  *  and someReleaseEManSem to acquire and release EMan semaphore(s).
  56.  *  On AIX, at present, since AIX does not support threads calling these two methods
  57.  *  has no effect.
  58.  */
  59.  
  60. #define SOMEEMan_MajorVersion 2
  61. #define SOMEEMan_MinorVersion 1
  62.  
  63. /* C++ SOM defs */
  64. #include <somcls.xh>
  65. #include <somcm.xh>
  66.  
  67. /* C++ parent defs */
  68. #ifndef SOM_SOMObject_xh
  69. #include <somobj.xh>
  70. #endif
  71.  
  72. /*
  73.  * C++ metaclass def
  74.  */
  75. #include <snglicls.xh>
  76.  
  77. #ifndef SOMEEMan_API
  78. #define SOMEEMan_API
  79. /*
  80.  * -- The Class API
  81.  */
  82.  
  83. /*
  84.  * Start of bindings for IDL types
  85.  */
  86.  
  87. class SOMClass;
  88. class SOMObject;
  89. class SOMEEvent;
  90. class SOMEClientEvent;
  91. class SOMEEMRegisterData;
  92.  
  93. /*
  94.  * End of bindings for IDL types.
  95.  */
  96.  
  97. /*
  98.  * Passthru lines: File: "C.xh", "after"
  99.  */
  100. extern "C" {
  101. #include <emtypes.h>
  102. }
  103.  
  104. /* A procedure to create the SOMEEMan Class */
  105. class SOMMSingleInstance;
  106. SOMEXTERN SOMMSingleInstance * SOMLINK SOMEEManNewClass(
  107.         integer4 majorVersion,
  108.         integer4 minorVersion);
  109.  
  110. /* The API to the SOMEEMan class object, and the methods it introduces. */
  111. SOMEXTERN struct SOMEEManClassDataStructure {
  112.     SOMMSingleInstance *classObject;
  113.     somMToken someGetEManSem;
  114.     somMToken someReleaseEManSem;
  115.     somMToken someChangeRegData;
  116.     somMToken someProcessEvent;
  117.     somMToken someProcessEvents;
  118.     somMToken someQueueEvent;
  119.     somMToken someRegister;
  120.     somMToken someRegisterEv;
  121.     somMToken someRegisterProc;
  122.     somMToken someShutdown;
  123.     somMToken someUnRegister;
  124. } SOMDLINK SOMEEManClassData;
  125. #define _SOMEEMan SOMEEManClassData.classObject
  126.  
  127. /* The API to parentMtabs for SOMEEMan, and the instance data it introduces. */
  128. SOMEXTERN struct SOMEEManCClassDataStructure {
  129.     somMethodTabs parentMtab;
  130.     somDToken              instanceDataToken;
  131. } SOMDLINK SOMEEManCClassData;
  132.  
  133. /*
  134.  * -- Typedefs for SOMEEMan Method Procedures
  135.  */
  136. SOMEXTERN {
  137. typedef void   SOMLINK somTP_SOMEEMan_someGetEManSem(SOMEEMan *somSelf, Environment *ev);
  138. typedef somTP_SOMEEMan_someGetEManSem *somTD_SOMEEMan_someGetEManSem;
  139. typedef void   SOMLINK somTP_SOMEEMan_someReleaseEManSem(SOMEEMan *somSelf, Environment *ev);
  140. typedef somTP_SOMEEMan_someReleaseEManSem *somTD_SOMEEMan_someReleaseEManSem;
  141. typedef void   SOMLINK somTP_SOMEEMan_someChangeRegData(SOMEEMan *somSelf, Environment *ev, 
  142.         long registrationId, 
  143.         SOMEEMRegisterData* registerData);
  144. typedef somTP_SOMEEMan_someChangeRegData *somTD_SOMEEMan_someChangeRegData;
  145. typedef void   SOMLINK somTP_SOMEEMan_someProcessEvent(SOMEEMan *somSelf, Environment *ev, 
  146.         unsigned long mask);
  147. typedef somTP_SOMEEMan_someProcessEvent *somTD_SOMEEMan_someProcessEvent;
  148. typedef void   SOMLINK somTP_SOMEEMan_someProcessEvents(SOMEEMan *somSelf, Environment *ev);
  149. typedef somTP_SOMEEMan_someProcessEvents *somTD_SOMEEMan_someProcessEvents;
  150. typedef void   SOMLINK somTP_SOMEEMan_someQueueEvent(SOMEEMan *somSelf, Environment *ev, 
  151.         SOMEClientEvent* event);
  152. typedef somTP_SOMEEMan_someQueueEvent *somTD_SOMEEMan_someQueueEvent;
  153. typedef long   SOMLINK somTP_SOMEEMan_someRegister(SOMEEMan *somSelf, Environment *ev, 
  154.         SOMEEMRegisterData* registerData, 
  155.         SOMObject* targetObject, 
  156.         string targetMethod, 
  157.         void* targetData);
  158. typedef somTP_SOMEEMan_someRegister *somTD_SOMEEMan_someRegister;
  159. typedef long   SOMLINK somTP_SOMEEMan_someRegisterEv(SOMEEMan *somSelf, Environment *ev, 
  160.         SOMEEMRegisterData* registerData, 
  161.         SOMObject* targetObject, 
  162.         Environment* callbackEv, 
  163.         string targetMethod, 
  164.         void* targetData);
  165. typedef somTP_SOMEEMan_someRegisterEv *somTD_SOMEEMan_someRegisterEv;
  166. typedef long   SOMLINK somTP_SOMEEMan_someRegisterProc(SOMEEMan *somSelf, Environment *ev, 
  167.         SOMEEMRegisterData* registerData, 
  168.         EMRegProc* targetProcedure, 
  169.         void* targetData);
  170. typedef somTP_SOMEEMan_someRegisterProc *somTD_SOMEEMan_someRegisterProc;
  171. typedef void   SOMLINK somTP_SOMEEMan_someShutdown(SOMEEMan *somSelf, Environment *ev);
  172. typedef somTP_SOMEEMan_someShutdown *somTD_SOMEEMan_someShutdown;
  173. typedef void   SOMLINK somTP_SOMEEMan_someUnRegister(SOMEEMan *somSelf, Environment *ev, 
  174.         long registrationId);
  175. typedef somTP_SOMEEMan_someUnRegister *somTD_SOMEEMan_someUnRegister;
  176.  
  177. /*
  178.  * -- Typedefs for Reintroduced Wrapper Methods
  179.  */
  180. typedef void   SOMLINK somTP_SOMEEMan_somDefaultInit(SOMEEMan *somSelf, 
  181.         som3InitCtrl* ctrl);
  182. typedef somTP_SOMEEMan_somDefaultInit *somTD_SOMEEMan_somDefaultInit;
  183. typedef void   SOMLINK somTP_SOMEEMan_somDestruct(SOMEEMan *somSelf, 
  184.         octet doFree, 
  185.         som3DestructCtrl* ctrl);
  186. typedef somTP_SOMEEMan_somDestruct *somTD_SOMEEMan_somDestruct;
  187. typedef void   SOMLINK somTP_SOMEEMan_somDefaultCopyInit(SOMEEMan *somSelf, 
  188.         som3InitCtrl* ctrl, 
  189.         SOMObject* fromObj);
  190. typedef somTP_SOMEEMan_somDefaultCopyInit *somTD_SOMEEMan_somDefaultCopyInit;
  191. typedef SOMEEMan*   SOMLINK somTP_SOMEEMan_somDefaultAssign(SOMEEMan *somSelf, 
  192.         som3AssignCtrl* ctrl, 
  193.         SOMObject* fromObj);
  194. typedef somTP_SOMEEMan_somDefaultAssign *somTD_SOMEEMan_somDefaultAssign;
  195. typedef void   SOMLINK somTP_SOMEEMan_somDefaultConstCopyInit(SOMEEMan *somSelf, 
  196.         som3InitCtrl* ctrl, 
  197.         SOMObject* fromObj);
  198. typedef somTP_SOMEEMan_somDefaultConstCopyInit *somTD_SOMEEMan_somDefaultConstCopyInit;
  199. typedef void   SOMLINK somTP_SOMEEMan_somDefaultVCopyInit(SOMEEMan *somSelf, 
  200.         som3InitCtrl* ctrl, 
  201.         SOMObject* fromObj);
  202. typedef somTP_SOMEEMan_somDefaultVCopyInit *somTD_SOMEEMan_somDefaultVCopyInit;
  203. typedef void   SOMLINK somTP_SOMEEMan_somDefaultConstVCopyInit(SOMEEMan *somSelf, 
  204.         som3InitCtrl* ctrl, 
  205.         SOMObject* fromObj);
  206. typedef somTP_SOMEEMan_somDefaultConstVCopyInit *somTD_SOMEEMan_somDefaultConstVCopyInit;
  207. typedef SOMEEMan*   SOMLINK somTP_SOMEEMan_somDefaultConstAssign(SOMEEMan *somSelf, 
  208.         som3AssignCtrl* ctrl, 
  209.         SOMObject* fromObj);
  210. typedef somTP_SOMEEMan_somDefaultConstAssign *somTD_SOMEEMan_somDefaultConstAssign;
  211. typedef SOMEEMan*   SOMLINK somTP_SOMEEMan_somDefaultVAssign(SOMEEMan *somSelf, 
  212.         som3AssignCtrl* ctrl, 
  213.         SOMObject* fromObj);
  214. typedef somTP_SOMEEMan_somDefaultVAssign *somTD_SOMEEMan_somDefaultVAssign;
  215. typedef SOMEEMan*   SOMLINK somTP_SOMEEMan_somDefaultConstVAssign(SOMEEMan *somSelf, 
  216.         som3AssignCtrl* ctrl, 
  217.         SOMObject* fromObj);
  218. typedef somTP_SOMEEMan_somDefaultConstVAssign *somTD_SOMEEMan_somDefaultConstVAssign;
  219. typedef void   SOMLINK somTP_SOMEEMan_somInit(SOMEEMan *somSelf);
  220. typedef somTP_SOMEEMan_somInit *somTD_SOMEEMan_somInit;
  221. typedef void   SOMLINK somTP_SOMEEMan_somFree(SOMEEMan *somSelf);
  222. typedef somTP_SOMEEMan_somFree *somTD_SOMEEMan_somFree;
  223. typedef void   SOMLINK somTP_SOMEEMan_somUninit(SOMEEMan *somSelf);
  224. typedef somTP_SOMEEMan_somUninit *somTD_SOMEEMan_somUninit;
  225. typedef SOMMSingleInstance*   SOMLINK somTP_SOMEEMan_somGetClass(SOMEEMan *somSelf);
  226. typedef somTP_SOMEEMan_somGetClass *somTD_SOMEEMan_somGetClass;
  227. typedef string   SOMLINK somTP_SOMEEMan_somGetClassName(SOMEEMan *somSelf);
  228. typedef somTP_SOMEEMan_somGetClassName *somTD_SOMEEMan_somGetClassName;
  229. typedef long   SOMLINK somTP_SOMEEMan_somGetSize(SOMEEMan *somSelf);
  230. typedef somTP_SOMEEMan_somGetSize *somTD_SOMEEMan_somGetSize;
  231. typedef boolean   SOMLINK somTP_SOMEEMan_somIsA(SOMEEMan *somSelf, 
  232.         SOMClass* aClassObj);
  233. typedef somTP_SOMEEMan_somIsA *somTD_SOMEEMan_somIsA;
  234. typedef boolean   SOMLINK somTP_SOMEEMan_somIsInstanceOf(SOMEEMan *somSelf, 
  235.         SOMClass* aClassObj);
  236. typedef somTP_SOMEEMan_somIsInstanceOf *somTD_SOMEEMan_somIsInstanceOf;
  237. typedef boolean   SOMLINK somTP_SOMEEMan_somRespondsTo(SOMEEMan *somSelf, 
  238.         somId mId);
  239. typedef somTP_SOMEEMan_somRespondsTo *somTD_SOMEEMan_somRespondsTo;
  240. typedef boolean   SOMLINK somTP_SOMEEMan_somDispatch(SOMEEMan *somSelf, 
  241.         somToken* retValue, 
  242.         somId methodId, 
  243.         va_list ap);
  244. typedef somTP_SOMEEMan_somDispatch *somTD_SOMEEMan_somDispatch;
  245. typedef boolean   SOMLINK somTP_SOMEEMan_somClassDispatch(SOMEEMan *somSelf, 
  246.         SOMClass* clsObj, 
  247.         somToken* retValue, 
  248.         somId methodId, 
  249.         va_list ap);
  250. typedef somTP_SOMEEMan_somClassDispatch *somTD_SOMEEMan_somClassDispatch;
  251. typedef boolean   SOMLINK somTP_SOMEEMan_somCastObj(SOMEEMan *somSelf, 
  252.         SOMClass* cls);
  253. typedef somTP_SOMEEMan_somCastObj *somTD_SOMEEMan_somCastObj;
  254. typedef boolean   SOMLINK somTP_SOMEEMan_somResetObj(SOMEEMan *somSelf);
  255. typedef somTP_SOMEEMan_somResetObj *somTD_SOMEEMan_somResetObj;
  256. typedef void   SOMLINK somTP_SOMEEMan_somDispatchV(SOMEEMan *somSelf, 
  257.         somId methodId, 
  258.         somId descriptor, 
  259.         va_list ap);
  260. typedef somTP_SOMEEMan_somDispatchV *somTD_SOMEEMan_somDispatchV;
  261. typedef long   SOMLINK somTP_SOMEEMan_somDispatchL(SOMEEMan *somSelf, 
  262.         somId methodId, 
  263.         somId descriptor, 
  264.         va_list ap);
  265. typedef somTP_SOMEEMan_somDispatchL *somTD_SOMEEMan_somDispatchL;
  266. typedef void*   SOMLINK somTP_SOMEEMan_somDispatchA(SOMEEMan *somSelf, 
  267.         somId methodId, 
  268.         somId descriptor, 
  269.         va_list ap);
  270. typedef somTP_SOMEEMan_somDispatchA *somTD_SOMEEMan_somDispatchA;
  271. typedef double   SOMLINK somTP_SOMEEMan_somDispatchD(SOMEEMan *somSelf, 
  272.         somId methodId, 
  273.         somId descriptor, 
  274.         va_list ap);
  275. typedef somTP_SOMEEMan_somDispatchD *somTD_SOMEEMan_somDispatchD;
  276. typedef SOMObject*   SOMLINK somTP_SOMEEMan_somPrintSelf(SOMEEMan *somSelf);
  277. typedef somTP_SOMEEMan_somPrintSelf *somTD_SOMEEMan_somPrintSelf;
  278. typedef void   SOMLINK somTP_SOMEEMan_somDumpSelf(SOMEEMan *somSelf, 
  279.         long level);
  280. typedef somTP_SOMEEMan_somDumpSelf *somTD_SOMEEMan_somDumpSelf;
  281. typedef void   SOMLINK somTP_SOMEEMan_somDumpSelfInt(SOMEEMan *somSelf, 
  282.         long level);
  283. typedef somTP_SOMEEMan_somDumpSelfInt *somTD_SOMEEMan_somDumpSelfInt;
  284. }
  285.  
  286. #endif /* SOMEEMan_API */
  287.  
  288.  
  289. /*
  290.  * -- This emitter treats Method Tokens as Thunks by default.
  291.  * -- Use the sc modifier "nothunks" to change this default
  292.  */
  293. #undef somresolve_
  294. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  295.  
  296. /*
  297.  * -- The C++ Wrapper Class for SOMEEMan
  298.  */
  299. class SOMEEMan : public SOMObject
  300. {
  301. /*
  302.  *  The Event Manager class (EMan for short) is used to handle several input
  303.  *  events. The main purpose of this class is to provide a service that can do
  304.  *  a blocked (or timed) wait on several event sources concurrently.  Typically,
  305.  *  in a main program,  one registers an interest in an event type with EMan and
  306.  *  specifies a callback (a procedure or a method) to be invoked when the event
  307.  *  of interest occurs. After all the necessary registrations are done, the main
  308.  *  program is ended by a call to process events in EMan. This call is non-returning.
  309.  *  Eman then waits on multiple registered sources of events. The application is then
  310.  *  completely event driven. I.E., it does something only when an event occurs.
  311.  *  The control returns to EMan after processing each event. Further registrations
  312.  *  can be done inside of callback routines. So also unregistrations.
  313.  * 
  314.  *  AIX Specifics:
  315.  *  On AIX this event manager supports Timer, Sink (any file, pipe,
  316.  *  socket and Message Queue), Client and WorkProc events.
  317.  * 
  318.  *  OS/2 Specifics:
  319.  *  On OS/2 this event manager supports Timer, Sink(sockets only). Client and
  320.  *  WorkProc events.
  321.  *  To cope with multi-threaded applications on OS/2, the event manager
  322.  *  methods are mutually exclusive (i.e., at any time only one thread can be
  323.  *  executing inside of EMan).
  324.  *  If an application thread needs to stop EMan from running (i.e., achieve
  325.  *  mutual exclusion with EMan), it can use the two methods someGetEmanSem
  326.  *  and someReleaseEManSem to acquire and release EMan semaphore(s).
  327.  *  On AIX, at present, since AIX does not support threads calling these two methods
  328.  *  has no effect.
  329.  */
  330. public:
  331.  
  332. // SOMEEMan::new creates the class object if necessary, and then uses somNewNoInit
  333. // to allocate memory and create the object. Initialization is in ctors.
  334. void *operator new(size_t)
  335. {
  336.    if (!_SOMEEMan) SOMEEManNewClass(SOMEEMan_MajorVersion,SOMEEMan_MinorVersion);
  337.    return (void*)
  338.       SOM_Resolve(_SOMEEMan,SOMClass,somNewNoInit)
  339.          ((SOMClass *)((void*)_SOMEEMan));
  340. }
  341.  
  342. // SOMEEMan::delete uses somDestruct.
  343. void operator delete(void * obj)
  344. {
  345.    if (obj && *(void**)obj) {
  346.       SOM_Resolve(obj,SOMObject,somFree)
  347.          ((SOMObject*)obj);
  348.    }
  349. }
  350.  
  351. SOMEEMan& operator=(SOMEEMan& fromObj)
  352. {
  353.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  354.    return *this;
  355. }
  356.  
  357. SOMEEMan()
  358. {
  359.    if (*(void**)this != 
  360.        ((somParentMtabStructPtr)
  361.         (SOMEEManCClassData.parentMtab))->mtab)
  362.       return;
  363.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  364. }
  365.  
  366. SOMEEMan(SOMEEMan* fromObj)
  367. {
  368.    if (*(void**)this != 
  369.        ((somParentMtabStructPtr)
  370.         (SOMEEManCClassData.parentMtab))->mtab)
  371.       return;
  372.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  373. }
  374.  
  375. #ifdef __IBMCPP__
  376. #pragma info(nocnv,nopar)
  377. #endif
  378. SOMEEMan(const SOMEEMan* fromObj)
  379. {
  380.    if (*(void**)this != 
  381.        ((somParentMtabStructPtr)
  382.         (SOMEEManCClassData.parentMtab))->mtab)
  383.       return;
  384.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  385. }
  386. #ifdef __IBMCPP__
  387. #pragma info(restore)
  388. #endif
  389.  
  390.  
  391. /* method: someGetEManSem */
  392. void   someGetEManSem(Environment *ev)
  393. {
  394. /*
  395.  *  Gets a semaphore to achieve mutual exclusion with EMan's activity.
  396.  *  Callers should not hold this semaphore for too long since it essentially
  397.  *  stops EMan activity for that duration.
  398.  */
  399.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someGetEManSem)
  400.     (this, ev);
  401. }
  402.  
  403.  
  404. /* method: someReleaseEManSem */
  405. void   someReleaseEManSem(Environment *ev)
  406. {
  407. /*
  408.  *  Release the semaphore obtained by someGetEManSem.
  409.  */
  410.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someReleaseEManSem)
  411.     (this, ev);
  412. }
  413.  
  414.  
  415. /* method: someChangeRegData */
  416. void   someChangeRegData(Environment *ev, 
  417.         long registrationId, 
  418.         SOMEEMRegisterData* registerData)
  419. {
  420. /*
  421.  *  Change the registration data associated with the specified id.
  422.  *  This id must have been returned by EMan in a previous Register call.
  423.  */
  424.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someChangeRegData)
  425.     (this, ev,registrationId,registerData);
  426. }
  427.  
  428.  
  429. /* method: someProcessEvent */
  430. void   someProcessEvent(Environment *ev, 
  431.         unsigned long mask)
  432. {
  433. /*
  434.  *  Process one event. This call is non-blocking. If there are no events to
  435.  *  process it returns immediately. The mask specifies what events to process.
  436.  *  The mask is formed by ORing the bit constants specified in eventmsk.h
  437.  *  For example, to processs Timer and Sink events only one would specify
  438.  *  the mask as:  EMProcessTimerEvent | EMProcessSinkEvent
  439.  */
  440.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someProcessEvent)
  441.     (this, ev,mask);
  442. }
  443.  
  444.  
  445. /* method: someProcessEvents */
  446. void   someProcessEvents(Environment *ev)
  447. {
  448. /*
  449.  *  Process infinite events. Does not return. Loops forever waiting for events
  450.  *  and dispatching events. The only way this can be broken is by calling
  451.  *  someShutdown in a callback.
  452.  */
  453.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someProcessEvents)
  454.     (this, ev);
  455. }
  456.  
  457.  
  458. /* method: someQueueEvent */
  459. void   someQueueEvent(Environment *ev, 
  460.         SOMEClientEvent* event)
  461. {
  462. /*
  463.  *  Used to be: void someQueueEvent(inout SOMEClientEvent event);
  464.  *  Enqueue the specified client event
  465.  */
  466.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someQueueEvent)
  467.     (this, ev,event);
  468. }
  469.  
  470.  
  471. /* method: someRegister */
  472. long   someRegister(Environment *ev, 
  473.         SOMEEMRegisterData* registerData, 
  474.         SOMObject* targetObject, 
  475.         string targetMethod, 
  476.         void* targetData)
  477. {
  478. /*
  479.  *  Register the object/method pair with EMan given the specified 'registerData'.
  480.  */
  481.    return SOM_ResolveD(this,SOMEEMan,SOMEEMan,someRegister)
  482.     (this, ev,registerData,targetObject,targetMethod,targetData);
  483. }
  484.  
  485.  
  486. /* method: someRegisterEv */
  487. long   someRegisterEv(Environment *ev, 
  488.         SOMEEMRegisterData* registerData, 
  489.         SOMObject* targetObject, 
  490.         Environment* callbackEv, 
  491.         string targetMethod, 
  492.         void* targetData)
  493. {
  494. /*
  495.  *  Register the object/method pair together with the callback Environment parameter
  496.  *  with EMan given the specified 'registerData'.
  497.  */
  498.    return SOM_ResolveD(this,SOMEEMan,SOMEEMan,someRegisterEv)
  499.     (this, ev,registerData,targetObject,callbackEv,targetMethod,targetData);
  500. }
  501.  
  502.  
  503. /* method: someRegisterProc */
  504. long   someRegisterProc(Environment *ev, 
  505.         SOMEEMRegisterData* registerData, 
  506.         EMRegProc* targetProcedure, 
  507.         void* targetData)
  508. {
  509. /*
  510.  *  Register the procedure with EMan given the specified 'registerData'.
  511.  */
  512.    return SOM_ResolveD(this,SOMEEMan,SOMEEMan,someRegisterProc)
  513.     (this, ev,registerData,targetProcedure,targetData);
  514. }
  515.  
  516.  
  517. /* method: someShutdown */
  518. void   someShutdown(Environment *ev)
  519. {
  520. /*
  521.  *  Shutdown EMan event loop. (i.e., makes the someProcessEvents return!)
  522.  */
  523.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someShutdown)
  524.     (this, ev);
  525. }
  526.  
  527.  
  528. /* method: someUnRegister */
  529. void   someUnRegister(Environment *ev, 
  530.         long registrationId)
  531. {
  532. /*
  533.  *  Unregister the data associated with the specified 'registrationId' within EMan
  534.  */
  535.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someUnRegister)
  536.     (this, ev,registrationId);
  537. }
  538.  
  539.  
  540. /*
  541.  * Reintroduce inherited methods
  542.  */
  543.  
  544. /* initializer method: somDefaultInit */
  545. void   somDefaultInit(som3InitCtrl* ctrl)
  546. {
  547. /*
  548.  *  A default initializer for a SOM object. Passing a null ctrl
  549.  *  indicates to the receiver that its class is the class of the
  550.  *  object being initialized, whereby the initializer will determine
  551.  *  an appropriate control structure.
  552.  */
  553.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultInit)
  554.     (this,ctrl);
  555. }
  556.  
  557.  
  558. /* method: somDestruct */
  559. void   somDestruct(octet doFree, 
  560.         som3DestructCtrl* ctrl)
  561. {
  562. /*
  563.  *  The default destructor for a SOM object. A nonzero <doFree>
  564.  *  indicates that the object storage should be freed by the
  565.  *  object's class (via somDeallocate) after uninitialization.
  566.  *  As with somDefaultInit, a null ctrl can be passed.
  567.  */
  568.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDestruct)
  569.     (this,doFree,ctrl);
  570. }
  571.  
  572.  
  573. /* initializer method: somDefaultCopyInit */
  574. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  575.         SOMObject* fromObj)
  576. {
  577. /*
  578.  *  A default copy constructor. Use this to make copies of objects for
  579.  *  calling methods with "by-value" argument semantics.
  580.  */
  581.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultCopyInit)
  582.     (this,ctrl,fromObj);
  583. }
  584.  
  585.  
  586. /* method: somDefaultAssign */
  587. SOMEEMan*  somDefaultAssign(som3AssignCtrl* ctrl, 
  588.         SOMObject* fromObj)
  589. {
  590. /*
  591.  *  A default assignment operator. Use this to "assign" the state of one
  592.  *  object to another.
  593.  */
  594.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultAssign)
  595.     (this,ctrl,fromObj);
  596. }
  597.  
  598.  
  599. /* initializer method: somDefaultConstCopyInit */
  600. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  601.         SOMObject* fromObj)
  602. {
  603. /*
  604.  *  A default copy constructor that uses a const fromObj.
  605.  */
  606.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultConstCopyInit)
  607.     (this,ctrl,fromObj);
  608. }
  609.  
  610.  
  611. /* initializer method: somDefaultVCopyInit */
  612. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  613.         SOMObject* fromObj)
  614. {
  615. /*
  616.  *  A default copy constructor that uses a volatile fromObj.
  617.  */
  618.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultVCopyInit)
  619.     (this,ctrl,fromObj);
  620. }
  621.  
  622.  
  623. /* initializer method: somDefaultConstVCopyInit */
  624. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  625.         SOMObject* fromObj)
  626. {
  627. /*
  628.  *  A default copy constructor that uses a const volatile fromObj.
  629.  */
  630.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultConstVCopyInit)
  631.     (this,ctrl,fromObj);
  632. }
  633.  
  634.  
  635. /* method: somDefaultConstAssign */
  636. SOMEEMan*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  637.         SOMObject* fromObj)
  638. {
  639. /*
  640.  *  A default assignment operator that uses a const fromObj.
  641.  */
  642.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultConstAssign)
  643.     (this,ctrl,fromObj);
  644. }
  645.  
  646.  
  647. /* method: somDefaultVAssign */
  648. SOMEEMan*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  649.         SOMObject* fromObj)
  650. {
  651. /*
  652.  *  A default assignment operator that uses a volatile fromObj.
  653.  */
  654.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultVAssign)
  655.     (this,ctrl,fromObj);
  656. }
  657.  
  658.  
  659. /* method: somDefaultConstVAssign */
  660. SOMEEMan*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  661.         SOMObject* fromObj)
  662. {
  663. /*
  664.  *  A default assignment operator that uses a const volatile fromObj.
  665.  */
  666.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultConstVAssign)
  667.     (this,ctrl,fromObj);
  668. }
  669.  
  670.  
  671. /* method: somInit */
  672. void   somInit()
  673. {
  674. /*
  675.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  676.  */
  677.    SOM_ResolveD(this,SOMEEMan,SOMObject,somInit)
  678.     (this);
  679. }
  680.  
  681.  
  682. /* method: somFree */
  683. void   somFree()
  684. {
  685. /*
  686.  *  Use as directed by framework implementations.
  687.  */
  688.    SOM_ResolveD(this,SOMEEMan,SOMObject,somFree)
  689.     (this);
  690. }
  691.  
  692.  
  693. /* method: somUninit */
  694. void   somUninit()
  695. {
  696. /*
  697.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  698.  */
  699.    SOM_ResolveD(this,SOMEEMan,SOMObject,somUninit)
  700.     (this);
  701. }
  702.  
  703.  
  704. /* method: somGetClass */
  705. SOMMSingleInstance*  somGetClass()
  706. {
  707. /*
  708.  *  Return the receiver's class.
  709.  */
  710.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somGetClass)
  711.     (this);
  712. }
  713.  
  714.  
  715. /* method: somGetClassName */
  716. string   somGetClassName()
  717. {
  718. /*
  719.  *  Return the name of the receiver's class.
  720.  */
  721.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somGetClassName)
  722.     (this);
  723. }
  724.  
  725.  
  726. /* method: somGetSize */
  727. long   somGetSize()
  728. {
  729. /*
  730.  *  Return the size of the receiver.
  731.  */
  732.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somGetSize)
  733.     (this);
  734. }
  735.  
  736.  
  737. /* method: somIsA */
  738. boolean   somIsA(SOMClass* aClassObj)
  739. {
  740. /*
  741.  *  Returns 1 (true) if the receiver responds to methods
  742.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  743.  */
  744.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somIsA)
  745.     (this,aClassObj);
  746. }
  747.  
  748.  
  749. /* method: somIsInstanceOf */
  750. boolean   somIsInstanceOf(SOMClass* aClassObj)
  751. {
  752. /*
  753.  *  Returns 1 (true) if the receiver is an instance of
  754.  *  <aClassObj> and 0 (false) otherwise.
  755.  */
  756.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somIsInstanceOf)
  757.     (this,aClassObj);
  758. }
  759.  
  760.  
  761. /* method: somRespondsTo */
  762. boolean   somRespondsTo(somId mId)
  763. {
  764. /*
  765.  *  Returns 1 (true) if the indicated method can be invoked
  766.  *  on the receiver and 0 (false) otherwise.
  767.  */
  768.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somRespondsTo)
  769.     (this,mId);
  770. }
  771.  
  772.  
  773. /* va_list method: somDispatch */
  774.  
  775. /*
  776.  *  This method provides a generic, class-specific dispatch mechanism.
  777.  *  It accepts as input <retValue> a pointer to the memory area to be
  778.  *  loaded with the result of dispatching the method indicated by
  779.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  780.  *  on which the method is to be invoked as the first argument.
  781.  */
  782. /* the va_list invocation form */
  783. boolean   SOMEEMan_somDispatch(somToken* retValue, 
  784.         somId methodId, 
  785.         va_list ap)
  786. {return SOM_ResolveD(this,SOMEEMan,SOMObject,somDispatch)
  787.     (this,retValue,methodId,ap);
  788. }
  789.  
  790. /* the varargs invocation form */
  791. boolean   somDispatch(somToken* retValue, 
  792.         somId methodId, 
  793.         ...)
  794. {
  795. /*
  796.  *  This method provides a generic, class-specific dispatch mechanism.
  797.  *  It accepts as input <retValue> a pointer to the memory area to be
  798.  *  loaded with the result of dispatching the method indicated by
  799.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  800.  *  on which the method is to be invoked as the first argument.
  801.  */
  802.    va_list ap;
  803.    va_start(ap, methodId);
  804.    boolean __somResult = 
  805.       SOM_ResolveD(this,SOMEEMan,SOMObject,somDispatch)
  806.     (this,retValue,methodId,ap);
  807.    va_end(ap);
  808.    return __somResult;
  809. }
  810.  
  811.  
  812. /* va_list method: somClassDispatch */
  813.  
  814. /*
  815.  *  Like somDispatch, but method resolution for static methods is done
  816.  *  according to the clsObj instance method table.
  817.  */
  818. /* the va_list invocation form */
  819. boolean   SOMEEMan_somClassDispatch(SOMClass* clsObj, 
  820.         somToken* retValue, 
  821.         somId methodId, 
  822.         va_list ap)
  823. {return SOM_ResolveD(this,SOMEEMan,SOMObject,somClassDispatch)
  824.     (this,clsObj,retValue,methodId,ap);
  825. }
  826.  
  827. /* the varargs invocation form */
  828. boolean   somClassDispatch(SOMClass* clsObj, 
  829.         somToken* retValue, 
  830.         somId methodId, 
  831.         ...)
  832. {
  833. /*
  834.  *  Like somDispatch, but method resolution for static methods is done
  835.  *  according to the clsObj instance method table.
  836.  */
  837.    va_list ap;
  838.    va_start(ap, methodId);
  839.    boolean __somResult = 
  840.       SOM_ResolveD(this,SOMEEMan,SOMObject,somClassDispatch)
  841.     (this,clsObj,retValue,methodId,ap);
  842.    va_end(ap);
  843.    return __somResult;
  844. }
  845.  
  846.  
  847. /* method: somCastObj */
  848. boolean   somCastObj(SOMClass* cls)
  849. {
  850. /*
  851.  *  cast the receiving object to cls (which must be an ancestor of the
  852.  *  objects true class. Returns true on success.
  853.  */
  854.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somCastObj)
  855.     (this,cls);
  856. }
  857.  
  858.  
  859. /* method: somResetObj */
  860. boolean   somResetObj()
  861. {
  862. /*
  863.  *  reset an object to its true class. Returns true always.
  864.  */
  865.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somResetObj)
  866.     (this);
  867. }
  868.  
  869.  
  870. /* va_list method: somDispatchV */
  871.  
  872. /*
  873.  *  Obsolete. Use somDispatch instead.
  874.  */
  875. /* the va_list invocation form */
  876. void   SOMEEMan_somDispatchV(somId methodId, 
  877.         somId descriptor, 
  878.         va_list ap)
  879. {   SOM_ResolveD(this,SOMEEMan,SOMObject,somDispatchV)
  880.     (this,methodId,descriptor,ap);
  881. }
  882.  
  883. /* the varargs invocation form */
  884. void   somDispatchV(somId methodId, 
  885.         somId descriptor, 
  886.         ...)
  887. {
  888. /*
  889.  *  Obsolete. Use somDispatch instead.
  890.  */
  891.    va_list ap;
  892.    va_start(ap, descriptor);
  893.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDispatchV)
  894.     (this,methodId,descriptor,ap);
  895.    va_end(ap);
  896. }
  897.  
  898.  
  899. /* va_list method: somDispatchL */
  900.  
  901. /*
  902.  *  Obsolete. Use somDispatch instead.
  903.  */
  904. /* the va_list invocation form */
  905. long   SOMEEMan_somDispatchL(somId methodId, 
  906.         somId descriptor, 
  907.         va_list ap)
  908. {return SOM_ResolveD(this,SOMEEMan,SOMObject,somDispatchL)
  909.     (this,methodId,descriptor,ap);
  910. }
  911.  
  912. /* the varargs invocation form */
  913. long   somDispatchL(somId methodId, 
  914.         somId descriptor, 
  915.         ...)
  916. {
  917. /*
  918.  *  Obsolete. Use somDispatch instead.
  919.  */
  920.    va_list ap;
  921.    va_start(ap, descriptor);
  922.    long __somResult = 
  923.       SOM_ResolveD(this,SOMEEMan,SOMObject,somDispatchL)
  924.     (this,methodId,descriptor,ap);
  925.    va_end(ap);
  926.    return __somResult;
  927. }
  928.  
  929.  
  930. /* va_list method: somDispatchA */
  931.  
  932. /*
  933.  *  Obsolete. Use somDispatch instead.
  934.  */
  935. /* the va_list invocation form */
  936. void*   SOMEEMan_somDispatchA(somId methodId, 
  937.         somId descriptor, 
  938.         va_list ap)
  939. {return SOM_ResolveD(this,SOMEEMan,SOMObject,somDispatchA)
  940.     (this,methodId,descriptor,ap);
  941. }
  942.  
  943. /* the varargs invocation form */
  944. void*   somDispatchA(somId methodId, 
  945.         somId descriptor, 
  946.         ...)
  947. {
  948. /*
  949.  *  Obsolete. Use somDispatch instead.
  950.  */
  951.    va_list ap;
  952.    va_start(ap, descriptor);
  953.    void* __somResult = 
  954.       SOM_ResolveD(this,SOMEEMan,SOMObject,somDispatchA)
  955.     (this,methodId,descriptor,ap);
  956.    va_end(ap);
  957.    return __somResult;
  958. }
  959.  
  960.  
  961. /* va_list method: somDispatchD */
  962.  
  963. /*
  964.  *  Obsolete. Use somDispatch instead.
  965.  */
  966. /* the va_list invocation form */
  967. double   SOMEEMan_somDispatchD(somId methodId, 
  968.         somId descriptor, 
  969.         va_list ap)
  970. {return SOM_ResolveD(this,SOMEEMan,SOMObject,somDispatchD)
  971.     (this,methodId,descriptor,ap);
  972. }
  973.  
  974. /* the varargs invocation form */
  975. double   somDispatchD(somId methodId, 
  976.         somId descriptor, 
  977.         ...)
  978. {
  979. /*
  980.  *  Obsolete. Use somDispatch instead.
  981.  */
  982.    va_list ap;
  983.    va_start(ap, descriptor);
  984.    double __somResult = 
  985.       SOM_ResolveD(this,SOMEEMan,SOMObject,somDispatchD)
  986.     (this,methodId,descriptor,ap);
  987.    va_end(ap);
  988.    return __somResult;
  989. }
  990.  
  991.  
  992. /* method: somPrintSelf */
  993. SOMObject*   somPrintSelf()
  994. {
  995. /*
  996.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  997.  *  information about this object.  The default implementation just gives
  998.  *  the object's class name and its address in memory.
  999.  *  <self> is returned.
  1000.  */
  1001.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somPrintSelf)
  1002.     (this);
  1003. }
  1004.  
  1005.  
  1006. /* method: somDumpSelf */
  1007. void   somDumpSelf(long level)
  1008. {
  1009. /*
  1010.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  1011.  *  and its current state.
  1012.  * 
  1013.  *  <level> indicates the nesting level for describing compound objects
  1014.  *  it must be greater than or equal to zero.  All lines in the
  1015.  *  description will be preceeded by <2*level> spaces.
  1016.  * 
  1017.  *  This routine only actually writes the data that concerns the object
  1018.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  1019.  *  the object's current state.  This approach allows readable
  1020.  *  descriptions of compound objects to be constructed.
  1021.  * 
  1022.  *  Generally it is not necessary to override this method, if it is
  1023.  *  overriden it generally must be completely replaced.
  1024.  */
  1025.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDumpSelf)
  1026.     (this,level);
  1027. }
  1028.  
  1029.  
  1030. /* method: somDumpSelfInt */
  1031. void   somDumpSelfInt(long level)
  1032. {
  1033. /*
  1034.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  1035.  *  Generally this method will need to be overridden.  When overriding
  1036.  *  it, begin by calling the parent class form of this method and then
  1037.  *  write in a description of your class's instance data. This will
  1038.  *  result in a description of all the object's instance data going
  1039.  *  from its root ancestor class to its specific class.
  1040.  */
  1041.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDumpSelfInt)
  1042.     (this,level);
  1043. }
  1044.  
  1045.  
  1046.  
  1047. };   /* SOMEEMan */
  1048.  
  1049.  
  1050.  
  1051. #endif       /* SOM_SOMEEMan_xh */
  1052.