home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / trialva / ibmcppw / include / eman.xh < prev    next >
Encoding:
Text File  |  1996-02-22  |  20.3 KB  |  716 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: h:\somnt\include\eman.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: Development
  7.  *     SOM Emitter emitxh.dll: Development
  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_SOMEEMan_xh
  27. #define SOM_SOMEEMan_xh
  28.  
  29. class SOMEEMan;
  30.  
  31. /*
  32.  *  The Event Manager class (EMan for short) is used to handle several input
  33.  *  events. The main purpose of this class is to provide a service that can do
  34.  *  a blocked (or timed) wait on several event sources concurrently.  Typically,
  35.  *  in a main program,  one registers an interest in an event type with EMan and
  36.  *  specifies a callback (a procedure or a method) to be invoked when the event
  37.  *  of interest occurs. After all the necessary registrations are done, the main
  38.  *  program is ended by a call to process events in EMan. This call is non-returning.
  39.  *  Eman then waits on multiple registered sources of events. The application is then
  40.  *  completely event driven. I.E., it does something only when an event occurs.
  41.  *  The control returns to EMan after processing each event. Further registrations
  42.  *  can be done inside of callback routines. So also unregistrations.
  43.  * 
  44.  *  AIX Specifics:
  45.  *  On AIX this event manager supports Timer, Sink (any file, pipe,
  46.  *  socket and Message Queue), Client and WorkProc events.
  47.  * 
  48.  *  OS/2 Specifics:
  49.  *  On OS/2 this event manager supports Timer, Sink(sockets only). Client and
  50.  *  WorkProc events.
  51.  *  To cope with multi-threaded applications on OS/2, the event manager
  52.  *  methods are mutually exclusive (i.e., at any time only one thread can be
  53.  *  executing inside of EMan).
  54.  *  If an application thread needs to stop EMan from running (i.e., achieve
  55.  *  mutual exclusion with EMan), it can use the two methods someGetEmanSem
  56.  *  and someReleaseEManSem to acquire and release EMan semaphore(s).
  57.  *  On AIX, at present, since AIX does not support threads calling these two methods
  58.  *  has no effect.
  59.  */
  60.  
  61. #define SOMEEMan_MajorVersion 2
  62. #define SOMEEMan_MinorVersion 1
  63.  
  64. /* C++ SOM defs */
  65. #include <somcls.xh>
  66. #include <somcm.xh>
  67.  
  68. /* C++ parent defs */
  69. #ifndef SOM_SOMObject_xh
  70. #include <somobj.xh>
  71. #endif
  72.  
  73. /*
  74.  * C++ metaclass def
  75.  */
  76. #include <snglicls.xh>
  77.  
  78. #ifndef SOMEEMan_API
  79. #define SOMEEMan_API
  80. /*
  81.  * -- The Class API
  82.  */
  83.  
  84. /*
  85.  * Start of user-defined types:
  86.  */
  87. class SOMClass;
  88. class SOMObject;
  89. class SOMEEvent;
  90. class SOMEClientEvent;
  91. class SOMEEMRegisterData;
  92.  
  93. /*
  94.  * End of user-defined 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
  107. #if (defined(SOM_Module_eman_Source) || defined(SOMEEMan_Class_Source) || defined (SOM_DONT_IMPORT_CLASS_SOMEEMan))
  108. WIN32_DLLEXPORT
  109. #else
  110. WIN32_DLLIMPORT
  111. #endif
  112. SOMMSingleInstance * SOMLINK SOMEEManNewClass(
  113.         integer4,
  114.         integer4 );
  115.  
  116. /* The API to the SOMEEMan class object, and the methods it introduces. */
  117. SOMEXTERN struct SOMEEManClassDataStructure {
  118.     SOMMSingleInstance *classObject;
  119.     somMToken someGetEManSem;
  120.     somMToken someReleaseEManSem;
  121.     somMToken someChangeRegData;
  122.     somMToken someProcessEvent;
  123.     somMToken someProcessEvents;
  124.     somMToken someQueueEvent;
  125.     somMToken someRegister;
  126.     somMToken someRegisterEv;
  127.     somMToken someRegisterProc;
  128.     somMToken someShutdown;
  129.     somMToken someUnRegister;
  130. }
  131. #if !(defined(SOM_Module_eman_Source) || defined(SOMEEMan_Class_Source) || defined (SOM_DONT_IMPORT_CLASS_SOMEEMan))
  132. WIN32_DLLIMPORT
  133. #elif defined(_MSC_VER)||defined(_WIN32_DECL_PROTO)
  134. WIN32_DLLEXPORT
  135. #endif
  136. SOMDLINK SOMEEManClassData;
  137. #define _SOMEEMan SOMEEManClassData.classObject
  138.  
  139. /* The API to parentMtabs for SOMEEMan, and the instance data it introduces. */
  140. SOMEXTERN struct SOMEEManCClassDataStructure {
  141.     somMethodTabs parentMtab;
  142.     somDToken              instanceDataToken;
  143. }
  144. #if !(defined(SOM_Module_eman_Source) || defined(SOMEEMan_Class_Source) || defined (SOM_DONT_IMPORT_CLASS_SOMEEMan))
  145. WIN32_DLLIMPORT
  146. #elif defined(_MSC_VER)||defined(_WIN32_DECL_PROTO)
  147. WIN32_DLLEXPORT
  148. #endif
  149. SOMDLINK SOMEEManCClassData;
  150.  
  151. /*
  152.  * -- Typedefs for SOMEEMan Method Procedures
  153.  */
  154. extern "C" {
  155. typedef void   SOMLINK somTP_SOMEEMan_someGetEManSem(SOMEEMan *somSelf, Environment *ev);
  156. typedef somTP_SOMEEMan_someGetEManSem *somTD_SOMEEMan_someGetEManSem;
  157. typedef void   SOMLINK somTP_SOMEEMan_someReleaseEManSem(SOMEEMan *somSelf, Environment *ev);
  158. typedef somTP_SOMEEMan_someReleaseEManSem *somTD_SOMEEMan_someReleaseEManSem;
  159. typedef void   SOMLINK somTP_SOMEEMan_someChangeRegData(SOMEEMan *somSelf, Environment *ev,
  160.         long registrationId,
  161.         SOMEEMRegisterData* registerData);
  162. typedef somTP_SOMEEMan_someChangeRegData *somTD_SOMEEMan_someChangeRegData;
  163. typedef void   SOMLINK somTP_SOMEEMan_someProcessEvent(SOMEEMan *somSelf, Environment *ev,
  164.         unsigned long mask);
  165. typedef somTP_SOMEEMan_someProcessEvent *somTD_SOMEEMan_someProcessEvent;
  166. typedef void   SOMLINK somTP_SOMEEMan_someProcessEvents(SOMEEMan *somSelf, Environment *ev);
  167. typedef somTP_SOMEEMan_someProcessEvents *somTD_SOMEEMan_someProcessEvents;
  168. typedef void   SOMLINK somTP_SOMEEMan_someQueueEvent(SOMEEMan *somSelf, Environment *ev,
  169.         SOMEClientEvent* event);
  170. typedef somTP_SOMEEMan_someQueueEvent *somTD_SOMEEMan_someQueueEvent;
  171. typedef long   SOMLINK somTP_SOMEEMan_someRegister(SOMEEMan *somSelf, Environment *ev,
  172.         SOMEEMRegisterData* registerData,
  173.         SOMObject* targetObject,
  174.         string targetMethod,
  175.         void* targetData);
  176. typedef somTP_SOMEEMan_someRegister *somTD_SOMEEMan_someRegister;
  177. typedef long   SOMLINK somTP_SOMEEMan_someRegisterEv(SOMEEMan *somSelf, Environment *ev,
  178.         SOMEEMRegisterData* registerData,
  179.         SOMObject* targetObject,
  180.         Environment* callbackEv,
  181.         string targetMethod,
  182.         void* targetData);
  183. typedef somTP_SOMEEMan_someRegisterEv *somTD_SOMEEMan_someRegisterEv;
  184. typedef long   SOMLINK somTP_SOMEEMan_someRegisterProc(SOMEEMan *somSelf, Environment *ev,
  185.         SOMEEMRegisterData* registerData,
  186.         EMRegProc* targetProcedure,
  187.         void* targetData);
  188. typedef somTP_SOMEEMan_someRegisterProc *somTD_SOMEEMan_someRegisterProc;
  189. typedef void   SOMLINK somTP_SOMEEMan_someShutdown(SOMEEMan *somSelf, Environment *ev);
  190. typedef somTP_SOMEEMan_someShutdown *somTD_SOMEEMan_someShutdown;
  191. typedef void   SOMLINK somTP_SOMEEMan_someUnRegister(SOMEEMan *somSelf, Environment *ev,
  192.         long registrationId);
  193. typedef somTP_SOMEEMan_someUnRegister *somTD_SOMEEMan_someUnRegister;
  194.  
  195. /*
  196.  * -- Typedefs for Reintroduced Wrapper Methods
  197.  */
  198. typedef void   SOMLINK somTP_SOMEEMan_somDefaultInit(SOMEEMan *somSelf,
  199.         somInitCtrl* ctrl);
  200. typedef somTP_SOMEEMan_somDefaultInit *somTD_SOMEEMan_somDefaultInit;
  201. typedef void   SOMLINK somTP_SOMEEMan_somDestruct(SOMEEMan *somSelf,
  202.         octet doFree,
  203.         somDestructCtrl* ctrl);
  204. typedef somTP_SOMEEMan_somDestruct *somTD_SOMEEMan_somDestruct;
  205. typedef void   SOMLINK somTP_SOMEEMan_somDefaultCopyInit(SOMEEMan *somSelf,
  206.         somInitCtrl* ctrl,
  207.         SOMObject* fromObj);
  208. typedef somTP_SOMEEMan_somDefaultCopyInit *somTD_SOMEEMan_somDefaultCopyInit;
  209. typedef SOMEEMan*   SOMLINK somTP_SOMEEMan_somDefaultAssign(SOMEEMan *somSelf,
  210.         somAssignCtrl* ctrl,
  211.         SOMObject* fromObj);
  212. typedef somTP_SOMEEMan_somDefaultAssign *somTD_SOMEEMan_somDefaultAssign;
  213. typedef void   SOMLINK somTP_SOMEEMan_somDefaultConstCopyInit(SOMEEMan *somSelf,
  214.         somInitCtrl* ctrl,
  215.         SOMObject* fromObj);
  216. typedef somTP_SOMEEMan_somDefaultConstCopyInit *somTD_SOMEEMan_somDefaultConstCopyInit;
  217. typedef void   SOMLINK somTP_SOMEEMan_somDefaultVCopyInit(SOMEEMan *somSelf,
  218.         somInitCtrl* ctrl,
  219.         SOMObject* fromObj);
  220. typedef somTP_SOMEEMan_somDefaultVCopyInit *somTD_SOMEEMan_somDefaultVCopyInit;
  221. typedef void   SOMLINK somTP_SOMEEMan_somDefaultConstVCopyInit(SOMEEMan *somSelf,
  222.         somInitCtrl* ctrl,
  223.         SOMObject* fromObj);
  224. typedef somTP_SOMEEMan_somDefaultConstVCopyInit *somTD_SOMEEMan_somDefaultConstVCopyInit;
  225. typedef SOMEEMan*   SOMLINK somTP_SOMEEMan_somDefaultConstAssign(SOMEEMan *somSelf,
  226.         somAssignCtrl* ctrl,
  227.         SOMObject* fromObj);
  228. typedef somTP_SOMEEMan_somDefaultConstAssign *somTD_SOMEEMan_somDefaultConstAssign;
  229. typedef SOMEEMan*   SOMLINK somTP_SOMEEMan_somDefaultVAssign(SOMEEMan *somSelf,
  230.         somAssignCtrl* ctrl,
  231.         SOMObject* fromObj);
  232. typedef somTP_SOMEEMan_somDefaultVAssign *somTD_SOMEEMan_somDefaultVAssign;
  233. typedef SOMEEMan*   SOMLINK somTP_SOMEEMan_somDefaultConstVAssign(SOMEEMan *somSelf,
  234.         somAssignCtrl* ctrl,
  235.         SOMObject* fromObj);
  236. typedef somTP_SOMEEMan_somDefaultConstVAssign *somTD_SOMEEMan_somDefaultConstVAssign;
  237. typedef void   SOMLINK somTP_SOMEEMan_somInit(SOMEEMan *somSelf);
  238. typedef somTP_SOMEEMan_somInit *somTD_SOMEEMan_somInit;
  239. typedef void   SOMLINK somTP_SOMEEMan_somFree(SOMEEMan *somSelf);
  240. typedef somTP_SOMEEMan_somFree *somTD_SOMEEMan_somFree;
  241. typedef void   SOMLINK somTP_SOMEEMan_somUninit(SOMEEMan *somSelf);
  242. typedef somTP_SOMEEMan_somUninit *somTD_SOMEEMan_somUninit;
  243. typedef SOMMSingleInstance*   SOMLINK somTP_SOMEEMan_somGetClass(SOMEEMan *somSelf);
  244. typedef somTP_SOMEEMan_somGetClass *somTD_SOMEEMan_somGetClass;
  245. typedef string   SOMLINK somTP_SOMEEMan_somGetClassName(SOMEEMan *somSelf);
  246. typedef somTP_SOMEEMan_somGetClassName *somTD_SOMEEMan_somGetClassName;
  247. typedef long   SOMLINK somTP_SOMEEMan_somGetSize(SOMEEMan *somSelf);
  248. typedef somTP_SOMEEMan_somGetSize *somTD_SOMEEMan_somGetSize;
  249. typedef boolean   SOMLINK somTP_SOMEEMan_somIsA(SOMEEMan *somSelf,
  250.         SOMClass* aClassObj);
  251. typedef somTP_SOMEEMan_somIsA *somTD_SOMEEMan_somIsA;
  252. typedef boolean   SOMLINK somTP_SOMEEMan_somIsInstanceOf(SOMEEMan *somSelf,
  253.         SOMClass* aClassObj);
  254. typedef somTP_SOMEEMan_somIsInstanceOf *somTD_SOMEEMan_somIsInstanceOf;
  255. typedef boolean   SOMLINK somTP_SOMEEMan_somRespondsTo(SOMEEMan *somSelf,
  256.         somId mId);
  257. typedef somTP_SOMEEMan_somRespondsTo *somTD_SOMEEMan_somRespondsTo;
  258. typedef boolean   SOMLINK somTP_SOMEEMan_somDispatch(SOMEEMan *somSelf,
  259.         somToken* retValue,
  260.         somId methodId,
  261.         va_list ap);
  262. typedef somTP_SOMEEMan_somDispatch *somTD_SOMEEMan_somDispatch;
  263. typedef boolean   SOMLINK somTP_SOMEEMan_somClassDispatch(SOMEEMan *somSelf,
  264.         SOMClass* clsObj,
  265.         somToken* retValue,
  266.         somId methodId,
  267.         va_list ap);
  268. typedef somTP_SOMEEMan_somClassDispatch *somTD_SOMEEMan_somClassDispatch;
  269. typedef boolean   SOMLINK somTP_SOMEEMan_somCastObj(SOMEEMan *somSelf,
  270.         SOMClass* cls);
  271. typedef somTP_SOMEEMan_somCastObj *somTD_SOMEEMan_somCastObj;
  272. typedef boolean   SOMLINK somTP_SOMEEMan_somResetObj(SOMEEMan *somSelf);
  273. typedef somTP_SOMEEMan_somResetObj *somTD_SOMEEMan_somResetObj;
  274. typedef SOMObject*   SOMLINK somTP_SOMEEMan_somPrintSelf(SOMEEMan *somSelf);
  275. typedef somTP_SOMEEMan_somPrintSelf *somTD_SOMEEMan_somPrintSelf;
  276. typedef void   SOMLINK somTP_SOMEEMan_somDumpSelf(SOMEEMan *somSelf,
  277.         long level);
  278. typedef somTP_SOMEEMan_somDumpSelf *somTD_SOMEEMan_somDumpSelf;
  279. typedef void   SOMLINK somTP_SOMEEMan_somDumpSelfInt(SOMEEMan *somSelf,
  280.         long level);
  281. typedef somTP_SOMEEMan_somDumpSelfInt *somTD_SOMEEMan_somDumpSelfInt;
  282. }
  283.  
  284. #endif /* SOMEEMan_API */
  285.  
  286.  
  287. /*
  288.  * -- This emitter believes that method thunks are unavailable,
  289.  * -- so somResolve will be called.
  290.  */
  291. #undef somresolve_
  292. #define somresolve_(obj,mToken) (somResolve(obj,mToken))
  293.  
  294. /*
  295.  * -- The C++ Wrapper Class for SOMEEMan
  296.  */
  297. class SOMEEMan : public SOMObject
  298. {
  299. public:
  300.  
  301. // SOMEEMan::new creates the class object if necessary, and then uses somNewNoInit
  302. // to allocate memory and create the object. Initialization is in ctors.
  303. void *operator new(size_t)
  304. {
  305.    if (!_SOMEEMan) SOMEEManNewClass(SOMEEMan_MajorVersion,SOMEEMan_MinorVersion);
  306.    return (void*)
  307.       SOM_Resolve(_SOMEEMan,SOMClass,somNewNoInit)
  308.          ((SOMClass *)((void*)_SOMEEMan));
  309. }
  310.  
  311. // SOMEEMan::delete uses somDestruct.
  312. void operator delete(void * obj)
  313. {
  314.    if (obj && *(void**)obj) {
  315.       SOM_Resolve(obj,SOMObject,somDestruct)
  316.          ((SOMObject*)obj, 1, 0);
  317.    }
  318. }
  319.  
  320. SOMEEMan()
  321. {
  322.    if (*(void**)this != 
  323.        ((somParentMtabStructPtr)
  324.         (SOMEEManCClassData.parentMtab))->mtab)
  325.       return;
  326.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  327. }
  328.  
  329. SOMEEMan(SOMEEMan* fromObj)
  330. {
  331.    if (*(void**)this != 
  332.        ((somParentMtabStructPtr)
  333.         (SOMEEManCClassData.parentMtab))->mtab)
  334.       return;
  335.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  336. }
  337.  
  338. SOMEEMan(const SOMEEMan* fromObj)
  339. {
  340.    if (*(void**)this != 
  341.        ((somParentMtabStructPtr)
  342.         (SOMEEManCClassData.parentMtab))->mtab)
  343.       return;
  344.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  345. }
  346.  
  347.  
  348. /* method: someGetEManSem */
  349. void   someGetEManSem(Environment *ev)
  350. {
  351.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someGetEManSem)
  352.     (this, ev);
  353. }
  354.  
  355.  
  356. /* method: someReleaseEManSem */
  357. void   someReleaseEManSem(Environment *ev)
  358. {
  359.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someReleaseEManSem)
  360.     (this, ev);
  361. }
  362.  
  363.  
  364. /* method: someChangeRegData */
  365. void   someChangeRegData(Environment *ev,
  366.         long registrationId,
  367.         SOMEEMRegisterData* registerData)
  368. {
  369.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someChangeRegData)
  370.     (this, ev,registrationId,registerData);
  371. }
  372.  
  373.  
  374. /* method: someProcessEvent */
  375. void   someProcessEvent(Environment *ev,
  376.         unsigned long mask)
  377. {
  378.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someProcessEvent)
  379.     (this, ev,mask);
  380. }
  381.  
  382.  
  383. /* method: someProcessEvents */
  384. void   someProcessEvents(Environment *ev)
  385. {
  386.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someProcessEvents)
  387.     (this, ev);
  388. }
  389.  
  390.  
  391. /* method: someQueueEvent */
  392. void   someQueueEvent(Environment *ev,
  393.         SOMEClientEvent* event)
  394. {
  395.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someQueueEvent)
  396.     (this, ev,event);
  397. }
  398.  
  399.  
  400. /* method: someRegister */
  401. long   someRegister(Environment *ev,
  402.         SOMEEMRegisterData* registerData,
  403.         SOMObject* targetObject,
  404.         string targetMethod,
  405.         void* targetData)
  406. {
  407.    return SOM_ResolveD(this,SOMEEMan,SOMEEMan,someRegister)
  408.     (this, ev,registerData,targetObject,targetMethod,targetData);
  409. }
  410.  
  411.  
  412. /* method: someRegisterEv */
  413. long   someRegisterEv(Environment *ev,
  414.         SOMEEMRegisterData* registerData,
  415.         SOMObject* targetObject,
  416.         Environment* callbackEv,
  417.         string targetMethod,
  418.         void* targetData)
  419. {
  420.    return SOM_ResolveD(this,SOMEEMan,SOMEEMan,someRegisterEv)
  421.     (this, ev,registerData,targetObject,callbackEv,targetMethod,targetData);
  422. }
  423.  
  424.  
  425. /* method: someRegisterProc */
  426. long   someRegisterProc(Environment *ev,
  427.         SOMEEMRegisterData* registerData,
  428.         EMRegProc* targetProcedure,
  429.         void* targetData)
  430. {
  431.    return SOM_ResolveD(this,SOMEEMan,SOMEEMan,someRegisterProc)
  432.     (this, ev,registerData,targetProcedure,targetData);
  433. }
  434.  
  435.  
  436. /* method: someShutdown */
  437. void   someShutdown(Environment *ev)
  438. {
  439.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someShutdown)
  440.     (this, ev);
  441. }
  442.  
  443.  
  444. /* method: someUnRegister */
  445. void   someUnRegister(Environment *ev,
  446.         long registrationId)
  447. {
  448.    SOM_ResolveD(this,SOMEEMan,SOMEEMan,someUnRegister)
  449.     (this, ev,registrationId);
  450. }
  451.  
  452.  
  453. /*
  454.  * Reintroduce inherited methods
  455.  */
  456.  
  457. /* initializer method: somDefaultInit */
  458. void   somDefaultInit(somInitCtrl* ctrl)
  459. {
  460.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultInit)
  461.     (this,ctrl);
  462. }
  463.  
  464.  
  465. /* method: somDestruct */
  466. void   somDestruct(octet doFree,
  467.         somDestructCtrl* ctrl)
  468. {
  469.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDestruct)
  470.     (this,doFree,ctrl);
  471. }
  472.  
  473.  
  474. /* initializer method: somDefaultCopyInit */
  475. void   somDefaultCopyInit(somInitCtrl* ctrl,
  476.         SOMObject* fromObj)
  477. {
  478.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultCopyInit)
  479.     (this,ctrl,fromObj);
  480. }
  481.  
  482.  
  483. /* method: somDefaultAssign */
  484. SOMEEMan*  somDefaultAssign(somAssignCtrl* ctrl,
  485.         SOMObject* fromObj)
  486. {
  487.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultAssign)
  488.     (this,ctrl,fromObj);
  489. }
  490.  
  491.  
  492. /* initializer method: somDefaultConstCopyInit */
  493. void   somDefaultConstCopyInit(somInitCtrl* ctrl,
  494.         SOMObject* fromObj)
  495. {
  496.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultConstCopyInit)
  497.     (this,ctrl,fromObj);
  498. }
  499.  
  500.  
  501. /* initializer method: somDefaultVCopyInit */
  502. void   somDefaultVCopyInit(somInitCtrl* ctrl,
  503.         SOMObject* fromObj)
  504. {
  505.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultVCopyInit)
  506.     (this,ctrl,fromObj);
  507. }
  508.  
  509.  
  510. /* initializer method: somDefaultConstVCopyInit */
  511. void   somDefaultConstVCopyInit(somInitCtrl* ctrl,
  512.         SOMObject* fromObj)
  513. {
  514.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultConstVCopyInit)
  515.     (this,ctrl,fromObj);
  516. }
  517.  
  518.  
  519. /* method: somDefaultConstAssign */
  520. SOMEEMan*  somDefaultConstAssign(somAssignCtrl* ctrl,
  521.         SOMObject* fromObj)
  522. {
  523.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultConstAssign)
  524.     (this,ctrl,fromObj);
  525. }
  526.  
  527.  
  528. /* method: somDefaultVAssign */
  529. SOMEEMan*  somDefaultVAssign(somAssignCtrl* ctrl,
  530.         SOMObject* fromObj)
  531. {
  532.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultVAssign)
  533.     (this,ctrl,fromObj);
  534. }
  535.  
  536.  
  537. /* method: somDefaultConstVAssign */
  538. SOMEEMan*  somDefaultConstVAssign(somAssignCtrl* ctrl,
  539.         SOMObject* fromObj)
  540. {
  541.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somDefaultConstVAssign)
  542.     (this,ctrl,fromObj);
  543. }
  544.  
  545.  
  546. /* method: somInit */
  547. void   somInit()
  548. {
  549.    SOM_ResolveD(this,SOMEEMan,SOMObject,somInit)
  550.     (this);
  551. }
  552.  
  553.  
  554. /* method: somFree */
  555. void   somFree()
  556. {
  557.    SOM_ResolveD(this,SOMEEMan,SOMObject,somFree)
  558.     (this);
  559. }
  560.  
  561.  
  562. /* method: somUninit */
  563. void   somUninit()
  564. {
  565.    SOM_ResolveD(this,SOMEEMan,SOMObject,somUninit)
  566.     (this);
  567. }
  568.  
  569.  
  570. /* method: somGetClass */
  571. SOMMSingleInstance*  somGetClass()
  572. {
  573.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somGetClass)
  574.     (this);
  575. }
  576.  
  577.  
  578. /* method: somGetClassName */
  579. string   somGetClassName()
  580. {
  581.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somGetClassName)
  582.     (this);
  583. }
  584.  
  585.  
  586. /* method: somGetSize */
  587. long   somGetSize()
  588. {
  589.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somGetSize)
  590.     (this);
  591. }
  592.  
  593.  
  594. /* method: somIsA */
  595. boolean   somIsA(SOMClass* aClassObj)
  596. {
  597.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somIsA)
  598.     (this,aClassObj);
  599. }
  600.  
  601.  
  602. /* method: somIsInstanceOf */
  603. boolean   somIsInstanceOf(SOMClass* aClassObj)
  604. {
  605.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somIsInstanceOf)
  606.     (this,aClassObj);
  607. }
  608.  
  609.  
  610. /* method: somRespondsTo */
  611. boolean   somRespondsTo(somId mId)
  612. {
  613.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somRespondsTo)
  614.     (this,mId);
  615. }
  616.  
  617.  
  618. /* va_list method: somDispatch */
  619. /* the va_list invocation form */
  620. boolean   SOMEEMan_somDispatch(somToken* retValue,
  621.         somId methodId,
  622.         va_list ap)
  623. {
  624. return SOM_ResolveD(this,SOMEEMan,SOMObject,somDispatch)
  625.     (this,retValue,methodId,ap);
  626. }
  627.  
  628. /* the varargs invocation form */
  629. boolean   somDispatch(somToken* retValue,
  630.         somId methodId,
  631.         ...)
  632. {
  633.    va_list ap;
  634.    va_start(ap, methodId);
  635.    boolean __somResult = 
  636.       SOM_ResolveD(this,SOMEEMan,SOMObject,somDispatch)
  637.     (this,retValue,methodId,ap);
  638.    va_end(ap);
  639.    return __somResult;
  640. }
  641.  
  642.  
  643. /* va_list method: somClassDispatch */
  644. /* the va_list invocation form */
  645. boolean   SOMEEMan_somClassDispatch(SOMClass* clsObj,
  646.         somToken* retValue,
  647.         somId methodId,
  648.         va_list ap)
  649. {
  650. return SOM_ResolveD(this,SOMEEMan,SOMObject,somClassDispatch)
  651.     (this,clsObj,retValue,methodId,ap);
  652. }
  653.  
  654. /* the varargs invocation form */
  655. boolean   somClassDispatch(SOMClass* clsObj,
  656.         somToken* retValue,
  657.         somId methodId,
  658.         ...)
  659. {
  660.    va_list ap;
  661.    va_start(ap, methodId);
  662.    boolean __somResult = 
  663.       SOM_ResolveD(this,SOMEEMan,SOMObject,somClassDispatch)
  664.     (this,clsObj,retValue,methodId,ap);
  665.    va_end(ap);
  666.    return __somResult;
  667. }
  668.  
  669.  
  670. /* method: somCastObj */
  671. boolean   somCastObj(SOMClass* cls)
  672. {
  673.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somCastObj)
  674.     (this,cls);
  675. }
  676.  
  677.  
  678. /* method: somResetObj */
  679. boolean   somResetObj()
  680. {
  681.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somResetObj)
  682.     (this);
  683. }
  684.  
  685.  
  686. /* method: somPrintSelf */
  687. SOMObject*   somPrintSelf()
  688. {
  689.    return SOM_ResolveD(this,SOMEEMan,SOMObject,somPrintSelf)
  690.     (this);
  691. }
  692.  
  693.  
  694. /* method: somDumpSelf */
  695. void   somDumpSelf(long level)
  696. {
  697.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDumpSelf)
  698.     (this,level);
  699. }
  700.  
  701.  
  702. /* method: somDumpSelfInt */
  703. void   somDumpSelfInt(long level)
  704. {
  705.    SOM_ResolveD(this,SOMEEMan,SOMObject,somDumpSelfInt)
  706.     (this,level);
  707. }
  708.  
  709.  
  710.  
  711. };   /* SOMEEMan */
  712.  
  713.  
  714.  
  715. #endif       /* SOM_SOMEEMan_xh */
  716.