home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / eman.h < prev    next >
C/C++ Source or Header  |  1999-02-22  |  18KB  |  499 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: eman.h.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.17
  7.  *     SOM Emitter emith: 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_h
  26. #define SOM_SOMEEMan_h
  27.  
  28.  
  29. #include <som.h>
  30.  
  31. /*
  32.  * -- This emitter treats Method Tokens as Thunks by default.
  33.  * -- Use the sc modifier "nothunks" to change this default
  34.  */
  35. #undef somresolve_
  36. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  37.  
  38. /*
  39.  * Define the class name as an object type
  40.  */
  41. #ifndef SOMEEMan
  42. #define SOMEEMan SOMObject
  43. #endif
  44. /*
  45.  *  The Event Manager class (EMan for short) is used to handle several input
  46.  *  events. The main purpose of this class is to provide a service that can do
  47.  *  a blocked (or timed) wait on several event sources concurrently.  Typically,
  48.  *  in a main program,  one registers an interest in an event type with EMan and
  49.  *  specifies a callback (a procedure or a method) to be invoked when the event
  50.  *  of interest occurs. After all the necessary registrations are done, the main
  51.  *  program is ended by a call to process events in EMan. This call is non-returning.
  52.  *  Eman then waits on multiple registered sources of events. The application is then
  53.  *  completely event driven. I.E., it does something only when an event occurs.
  54.  *  The control returns to EMan after processing each event. Further registrations
  55.  *  can be done inside of callback routines. So also unregistrations.
  56.  * 
  57.  *  AIX Specifics:
  58.  *  On AIX this event manager supports Timer, Sink (any file, pipe,
  59.  *  socket and Message Queue), Client and WorkProc events.
  60.  * 
  61.  *  OS/2 Specifics:
  62.  *  On OS/2 this event manager supports Timer, Sink(sockets only). Client and
  63.  *  WorkProc events.
  64.  *  To cope with multi-threaded applications on OS/2, the event manager
  65.  *  methods are mutually exclusive (i.e., at any time only one thread can be
  66.  *  executing inside of EMan).
  67.  *  If an application thread needs to stop EMan from running (i.e., achieve
  68.  *  mutual exclusion with EMan), it can use the two methods someGetEmanSem
  69.  *  and someReleaseEManSem to acquire and release EMan semaphore(s).
  70.  *  On AIX, at present, since AIX does not support threads calling these two methods
  71.  *  has no effect.
  72.  */
  73. #include <somobj.h>
  74.  
  75. /*
  76.  * Start of bindings for IDL types
  77.  */
  78.  
  79. #ifndef SOMClass
  80.     #define SOMClass SOMObject
  81. #endif /* SOMClass */
  82. #ifndef SOMEEvent
  83.     #define SOMEEvent SOMObject
  84. #endif /* SOMEEvent */
  85. #ifndef SOMEClientEvent
  86.     #define SOMEClientEvent SOMObject
  87. #endif /* SOMEClientEvent */
  88. #ifndef SOMEEMRegisterData
  89.     #define SOMEEMRegisterData SOMObject
  90. #endif /* SOMEEMRegisterData */
  91.  
  92. /*
  93.  * End of bindings for IDL types.
  94.  */
  95.  
  96. /*
  97.  * Passthru lines: File: "C.h", "after"
  98.  */
  99. #include <emtypes.h>
  100.  
  101. #define SOMEEMan_MajorVersion 2
  102. #define SOMEEMan_MinorVersion 1
  103.  
  104. /*
  105.  * External name shortening if required
  106.  */
  107. #ifdef SOM_USE_SHORT_EXTERNAL_NAMES
  108. #define SOMEEManNewClass c
  109. #pragma linkage(c, system)
  110. #define SOMEEManClassData d
  111. #define SOMEEManCClassData x
  112. #endif /* SOM_USE_SHORT_EXTERNAL_NAMES */
  113.  
  114. /*
  115.  * Include the metaclass file
  116.  */
  117. #ifndef SOM_SOMMSingleInstance_h
  118. #include <snglicls.h>
  119. #endif
  120. /*--------------Migration------------*/
  121. #define SOMEEMan_classObj SOMEEManClassData.classObject
  122. #define _SOMEEMan SOMEEMan_classObj
  123.  
  124. /*
  125.  * Declare the class creation procedure
  126.  */
  127. SOMEXTERN SOMClass * SOMLINK SOMEEManNewClass(integer4 somtmajorVersion,
  128.         integer4 somtminorVersion);
  129. #pragma linkage(SOMEEManNewClass, system)
  130.  
  131. /*
  132.  * Declare the class data structure
  133.  */
  134. SOMEXTERN struct SOMEEManClassDataStructure {
  135.     SOMClass *classObject;
  136.     somMToken someGetEManSem;
  137.     somMToken someReleaseEManSem;
  138.     somMToken someChangeRegData;
  139.     somMToken someProcessEvent;
  140.     somMToken someProcessEvents;
  141.     somMToken someQueueEvent;
  142.     somMToken someRegister;
  143.     somMToken someRegisterEv;
  144.     somMToken someRegisterProc;
  145.     somMToken someShutdown;
  146.     somMToken someUnRegister;
  147. } SOMDLINK SOMEEManClassData;
  148.  
  149. /*
  150.  * Declare the C specific class data structure
  151.  */
  152. SOMEXTERN struct SOMEEManCClassDataStructure {
  153.     somMethodTabs parentMtab;
  154.     somDToken instanceDataToken;
  155. } SOMDLINK SOMEEManCClassData;
  156.  
  157. /*
  158.  * New and Renew macros for SOMEEMan
  159.  */
  160. #define SOMEEManNew() \
  161.    ( _SOMEEMan ? \
  162.     _somNew(_SOMEEMan) \
  163.     : ( SOMEEManNewClass(\
  164.         SOMEEMan_MajorVersion, \
  165.         SOMEEMan_MinorVersion),\
  166.        _somNew(_SOMEEMan)))
  167. #define SOMEEManRenew(buf) \
  168.    ( _SOMEEMan ? \
  169.     _somRenew(_SOMEEMan, buf) \
  170.     : ( SOMEEManNewClass(\
  171.         SOMEEMan_MajorVersion, \
  172.         SOMEEMan_MinorVersion),\
  173.        _somRenew(_SOMEEMan, buf)))
  174.  
  175. /*
  176.  * Override method: somInit
  177.  */
  178. #define SOMEEMan_somInit(somSelf) \
  179.     SOMObject_somInit(somSelf)
  180.  
  181. /*
  182.  * Override method: somUninit
  183.  */
  184. #define SOMEEMan_somUninit(somSelf) \
  185.     SOMObject_somUninit(somSelf)
  186.  
  187. /*
  188.  * New Method: someGetEManSem
  189.  */
  190. typedef void   SOMLINK somTP_SOMEEMan_someGetEManSem(SOMEEMan *somSelf, Environment *ev);
  191. #pragma linkage(somTP_SOMEEMan_someGetEManSem, system)
  192. typedef somTP_SOMEEMan_someGetEManSem *somTD_SOMEEMan_someGetEManSem;
  193. /*
  194.  *  Gets a semaphore to achieve mutual exclusion with EMan's activity.
  195.  *  Callers should not hold this semaphore for too long since it essentially
  196.  *  stops EMan activity for that duration.
  197.  */
  198. #define somMD_SOMEEMan_someGetEManSem "::SOMEEMan::someGetEManSem"
  199. #define SOMEEMan_someGetEManSem(somSelf,ev) \
  200.     (SOM_Resolve(somSelf, SOMEEMan, someGetEManSem) \
  201.     (somSelf,ev))
  202. #ifndef SOMGD_someGetEManSem
  203.     #if (defined(_someGetEManSem) || defined(__someGetEManSem))
  204.         #undef _someGetEManSem
  205.         #undef __someGetEManSem
  206.         #define SOMGD_someGetEManSem 1
  207.     #else
  208.         #define _someGetEManSem SOMEEMan_someGetEManSem
  209.     #endif /* _someGetEManSem */
  210. #endif /* SOMGD_someGetEManSem */
  211.  
  212. /*
  213.  * New Method: someReleaseEManSem
  214.  */
  215. typedef void   SOMLINK somTP_SOMEEMan_someReleaseEManSem(SOMEEMan *somSelf, Environment *ev);
  216. #pragma linkage(somTP_SOMEEMan_someReleaseEManSem, system)
  217. typedef somTP_SOMEEMan_someReleaseEManSem *somTD_SOMEEMan_someReleaseEManSem;
  218. /*
  219.  *  Release the semaphore obtained by someGetEManSem.
  220.  */
  221. #define somMD_SOMEEMan_someReleaseEManSem "::SOMEEMan::someReleaseEManSem"
  222. #define SOMEEMan_someReleaseEManSem(somSelf,ev) \
  223.     (SOM_Resolve(somSelf, SOMEEMan, someReleaseEManSem) \
  224.     (somSelf,ev))
  225. #ifndef SOMGD_someReleaseEManSem
  226.     #if (defined(_someReleaseEManSem) || defined(__someReleaseEManSem))
  227.         #undef _someReleaseEManSem
  228.         #undef __someReleaseEManSem
  229.         #define SOMGD_someReleaseEManSem 1
  230.     #else
  231.         #define _someReleaseEManSem SOMEEMan_someReleaseEManSem
  232.     #endif /* _someReleaseEManSem */
  233. #endif /* SOMGD_someReleaseEManSem */
  234.  
  235. /*
  236.  * New Method: someChangeRegData
  237.  */
  238. typedef void   SOMLINK somTP_SOMEEMan_someChangeRegData(SOMEEMan *somSelf, Environment *ev, 
  239.         long registrationId, 
  240.         SOMEEMRegisterData* registerData);
  241. #pragma linkage(somTP_SOMEEMan_someChangeRegData, system)
  242. typedef somTP_SOMEEMan_someChangeRegData *somTD_SOMEEMan_someChangeRegData;
  243. /*
  244.  *  Change the registration data associated with the specified id.
  245.  *  This id must have been returned by EMan in a previous Register call.
  246.  */
  247. #define somMD_SOMEEMan_someChangeRegData "::SOMEEMan::someChangeRegData"
  248. #define SOMEEMan_someChangeRegData(somSelf,ev,registrationId,registerData) \
  249.     (SOM_Resolve(somSelf, SOMEEMan, someChangeRegData) \
  250.     (somSelf,ev,registrationId,registerData))
  251. #ifndef SOMGD_someChangeRegData
  252.     #if (defined(_someChangeRegData) || defined(__someChangeRegData))
  253.         #undef _someChangeRegData
  254.         #undef __someChangeRegData
  255.         #define SOMGD_someChangeRegData 1
  256.     #else
  257.         #define _someChangeRegData SOMEEMan_someChangeRegData
  258.     #endif /* _someChangeRegData */
  259. #endif /* SOMGD_someChangeRegData */
  260.  
  261. /*
  262.  * New Method: someProcessEvent
  263.  */
  264. typedef void   SOMLINK somTP_SOMEEMan_someProcessEvent(SOMEEMan *somSelf, Environment *ev, 
  265.         unsigned long mask);
  266. #pragma linkage(somTP_SOMEEMan_someProcessEvent, system)
  267. typedef somTP_SOMEEMan_someProcessEvent *somTD_SOMEEMan_someProcessEvent;
  268. /*
  269.  *  Process one event. This call is non-blocking. If there are no events to
  270.  *  process it returns immediately. The mask specifies what events to process.
  271.  *  The mask is formed by ORing the bit constants specified in eventmsk.h
  272.  *  For example, to processs Timer and Sink events only one would specify
  273.  *  the mask as:  EMProcessTimerEvent | EMProcessSinkEvent
  274.  */
  275. #define somMD_SOMEEMan_someProcessEvent "::SOMEEMan::someProcessEvent"
  276. #define SOMEEMan_someProcessEvent(somSelf,ev,mask) \
  277.     (SOM_Resolve(somSelf, SOMEEMan, someProcessEvent) \
  278.     (somSelf,ev,mask))
  279. #ifndef SOMGD_someProcessEvent
  280.     #if (defined(_someProcessEvent) || defined(__someProcessEvent))
  281.         #undef _someProcessEvent
  282.         #undef __someProcessEvent
  283.         #define SOMGD_someProcessEvent 1
  284.     #else
  285.         #define _someProcessEvent SOMEEMan_someProcessEvent
  286.     #endif /* _someProcessEvent */
  287. #endif /* SOMGD_someProcessEvent */
  288.  
  289. /*
  290.  * New Method: someProcessEvents
  291.  */
  292. typedef void   SOMLINK somTP_SOMEEMan_someProcessEvents(SOMEEMan *somSelf, Environment *ev);
  293. #pragma linkage(somTP_SOMEEMan_someProcessEvents, system)
  294. typedef somTP_SOMEEMan_someProcessEvents *somTD_SOMEEMan_someProcessEvents;
  295. /*
  296.  *  Process infinite events. Does not return. Loops forever waiting for events
  297.  *  and dispatching events. The only way this can be broken is by calling
  298.  *  someShutdown in a callback.
  299.  */
  300. #define somMD_SOMEEMan_someProcessEvents "::SOMEEMan::someProcessEvents"
  301. #define SOMEEMan_someProcessEvents(somSelf,ev) \
  302.     (SOM_Resolve(somSelf, SOMEEMan, someProcessEvents) \
  303.     (somSelf,ev))
  304. #ifndef SOMGD_someProcessEvents
  305.     #if (defined(_someProcessEvents) || defined(__someProcessEvents))
  306.         #undef _someProcessEvents
  307.         #undef __someProcessEvents
  308.         #define SOMGD_someProcessEvents 1
  309.     #else
  310.         #define _someProcessEvents SOMEEMan_someProcessEvents
  311.     #endif /* _someProcessEvents */
  312. #endif /* SOMGD_someProcessEvents */
  313.  
  314. /*
  315.  * New Method: someQueueEvent
  316.  */
  317. typedef void   SOMLINK somTP_SOMEEMan_someQueueEvent(SOMEEMan *somSelf, Environment *ev, 
  318.         SOMEClientEvent* event);
  319. #pragma linkage(somTP_SOMEEMan_someQueueEvent, system)
  320. typedef somTP_SOMEEMan_someQueueEvent *somTD_SOMEEMan_someQueueEvent;
  321. /*
  322.  *  Used to be: void someQueueEvent(inout SOMEClientEvent event);
  323.  *  Enqueue the specified client event
  324.  */
  325. #define somMD_SOMEEMan_someQueueEvent "::SOMEEMan::someQueueEvent"
  326. #define SOMEEMan_someQueueEvent(somSelf,ev,event) \
  327.     (SOM_Resolve(somSelf, SOMEEMan, someQueueEvent) \
  328.     (somSelf,ev,event))
  329. #ifndef SOMGD_someQueueEvent
  330.     #if (defined(_someQueueEvent) || defined(__someQueueEvent))
  331.         #undef _someQueueEvent
  332.         #undef __someQueueEvent
  333.         #define SOMGD_someQueueEvent 1
  334.     #else
  335.         #define _someQueueEvent SOMEEMan_someQueueEvent
  336.     #endif /* _someQueueEvent */
  337. #endif /* SOMGD_someQueueEvent */
  338.  
  339. /*
  340.  * New Method: someRegister
  341.  */
  342. typedef long   SOMLINK somTP_SOMEEMan_someRegister(SOMEEMan *somSelf, Environment *ev, 
  343.         SOMEEMRegisterData* registerData, 
  344.         SOMObject* targetObject, 
  345.         string targetMethod, 
  346.         void* targetData);
  347. #pragma linkage(somTP_SOMEEMan_someRegister, system)
  348. typedef somTP_SOMEEMan_someRegister *somTD_SOMEEMan_someRegister;
  349. /*
  350.  *  Register the object/method pair with EMan given the specified 'registerData'.
  351.  */
  352. #define somMD_SOMEEMan_someRegister "::SOMEEMan::someRegister"
  353. #define SOMEEMan_someRegister(somSelf,ev,registerData,targetObject,targetMethod,targetData) \
  354.     (SOM_Resolve(somSelf, SOMEEMan, someRegister) \
  355.     (somSelf,ev,registerData,targetObject,targetMethod,targetData))
  356. #ifndef SOMGD_someRegister
  357.     #if (defined(_someRegister) || defined(__someRegister))
  358.         #undef _someRegister
  359.         #undef __someRegister
  360.         #define SOMGD_someRegister 1
  361.     #else
  362.         #define _someRegister SOMEEMan_someRegister
  363.     #endif /* _someRegister */
  364. #endif /* SOMGD_someRegister */
  365.  
  366. /*
  367.  * New Method: someRegisterEv
  368.  */
  369. typedef long   SOMLINK somTP_SOMEEMan_someRegisterEv(SOMEEMan *somSelf, Environment *ev, 
  370.         SOMEEMRegisterData* registerData, 
  371.         SOMObject* targetObject, 
  372.         Environment* callbackEv, 
  373.         string targetMethod, 
  374.         void* targetData);
  375. #pragma linkage(somTP_SOMEEMan_someRegisterEv, system)
  376. typedef somTP_SOMEEMan_someRegisterEv *somTD_SOMEEMan_someRegisterEv;
  377. /*
  378.  *  Register the object/method pair together with the callback Environment parameter
  379.  *  with EMan given the specified 'registerData'.
  380.  */
  381. #define somMD_SOMEEMan_someRegisterEv "::SOMEEMan::someRegisterEv"
  382. #define SOMEEMan_someRegisterEv(somSelf,ev,registerData,targetObject,callbackEv,targetMethod,targetData) \
  383.     (SOM_Resolve(somSelf, SOMEEMan, someRegisterEv) \
  384.     (somSelf,ev,registerData,targetObject,callbackEv,targetMethod,targetData))
  385. #ifndef SOMGD_someRegisterEv
  386.     #if (defined(_someRegisterEv) || defined(__someRegisterEv))
  387.         #undef _someRegisterEv
  388.         #undef __someRegisterEv
  389.         #define SOMGD_someRegisterEv 1
  390.     #else
  391.         #define _someRegisterEv SOMEEMan_someRegisterEv
  392.     #endif /* _someRegisterEv */
  393. #endif /* SOMGD_someRegisterEv */
  394.  
  395. /*
  396.  * New Method: someRegisterProc
  397.  */
  398. typedef long   SOMLINK somTP_SOMEEMan_someRegisterProc(SOMEEMan *somSelf, Environment *ev, 
  399.         SOMEEMRegisterData* registerData, 
  400.         EMRegProc* targetProcedure, 
  401.         void* targetData);
  402. #pragma linkage(somTP_SOMEEMan_someRegisterProc, system)
  403. typedef somTP_SOMEEMan_someRegisterProc *somTD_SOMEEMan_someRegisterProc;
  404. /*
  405.  *  Register the procedure with EMan given the specified 'registerData'.
  406.  */
  407. #define somMD_SOMEEMan_someRegisterProc "::SOMEEMan::someRegisterProc"
  408. #define SOMEEMan_someRegisterProc(somSelf,ev,registerData,targetProcedure,targetData) \
  409.     (SOM_Resolve(somSelf, SOMEEMan, someRegisterProc) \
  410.     (somSelf,ev,registerData,targetProcedure,targetData))
  411. #ifndef SOMGD_someRegisterProc
  412.     #if (defined(_someRegisterProc) || defined(__someRegisterProc))
  413.         #undef _someRegisterProc
  414.         #undef __someRegisterProc
  415.         #define SOMGD_someRegisterProc 1
  416.     #else
  417.         #define _someRegisterProc SOMEEMan_someRegisterProc
  418.     #endif /* _someRegisterProc */
  419. #endif /* SOMGD_someRegisterProc */
  420.  
  421. /*
  422.  * New Method: someShutdown
  423.  */
  424. typedef void   SOMLINK somTP_SOMEEMan_someShutdown(SOMEEMan *somSelf, Environment *ev);
  425. #pragma linkage(somTP_SOMEEMan_someShutdown, system)
  426. typedef somTP_SOMEEMan_someShutdown *somTD_SOMEEMan_someShutdown;
  427. /*
  428.  *  Shutdown EMan event loop. (i.e., makes the someProcessEvents return!)
  429.  */
  430. #define somMD_SOMEEMan_someShutdown "::SOMEEMan::someShutdown"
  431. #define SOMEEMan_someShutdown(somSelf,ev) \
  432.     (SOM_Resolve(somSelf, SOMEEMan, someShutdown) \
  433.     (somSelf,ev))
  434. #ifndef SOMGD_someShutdown
  435.     #if (defined(_someShutdown) || defined(__someShutdown))
  436.         #undef _someShutdown
  437.         #undef __someShutdown
  438.         #define SOMGD_someShutdown 1
  439.     #else
  440.         #define _someShutdown SOMEEMan_someShutdown
  441.     #endif /* _someShutdown */
  442. #endif /* SOMGD_someShutdown */
  443.  
  444. /*
  445.  * New Method: someUnRegister
  446.  */
  447. typedef void   SOMLINK somTP_SOMEEMan_someUnRegister(SOMEEMan *somSelf, Environment *ev, 
  448.         long registrationId);
  449. #pragma linkage(somTP_SOMEEMan_someUnRegister, system)
  450. typedef somTP_SOMEEMan_someUnRegister *somTD_SOMEEMan_someUnRegister;
  451. /*
  452.  *  Unregister the data associated with the specified 'registrationId' within EMan
  453.  */
  454. #define somMD_SOMEEMan_someUnRegister "::SOMEEMan::someUnRegister"
  455. #define SOMEEMan_someUnRegister(somSelf,ev,registrationId) \
  456.     (SOM_Resolve(somSelf, SOMEEMan, someUnRegister) \
  457.     (somSelf,ev,registrationId))
  458. #ifndef SOMGD_someUnRegister
  459.     #if (defined(_someUnRegister) || defined(__someUnRegister))
  460.         #undef _someUnRegister
  461.         #undef __someUnRegister
  462.         #define SOMGD_someUnRegister 1
  463.     #else
  464.         #define _someUnRegister SOMEEMan_someUnRegister
  465.     #endif /* _someUnRegister */
  466. #endif /* SOMGD_someUnRegister */
  467. #ifndef SOM_DONT_USE_INHERITED_MACROS
  468. #define SOMEEMan_somDefaultInit SOMObject_somDefaultInit
  469. #define SOMEEMan_somDestruct SOMObject_somDestruct
  470. #define SOMEEMan_somDefaultCopyInit SOMObject_somDefaultCopyInit
  471. #define SOMEEMan_somDefaultAssign SOMObject_somDefaultAssign
  472. #define SOMEEMan_somDefaultConstCopyInit SOMObject_somDefaultConstCopyInit
  473. #define SOMEEMan_somDefaultVCopyInit SOMObject_somDefaultVCopyInit
  474. #define SOMEEMan_somDefaultConstVCopyInit SOMObject_somDefaultConstVCopyInit
  475. #define SOMEEMan_somDefaultConstAssign SOMObject_somDefaultConstAssign
  476. #define SOMEEMan_somDefaultVAssign SOMObject_somDefaultVAssign
  477. #define SOMEEMan_somDefaultConstVAssign SOMObject_somDefaultConstVAssign
  478. #define SOMEEMan_somFree SOMObject_somFree
  479. #define SOMEEMan_somGetClass SOMObject_somGetClass
  480. #define SOMEEMan_somGetClassName SOMObject_somGetClassName
  481. #define SOMEEMan_somGetSize SOMObject_somGetSize
  482. #define SOMEEMan_somIsA SOMObject_somIsA
  483. #define SOMEEMan_somIsInstanceOf SOMObject_somIsInstanceOf
  484. #define SOMEEMan_somRespondsTo SOMObject_somRespondsTo
  485. #define SOMEEMan_somDispatch SOMObject_somDispatch
  486. #define SOMEEMan_somClassDispatch SOMObject_somClassDispatch
  487. #define SOMEEMan_somCastObj SOMObject_somCastObj
  488. #define SOMEEMan_somResetObj SOMObject_somResetObj
  489. #define SOMEEMan_somDispatchV SOMObject_somDispatchV
  490. #define SOMEEMan_somDispatchL SOMObject_somDispatchL
  491. #define SOMEEMan_somDispatchA SOMObject_somDispatchA
  492. #define SOMEEMan_somDispatchD SOMObject_somDispatchD
  493. #define SOMEEMan_somPrintSelf SOMObject_somPrintSelf
  494. #define SOMEEMan_somDumpSelf SOMObject_somDumpSelf
  495. #define SOMEEMan_somDumpSelfInt SOMObject_somDumpSelfInt
  496. #endif /* SOM_DONT_USE_INHERITED_MACROS */
  497.  
  498. #endif       /* SOM_SOMEEMan_h */
  499.