home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / somdserv.xh < prev    next >
Text File  |  1999-02-22  |  30KB  |  996 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: somdserv.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.17
  7.  *     SOM Emitter emitxh: 2.47
  8.  */
  9.  
  10. /*
  11.  *    Interface for DSOM Server Objects
  12.  * 
  13.  *    This class defines and implements the behavior of DSOM Server objects
  14.  *    used with the DSOM Object Manager (SOMDObjectMgr).
  15.  * 
  16.  *    Each DSOM server process is defined to have a (single instance of a)
  17.  *    SOMDServer object.  The SOMDServer object performs three kinds of
  18.  *    functions:
  19.  * 
  20.  *        1) creation of SOM objects
  21.  *        2) mapping of application-defined object ids into DSOM object
  22.  *           "references" (SOMDObjects), and back again
  23.  *        3) any application-specific server methods (e.g., for initialization,
  24.  *           server control, etc.)
  25.  * 
  26.  *    The SOMDServer class defines methods for the basic creation of SOM
  27.  *    objects in the server process (somdCreateObj), for deletion of SOM
  28.  *    objects (somdDeleteObj), and for finding the SOM  class object for a
  29.  *    specified class (somdGetClassObj).
  30.  *    With somdGetClassObj, a client can get a proxy to a class object on the
  31.  *    server, so that methods introduced in the metaclass (e.g., class-specific
  32.  *    constructors, etc.) may be invoked directly.
  33.  * 
  34.  *    This class also defines methods for the mappings to and from SOMDObjects
  35.  *    and back again.  (Note: SOMDObject implements a CORBA "object reference"
  36.  *    in DSOM.  An object reference is something that is used to describe and
  37.  *    locate an actual target object.)  These methods are used by the SOM
  38.  *    Object Adapter (SOMOA) when converting messages into method calls
  39.  *    and results into messages.
  40.  * 
  41.  *    Application-specific server methods should be defined in subclasses
  42.  *    of this SOMDServer subclass.
  43.  * 
  44.  *    A particular SOMDServer subclass is specified in the ImplementationDef
  45.  *    for each server process.  The SOMOA will instantiate one instance
  46.  *    of the specified SOMDServer subclass during server process initialization
  47.  *    (in SOMOA::impl_is_ready).
  48.  * 
  49.  */
  50.  
  51.  
  52. #ifndef SOM_SOMDServer_xh
  53. #define SOM_SOMDServer_xh
  54.  
  55. class SOMDServer;
  56.  
  57. #define SOMDServer_MajorVersion 2
  58. #define SOMDServer_MinorVersion 1
  59.  
  60. /* C++ SOM defs */
  61. #include <somcls.xh>
  62. #include <somcm.xh>
  63.  
  64. /* C++ parent defs */
  65. #ifndef SOM_SOMObject_xh
  66. #include <somobj.xh>
  67. #endif
  68.  
  69. /*
  70.  * C++ metaclass def
  71.  */
  72. #include <snglicls.xh>
  73.  
  74. #ifndef SOMDServer_API
  75. #define SOMDServer_API
  76. /*
  77.  * -- The Class API
  78.  */
  79.  
  80. /*
  81.  * Start of bindings for IDL types
  82.  */
  83.  
  84. class SOMClass;
  85. class SOMObject;
  86. class Container;
  87. class SOMDObject;
  88.  
  89. /*
  90.  * End of bindings for IDL types.
  91.  */
  92.  
  93. /*
  94.  * Passthru lines: File: "C.xh", "after"
  95.  */
  96.  
  97. class SOMDServer;
  98. SOMEXTERN SOMDServer * SOMDLINK SOMD_ServerObject; /* global variable */
  99.  
  100.  
  101. /* A procedure to create the SOMDServer Class */
  102. class SOMMSingleInstance;
  103. SOMEXTERN SOMMSingleInstance * SOMLINK SOMDServerNewClass(
  104.         integer4 majorVersion,
  105.         integer4 minorVersion);
  106.  
  107. /* The API to the SOMDServer class object, and the methods it introduces. */
  108. SOMEXTERN struct SOMDServerClassDataStructure {
  109.     SOMMSingleInstance *classObject;
  110.     somMToken somdSOMObjFromRef;
  111.     somMToken somdRefFromSOMObj;
  112.     somMToken somdCreateObj;
  113.     somMToken somdDeleteObj;
  114.     somMToken somdGetClassObj;
  115.     somMToken somdDispatchMethod;
  116.     somMToken somdObjReferencesCached;
  117. } SOMDLINK SOMDServerClassData;
  118. #define _SOMDServer SOMDServerClassData.classObject
  119.  
  120. /* The API to parentMtabs for SOMDServer, and the instance data it introduces. */
  121. SOMEXTERN struct SOMDServerCClassDataStructure {
  122.     somMethodTabs parentMtab;
  123.     somDToken              instanceDataToken;
  124. } SOMDLINK SOMDServerCClassData;
  125.  
  126. /*
  127.  * -- Typedefs for SOMDServer Method Procedures
  128.  */
  129. SOMEXTERN {
  130. typedef SOMDObject*   SOMLINK somTP_SOMDServer_somdRefFromSOMObj(SOMDServer *somSelf, Environment *ev, 
  131.         SOMObject* somobj);
  132. typedef somTP_SOMDServer_somdRefFromSOMObj *somTD_SOMDServer_somdRefFromSOMObj;
  133. typedef SOMObject*   SOMLINK somTP_SOMDServer_somdSOMObjFromRef(SOMDServer *somSelf, Environment *ev, 
  134.         SOMDObject* objref);
  135. typedef somTP_SOMDServer_somdSOMObjFromRef *somTD_SOMDServer_somdSOMObjFromRef;
  136. typedef void   SOMLINK somTP_SOMDServer_somdDispatchMethod(SOMDServer *somSelf, Environment *ev, 
  137.         SOMObject* somobj, 
  138.         somToken* retValue, 
  139.         somId methodId, 
  140.         va_list ap);
  141. typedef somTP_SOMDServer_somdDispatchMethod *somTD_SOMDServer_somdDispatchMethod;
  142. typedef SOMObject*   SOMLINK somTP_SOMDServer_somdCreateObj(SOMDServer *somSelf, Environment *ev, 
  143.         Identifier objclass, 
  144.         string hints);
  145. typedef somTP_SOMDServer_somdCreateObj *somTD_SOMDServer_somdCreateObj;
  146. typedef void   SOMLINK somTP_SOMDServer_somdDeleteObj(SOMDServer *somSelf, Environment *ev, 
  147.         SOMObject* somobj);
  148. typedef somTP_SOMDServer_somdDeleteObj *somTD_SOMDServer_somdDeleteObj;
  149. typedef SOMClass*   SOMLINK somTP_SOMDServer_somdGetClassObj(SOMDServer *somSelf, Environment *ev, 
  150.         Identifier objclass);
  151. typedef somTP_SOMDServer_somdGetClassObj *somTD_SOMDServer_somdGetClassObj;
  152. typedef boolean   SOMLINK somTP_SOMDServer_somdObjReferencesCached(SOMDServer *somSelf, Environment *ev);
  153. typedef somTP_SOMDServer_somdObjReferencesCached *somTD_SOMDServer_somdObjReferencesCached;
  154.  
  155. /*
  156.  * -- Typedefs for Reintroduced Wrapper Methods
  157.  */
  158. typedef void   SOMLINK somTP_SOMDServer_somDefaultInit(SOMDServer *somSelf, 
  159.         som3InitCtrl* ctrl);
  160. typedef somTP_SOMDServer_somDefaultInit *somTD_SOMDServer_somDefaultInit;
  161. typedef void   SOMLINK somTP_SOMDServer_somDestruct(SOMDServer *somSelf, 
  162.         octet doFree, 
  163.         som3DestructCtrl* ctrl);
  164. typedef somTP_SOMDServer_somDestruct *somTD_SOMDServer_somDestruct;
  165. typedef void   SOMLINK somTP_SOMDServer_somDefaultCopyInit(SOMDServer *somSelf, 
  166.         som3InitCtrl* ctrl, 
  167.         SOMObject* fromObj);
  168. typedef somTP_SOMDServer_somDefaultCopyInit *somTD_SOMDServer_somDefaultCopyInit;
  169. typedef SOMDServer*   SOMLINK somTP_SOMDServer_somDefaultAssign(SOMDServer *somSelf, 
  170.         som3AssignCtrl* ctrl, 
  171.         SOMObject* fromObj);
  172. typedef somTP_SOMDServer_somDefaultAssign *somTD_SOMDServer_somDefaultAssign;
  173. typedef void   SOMLINK somTP_SOMDServer_somDefaultConstCopyInit(SOMDServer *somSelf, 
  174.         som3InitCtrl* ctrl, 
  175.         SOMObject* fromObj);
  176. typedef somTP_SOMDServer_somDefaultConstCopyInit *somTD_SOMDServer_somDefaultConstCopyInit;
  177. typedef void   SOMLINK somTP_SOMDServer_somDefaultVCopyInit(SOMDServer *somSelf, 
  178.         som3InitCtrl* ctrl, 
  179.         SOMObject* fromObj);
  180. typedef somTP_SOMDServer_somDefaultVCopyInit *somTD_SOMDServer_somDefaultVCopyInit;
  181. typedef void   SOMLINK somTP_SOMDServer_somDefaultConstVCopyInit(SOMDServer *somSelf, 
  182.         som3InitCtrl* ctrl, 
  183.         SOMObject* fromObj);
  184. typedef somTP_SOMDServer_somDefaultConstVCopyInit *somTD_SOMDServer_somDefaultConstVCopyInit;
  185. typedef SOMDServer*   SOMLINK somTP_SOMDServer_somDefaultConstAssign(SOMDServer *somSelf, 
  186.         som3AssignCtrl* ctrl, 
  187.         SOMObject* fromObj);
  188. typedef somTP_SOMDServer_somDefaultConstAssign *somTD_SOMDServer_somDefaultConstAssign;
  189. typedef SOMDServer*   SOMLINK somTP_SOMDServer_somDefaultVAssign(SOMDServer *somSelf, 
  190.         som3AssignCtrl* ctrl, 
  191.         SOMObject* fromObj);
  192. typedef somTP_SOMDServer_somDefaultVAssign *somTD_SOMDServer_somDefaultVAssign;
  193. typedef SOMDServer*   SOMLINK somTP_SOMDServer_somDefaultConstVAssign(SOMDServer *somSelf, 
  194.         som3AssignCtrl* ctrl, 
  195.         SOMObject* fromObj);
  196. typedef somTP_SOMDServer_somDefaultConstVAssign *somTD_SOMDServer_somDefaultConstVAssign;
  197. typedef void   SOMLINK somTP_SOMDServer_somInit(SOMDServer *somSelf);
  198. typedef somTP_SOMDServer_somInit *somTD_SOMDServer_somInit;
  199. typedef void   SOMLINK somTP_SOMDServer_somFree(SOMDServer *somSelf);
  200. typedef somTP_SOMDServer_somFree *somTD_SOMDServer_somFree;
  201. typedef void   SOMLINK somTP_SOMDServer_somUninit(SOMDServer *somSelf);
  202. typedef somTP_SOMDServer_somUninit *somTD_SOMDServer_somUninit;
  203. typedef SOMMSingleInstance*   SOMLINK somTP_SOMDServer_somGetClass(SOMDServer *somSelf);
  204. typedef somTP_SOMDServer_somGetClass *somTD_SOMDServer_somGetClass;
  205. typedef string   SOMLINK somTP_SOMDServer_somGetClassName(SOMDServer *somSelf);
  206. typedef somTP_SOMDServer_somGetClassName *somTD_SOMDServer_somGetClassName;
  207. typedef long   SOMLINK somTP_SOMDServer_somGetSize(SOMDServer *somSelf);
  208. typedef somTP_SOMDServer_somGetSize *somTD_SOMDServer_somGetSize;
  209. typedef boolean   SOMLINK somTP_SOMDServer_somIsA(SOMDServer *somSelf, 
  210.         SOMClass* aClassObj);
  211. typedef somTP_SOMDServer_somIsA *somTD_SOMDServer_somIsA;
  212. typedef boolean   SOMLINK somTP_SOMDServer_somIsInstanceOf(SOMDServer *somSelf, 
  213.         SOMClass* aClassObj);
  214. typedef somTP_SOMDServer_somIsInstanceOf *somTD_SOMDServer_somIsInstanceOf;
  215. typedef boolean   SOMLINK somTP_SOMDServer_somRespondsTo(SOMDServer *somSelf, 
  216.         somId mId);
  217. typedef somTP_SOMDServer_somRespondsTo *somTD_SOMDServer_somRespondsTo;
  218. typedef boolean   SOMLINK somTP_SOMDServer_somDispatch(SOMDServer *somSelf, 
  219.         somToken* retValue, 
  220.         somId methodId, 
  221.         va_list ap);
  222. typedef somTP_SOMDServer_somDispatch *somTD_SOMDServer_somDispatch;
  223. typedef boolean   SOMLINK somTP_SOMDServer_somClassDispatch(SOMDServer *somSelf, 
  224.         SOMClass* clsObj, 
  225.         somToken* retValue, 
  226.         somId methodId, 
  227.         va_list ap);
  228. typedef somTP_SOMDServer_somClassDispatch *somTD_SOMDServer_somClassDispatch;
  229. typedef boolean   SOMLINK somTP_SOMDServer_somCastObj(SOMDServer *somSelf, 
  230.         SOMClass* cls);
  231. typedef somTP_SOMDServer_somCastObj *somTD_SOMDServer_somCastObj;
  232. typedef boolean   SOMLINK somTP_SOMDServer_somResetObj(SOMDServer *somSelf);
  233. typedef somTP_SOMDServer_somResetObj *somTD_SOMDServer_somResetObj;
  234. typedef void   SOMLINK somTP_SOMDServer_somDispatchV(SOMDServer *somSelf, 
  235.         somId methodId, 
  236.         somId descriptor, 
  237.         va_list ap);
  238. typedef somTP_SOMDServer_somDispatchV *somTD_SOMDServer_somDispatchV;
  239. typedef long   SOMLINK somTP_SOMDServer_somDispatchL(SOMDServer *somSelf, 
  240.         somId methodId, 
  241.         somId descriptor, 
  242.         va_list ap);
  243. typedef somTP_SOMDServer_somDispatchL *somTD_SOMDServer_somDispatchL;
  244. typedef void*   SOMLINK somTP_SOMDServer_somDispatchA(SOMDServer *somSelf, 
  245.         somId methodId, 
  246.         somId descriptor, 
  247.         va_list ap);
  248. typedef somTP_SOMDServer_somDispatchA *somTD_SOMDServer_somDispatchA;
  249. typedef double   SOMLINK somTP_SOMDServer_somDispatchD(SOMDServer *somSelf, 
  250.         somId methodId, 
  251.         somId descriptor, 
  252.         va_list ap);
  253. typedef somTP_SOMDServer_somDispatchD *somTD_SOMDServer_somDispatchD;
  254. typedef SOMObject*   SOMLINK somTP_SOMDServer_somPrintSelf(SOMDServer *somSelf);
  255. typedef somTP_SOMDServer_somPrintSelf *somTD_SOMDServer_somPrintSelf;
  256. typedef void   SOMLINK somTP_SOMDServer_somDumpSelf(SOMDServer *somSelf, 
  257.         long level);
  258. typedef somTP_SOMDServer_somDumpSelf *somTD_SOMDServer_somDumpSelf;
  259. typedef void   SOMLINK somTP_SOMDServer_somDumpSelfInt(SOMDServer *somSelf, 
  260.         long level);
  261. typedef somTP_SOMDServer_somDumpSelfInt *somTD_SOMDServer_somDumpSelfInt;
  262. }
  263.  
  264. #endif /* SOMDServer_API */
  265.  
  266.  
  267. /*
  268.  * -- This emitter treats Method Tokens as Thunks by default.
  269.  * -- Use the sc modifier "nothunks" to change this default
  270.  */
  271. #undef somresolve_
  272. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  273.  
  274. /*
  275.  * -- The C++ Wrapper Class for SOMDServer
  276.  */
  277. class SOMDServer : public SOMObject
  278. {
  279. public:
  280.  
  281. // SOMDServer::new creates the class object if necessary, and then uses somNewNoInit
  282. // to allocate memory and create the object. Initialization is in ctors.
  283. void *operator new(size_t)
  284. {
  285.    if (!_SOMDServer) SOMDServerNewClass(SOMDServer_MajorVersion,SOMDServer_MinorVersion);
  286.    return (void*)
  287.       SOM_Resolve(_SOMDServer,SOMClass,somNewNoInit)
  288.          ((SOMClass *)((void*)_SOMDServer));
  289. }
  290.  
  291. // SOMDServer::delete uses somDestruct.
  292. void operator delete(void * obj)
  293. {
  294.    if (obj && *(void**)obj) {
  295.       SOM_Resolve(obj,SOMObject,somFree)
  296.          ((SOMObject*)obj);
  297.    }
  298. }
  299.  
  300. SOMDServer& operator=(SOMDServer& fromObj)
  301. {
  302.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  303.    return *this;
  304. }
  305.  
  306. SOMDServer()
  307. {
  308.    if (*(void**)this != 
  309.        ((somParentMtabStructPtr)
  310.         (SOMDServerCClassData.parentMtab))->mtab)
  311.       return;
  312.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  313. }
  314.  
  315. SOMDServer(SOMDServer* fromObj)
  316. {
  317.    if (*(void**)this != 
  318.        ((somParentMtabStructPtr)
  319.         (SOMDServerCClassData.parentMtab))->mtab)
  320.       return;
  321.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  322. }
  323.  
  324. #ifdef __IBMCPP__
  325. #pragma info(nocnv,nopar)
  326. #endif
  327. SOMDServer(const SOMDServer* fromObj)
  328. {
  329.    if (*(void**)this != 
  330.        ((somParentMtabStructPtr)
  331.         (SOMDServerCClassData.parentMtab))->mtab)
  332.       return;
  333.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  334. }
  335. #ifdef __IBMCPP__
  336. #pragma info(restore)
  337. #endif
  338.  
  339.  
  340. /* method: somdRefFromSOMObj */
  341. SOMDObject*   somdRefFromSOMObj(Environment *ev, 
  342.         SOMObject* somobj)
  343. {
  344. /*
  345.  *  This method returns a DSOM object reference for a SOM object
  346.  *  instance in this server process.  SOMOA will call this method
  347.  *  whenever it returns a result from a method call which includes
  348.  *  a pointer to a SOMObject (versus a pointer to a SOMDObject).
  349.  *  Ownership of the returned object reference is given to the
  350.  *  caller EXCEPT when the somdObjReferencesCached method returns TRUE.
  351.  *  When the input (somobj) is already an object reference, the default
  352.  *  implementation simply returns somobj, rather than creating a new reference.
  353.  *  (Subclasses might override this method to duplicate the input reference, however.)
  354.  *  Hence, callers should note when the returned value is the same as
  355.  *  the input (somobj) when determining whether or not to free the result.
  356.  */
  357.    return SOM_ResolveD(this,SOMDServer,SOMDServer,somdRefFromSOMObj)
  358.     (this, ev,somobj);
  359. }
  360.  
  361.  
  362. /* method: somdSOMObjFromRef */
  363. SOMObject*   somdSOMObjFromRef(Environment *ev, 
  364.         SOMDObject* objref)
  365. {
  366. /*
  367.  *  This method maps a DSOM object reference into a SOM object.
  368.  *  This can be done in whatever way is appropriate for the application.
  369.  *  This method is called by SOMOA in order to translate any method call
  370.  *  parameters which are object references (created from somdRefFromSOMObj
  371.  *  above) into SOM objects.
  372.  */
  373.    return SOM_ResolveD(this,SOMDServer,SOMDServer,somdSOMObjFromRef)
  374.     (this, ev,objref);
  375. }
  376.  
  377.  
  378. /* va_list method: somdDispatchMethod */
  379.  
  380. /*
  381.  *  This method is called by SOMOA to dispatch a method on a SOM object.
  382.  *  The intention is to give the Server object an opportunity to intercept
  383.  *  method calls, if desired.  The parameters to this method are the same
  384.  *  as the parameters passed to SOMObject::somDispatch.
  385.  * 
  386.  *  The default implementation invokes SOMObject::somDispatch on the
  387.  *  specified target object, "somobj", with the supplied arguments.
  388.  */
  389. /* the va_list invocation form */
  390. void   SOMDServer_somdDispatchMethod(Environment *ev, 
  391.         SOMObject* somobj, 
  392.         somToken* retValue, 
  393.         somId methodId, 
  394.         va_list ap)
  395. {   SOM_ResolveD(this,SOMDServer,SOMDServer,somdDispatchMethod)
  396.     (this, ev,somobj,retValue,methodId,ap);
  397. }
  398.  
  399. /* the varargs invocation form */
  400. void   somdDispatchMethod(Environment *ev, 
  401.         SOMObject* somobj, 
  402.         somToken* retValue, 
  403.         somId methodId, 
  404.         ...)
  405. {
  406. /*
  407.  *  This method is called by SOMOA to dispatch a method on a SOM object.
  408.  *  The intention is to give the Server object an opportunity to intercept
  409.  *  method calls, if desired.  The parameters to this method are the same
  410.  *  as the parameters passed to SOMObject::somDispatch.
  411.  * 
  412.  *  The default implementation invokes SOMObject::somDispatch on the
  413.  *  specified target object, "somobj", with the supplied arguments.
  414.  */
  415.    va_list ap;
  416.    va_start(ap, methodId);
  417.    SOM_ResolveD(this,SOMDServer,SOMDServer,somdDispatchMethod)
  418.     (this, ev,somobj,retValue,methodId,ap);
  419.    va_end(ap);
  420. }
  421.  
  422.  
  423. /* method: somdCreateObj */
  424. SOMObject*   somdCreateObj(Environment *ev, 
  425.         Identifier objclass, 
  426.         string hints)
  427. {
  428. /*
  429.  *  Creates an object of the specified class.  This method (if overridden)
  430.  *  may optionally define creation "hints" which the client may specify in
  431.  *  this call.
  432.  * 
  433.  *  Called indirectly by SOMDObjectMgr::somdNewObject.
  434.  * 
  435.  *  The default implementation calls somdGetClassObj to get the specified
  436.  *  SOMClass object, and invokes "somNew".  The "hints" argument is ignored
  437.  *  in the default implementation.
  438.  */
  439.    return SOM_ResolveD(this,SOMDServer,SOMDServer,somdCreateObj)
  440.     (this, ev,objclass,hints);
  441. }
  442.  
  443.  
  444. /* method: somdDeleteObj */
  445. void   somdDeleteObj(Environment *ev, 
  446.         SOMObject* somobj)
  447. {
  448. /*
  449.  *  Deletes a SOM object.  By default, simply calls somFree on the object.
  450.  *  Can be overridden by the application.
  451.  * 
  452.  *  Called indirectly by SOMDObjectMgr::somdDestroyObject.
  453.  */
  454.    SOM_ResolveD(this,SOMDServer,SOMDServer,somdDeleteObj)
  455.     (this, ev,somobj);
  456. }
  457.  
  458.  
  459. /* method: somdGetClassObj */
  460. SOMClass*   somdGetClassObj(Environment *ev, 
  461.         Identifier objclass)
  462. {
  463. /*
  464.  *  Creates/returns a class object for the specified class.
  465.  *  (May result in the loading of a DLL for the class.)
  466.  */
  467.    return SOM_ResolveD(this,SOMDServer,SOMDServer,somdGetClassObj)
  468.     (this, ev,objclass);
  469. }
  470.  
  471.  
  472. /* method: somdObjReferencesCached */
  473. boolean   somdObjReferencesCached(Environment *ev)
  474. {
  475. /*
  476.  *  Whether the server retains ownership of the object references
  477.  *  it creates via the somdRefFromSOMObj method.
  478.  */
  479.    return SOM_ResolveD(this,SOMDServer,SOMDServer,somdObjReferencesCached)
  480.     (this, ev);
  481. }
  482.  
  483.  
  484. /*
  485.  * Reintroduce inherited methods
  486.  */
  487.  
  488. /* initializer method: somDefaultInit */
  489. void   somDefaultInit(som3InitCtrl* ctrl)
  490. {
  491. /*
  492.  *  A default initializer for a SOM object. Passing a null ctrl
  493.  *  indicates to the receiver that its class is the class of the
  494.  *  object being initialized, whereby the initializer will determine
  495.  *  an appropriate control structure.
  496.  */
  497.    SOM_ResolveD(this,SOMDServer,SOMObject,somDefaultInit)
  498.     (this,ctrl);
  499. }
  500.  
  501.  
  502. /* method: somDestruct */
  503. void   somDestruct(octet doFree, 
  504.         som3DestructCtrl* ctrl)
  505. {
  506. /*
  507.  *  The default destructor for a SOM object. A nonzero <doFree>
  508.  *  indicates that the object storage should be freed by the
  509.  *  object's class (via somDeallocate) after uninitialization.
  510.  *  As with somDefaultInit, a null ctrl can be passed.
  511.  */
  512.    SOM_ResolveD(this,SOMDServer,SOMObject,somDestruct)
  513.     (this,doFree,ctrl);
  514. }
  515.  
  516.  
  517. /* initializer method: somDefaultCopyInit */
  518. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  519.         SOMObject* fromObj)
  520. {
  521. /*
  522.  *  A default copy constructor. Use this to make copies of objects for
  523.  *  calling methods with "by-value" argument semantics.
  524.  */
  525.    SOM_ResolveD(this,SOMDServer,SOMObject,somDefaultCopyInit)
  526.     (this,ctrl,fromObj);
  527. }
  528.  
  529.  
  530. /* method: somDefaultAssign */
  531. SOMDServer*  somDefaultAssign(som3AssignCtrl* ctrl, 
  532.         SOMObject* fromObj)
  533. {
  534. /*
  535.  *  A default assignment operator. Use this to "assign" the state of one
  536.  *  object to another.
  537.  */
  538.    return SOM_ResolveD(this,SOMDServer,SOMObject,somDefaultAssign)
  539.     (this,ctrl,fromObj);
  540. }
  541.  
  542.  
  543. /* initializer method: somDefaultConstCopyInit */
  544. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  545.         SOMObject* fromObj)
  546. {
  547. /*
  548.  *  A default copy constructor that uses a const fromObj.
  549.  */
  550.    SOM_ResolveD(this,SOMDServer,SOMObject,somDefaultConstCopyInit)
  551.     (this,ctrl,fromObj);
  552. }
  553.  
  554.  
  555. /* initializer method: somDefaultVCopyInit */
  556. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  557.         SOMObject* fromObj)
  558. {
  559. /*
  560.  *  A default copy constructor that uses a volatile fromObj.
  561.  */
  562.    SOM_ResolveD(this,SOMDServer,SOMObject,somDefaultVCopyInit)
  563.     (this,ctrl,fromObj);
  564. }
  565.  
  566.  
  567. /* initializer method: somDefaultConstVCopyInit */
  568. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  569.         SOMObject* fromObj)
  570. {
  571. /*
  572.  *  A default copy constructor that uses a const volatile fromObj.
  573.  */
  574.    SOM_ResolveD(this,SOMDServer,SOMObject,somDefaultConstVCopyInit)
  575.     (this,ctrl,fromObj);
  576. }
  577.  
  578.  
  579. /* method: somDefaultConstAssign */
  580. SOMDServer*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  581.         SOMObject* fromObj)
  582. {
  583. /*
  584.  *  A default assignment operator that uses a const fromObj.
  585.  */
  586.    return SOM_ResolveD(this,SOMDServer,SOMObject,somDefaultConstAssign)
  587.     (this,ctrl,fromObj);
  588. }
  589.  
  590.  
  591. /* method: somDefaultVAssign */
  592. SOMDServer*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  593.         SOMObject* fromObj)
  594. {
  595. /*
  596.  *  A default assignment operator that uses a volatile fromObj.
  597.  */
  598.    return SOM_ResolveD(this,SOMDServer,SOMObject,somDefaultVAssign)
  599.     (this,ctrl,fromObj);
  600. }
  601.  
  602.  
  603. /* method: somDefaultConstVAssign */
  604. SOMDServer*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  605.         SOMObject* fromObj)
  606. {
  607. /*
  608.  *  A default assignment operator that uses a const volatile fromObj.
  609.  */
  610.    return SOM_ResolveD(this,SOMDServer,SOMObject,somDefaultConstVAssign)
  611.     (this,ctrl,fromObj);
  612. }
  613.  
  614.  
  615. /* method: somInit */
  616. void   somInit()
  617. {
  618. /*
  619.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  620.  */
  621.    SOM_ResolveD(this,SOMDServer,SOMObject,somInit)
  622.     (this);
  623. }
  624.  
  625.  
  626. /* method: somFree */
  627. void   somFree()
  628. {
  629. /*
  630.  *  Use as directed by framework implementations.
  631.  */
  632.    SOM_ResolveD(this,SOMDServer,SOMObject,somFree)
  633.     (this);
  634. }
  635.  
  636.  
  637. /* method: somUninit */
  638. void   somUninit()
  639. {
  640. /*
  641.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  642.  */
  643.    SOM_ResolveD(this,SOMDServer,SOMObject,somUninit)
  644.     (this);
  645. }
  646.  
  647.  
  648. /* method: somGetClass */
  649. SOMMSingleInstance*  somGetClass()
  650. {
  651. /*
  652.  *  Return the receiver's class.
  653.  */
  654.    return SOM_ResolveD(this,SOMDServer,SOMObject,somGetClass)
  655.     (this);
  656. }
  657.  
  658.  
  659. /* method: somGetClassName */
  660. string   somGetClassName()
  661. {
  662. /*
  663.  *  Return the name of the receiver's class.
  664.  */
  665.    return SOM_ResolveD(this,SOMDServer,SOMObject,somGetClassName)
  666.     (this);
  667. }
  668.  
  669.  
  670. /* method: somGetSize */
  671. long   somGetSize()
  672. {
  673. /*
  674.  *  Return the size of the receiver.
  675.  */
  676.    return SOM_ResolveD(this,SOMDServer,SOMObject,somGetSize)
  677.     (this);
  678. }
  679.  
  680.  
  681. /* method: somIsA */
  682. boolean   somIsA(SOMClass* aClassObj)
  683. {
  684. /*
  685.  *  Returns 1 (true) if the receiver responds to methods
  686.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  687.  */
  688.    return SOM_ResolveD(this,SOMDServer,SOMObject,somIsA)
  689.     (this,aClassObj);
  690. }
  691.  
  692.  
  693. /* method: somIsInstanceOf */
  694. boolean   somIsInstanceOf(SOMClass* aClassObj)
  695. {
  696. /*
  697.  *  Returns 1 (true) if the receiver is an instance of
  698.  *  <aClassObj> and 0 (false) otherwise.
  699.  */
  700.    return SOM_ResolveD(this,SOMDServer,SOMObject,somIsInstanceOf)
  701.     (this,aClassObj);
  702. }
  703.  
  704.  
  705. /* method: somRespondsTo */
  706. boolean   somRespondsTo(somId mId)
  707. {
  708. /*
  709.  *  Returns 1 (true) if the indicated method can be invoked
  710.  *  on the receiver and 0 (false) otherwise.
  711.  */
  712.    return SOM_ResolveD(this,SOMDServer,SOMObject,somRespondsTo)
  713.     (this,mId);
  714. }
  715.  
  716.  
  717. /* va_list method: somDispatch */
  718.  
  719. /*
  720.  *  This method provides a generic, class-specific dispatch mechanism.
  721.  *  It accepts as input <retValue> a pointer to the memory area to be
  722.  *  loaded with the result of dispatching the method indicated by
  723.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  724.  *  on which the method is to be invoked as the first argument.
  725.  */
  726. /* the va_list invocation form */
  727. boolean   SOMDServer_somDispatch(somToken* retValue, 
  728.         somId methodId, 
  729.         va_list ap)
  730. {return SOM_ResolveD(this,SOMDServer,SOMObject,somDispatch)
  731.     (this,retValue,methodId,ap);
  732. }
  733.  
  734. /* the varargs invocation form */
  735. boolean   somDispatch(somToken* retValue, 
  736.         somId methodId, 
  737.         ...)
  738. {
  739. /*
  740.  *  This method provides a generic, class-specific dispatch mechanism.
  741.  *  It accepts as input <retValue> a pointer to the memory area to be
  742.  *  loaded with the result of dispatching the method indicated by
  743.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  744.  *  on which the method is to be invoked as the first argument.
  745.  */
  746.    va_list ap;
  747.    va_start(ap, methodId);
  748.    boolean __somResult = 
  749.       SOM_ResolveD(this,SOMDServer,SOMObject,somDispatch)
  750.     (this,retValue,methodId,ap);
  751.    va_end(ap);
  752.    return __somResult;
  753. }
  754.  
  755.  
  756. /* va_list method: somClassDispatch */
  757.  
  758. /*
  759.  *  Like somDispatch, but method resolution for static methods is done
  760.  *  according to the clsObj instance method table.
  761.  */
  762. /* the va_list invocation form */
  763. boolean   SOMDServer_somClassDispatch(SOMClass* clsObj, 
  764.         somToken* retValue, 
  765.         somId methodId, 
  766.         va_list ap)
  767. {return SOM_ResolveD(this,SOMDServer,SOMObject,somClassDispatch)
  768.     (this,clsObj,retValue,methodId,ap);
  769. }
  770.  
  771. /* the varargs invocation form */
  772. boolean   somClassDispatch(SOMClass* clsObj, 
  773.         somToken* retValue, 
  774.         somId methodId, 
  775.         ...)
  776. {
  777. /*
  778.  *  Like somDispatch, but method resolution for static methods is done
  779.  *  according to the clsObj instance method table.
  780.  */
  781.    va_list ap;
  782.    va_start(ap, methodId);
  783.    boolean __somResult = 
  784.       SOM_ResolveD(this,SOMDServer,SOMObject,somClassDispatch)
  785.     (this,clsObj,retValue,methodId,ap);
  786.    va_end(ap);
  787.    return __somResult;
  788. }
  789.  
  790.  
  791. /* method: somCastObj */
  792. boolean   somCastObj(SOMClass* cls)
  793. {
  794. /*
  795.  *  cast the receiving object to cls (which must be an ancestor of the
  796.  *  objects true class. Returns true on success.
  797.  */
  798.    return SOM_ResolveD(this,SOMDServer,SOMObject,somCastObj)
  799.     (this,cls);
  800. }
  801.  
  802.  
  803. /* method: somResetObj */
  804. boolean   somResetObj()
  805. {
  806. /*
  807.  *  reset an object to its true class. Returns true always.
  808.  */
  809.    return SOM_ResolveD(this,SOMDServer,SOMObject,somResetObj)
  810.     (this);
  811. }
  812.  
  813.  
  814. /* va_list method: somDispatchV */
  815.  
  816. /*
  817.  *  Obsolete. Use somDispatch instead.
  818.  */
  819. /* the va_list invocation form */
  820. void   SOMDServer_somDispatchV(somId methodId, 
  821.         somId descriptor, 
  822.         va_list ap)
  823. {   SOM_ResolveD(this,SOMDServer,SOMObject,somDispatchV)
  824.     (this,methodId,descriptor,ap);
  825. }
  826.  
  827. /* the varargs invocation form */
  828. void   somDispatchV(somId methodId, 
  829.         somId descriptor, 
  830.         ...)
  831. {
  832. /*
  833.  *  Obsolete. Use somDispatch instead.
  834.  */
  835.    va_list ap;
  836.    va_start(ap, descriptor);
  837.    SOM_ResolveD(this,SOMDServer,SOMObject,somDispatchV)
  838.     (this,methodId,descriptor,ap);
  839.    va_end(ap);
  840. }
  841.  
  842.  
  843. /* va_list method: somDispatchL */
  844.  
  845. /*
  846.  *  Obsolete. Use somDispatch instead.
  847.  */
  848. /* the va_list invocation form */
  849. long   SOMDServer_somDispatchL(somId methodId, 
  850.         somId descriptor, 
  851.         va_list ap)
  852. {return SOM_ResolveD(this,SOMDServer,SOMObject,somDispatchL)
  853.     (this,methodId,descriptor,ap);
  854. }
  855.  
  856. /* the varargs invocation form */
  857. long   somDispatchL(somId methodId, 
  858.         somId descriptor, 
  859.         ...)
  860. {
  861. /*
  862.  *  Obsolete. Use somDispatch instead.
  863.  */
  864.    va_list ap;
  865.    va_start(ap, descriptor);
  866.    long __somResult = 
  867.       SOM_ResolveD(this,SOMDServer,SOMObject,somDispatchL)
  868.     (this,methodId,descriptor,ap);
  869.    va_end(ap);
  870.    return __somResult;
  871. }
  872.  
  873.  
  874. /* va_list method: somDispatchA */
  875.  
  876. /*
  877.  *  Obsolete. Use somDispatch instead.
  878.  */
  879. /* the va_list invocation form */
  880. void*   SOMDServer_somDispatchA(somId methodId, 
  881.         somId descriptor, 
  882.         va_list ap)
  883. {return SOM_ResolveD(this,SOMDServer,SOMObject,somDispatchA)
  884.     (this,methodId,descriptor,ap);
  885. }
  886.  
  887. /* the varargs invocation form */
  888. void*   somDispatchA(somId methodId, 
  889.         somId descriptor, 
  890.         ...)
  891. {
  892. /*
  893.  *  Obsolete. Use somDispatch instead.
  894.  */
  895.    va_list ap;
  896.    va_start(ap, descriptor);
  897.    void* __somResult = 
  898.       SOM_ResolveD(this,SOMDServer,SOMObject,somDispatchA)
  899.     (this,methodId,descriptor,ap);
  900.    va_end(ap);
  901.    return __somResult;
  902. }
  903.  
  904.  
  905. /* va_list method: somDispatchD */
  906.  
  907. /*
  908.  *  Obsolete. Use somDispatch instead.
  909.  */
  910. /* the va_list invocation form */
  911. double   SOMDServer_somDispatchD(somId methodId, 
  912.         somId descriptor, 
  913.         va_list ap)
  914. {return SOM_ResolveD(this,SOMDServer,SOMObject,somDispatchD)
  915.     (this,methodId,descriptor,ap);
  916. }
  917.  
  918. /* the varargs invocation form */
  919. double   somDispatchD(somId methodId, 
  920.         somId descriptor, 
  921.         ...)
  922. {
  923. /*
  924.  *  Obsolete. Use somDispatch instead.
  925.  */
  926.    va_list ap;
  927.    va_start(ap, descriptor);
  928.    double __somResult = 
  929.       SOM_ResolveD(this,SOMDServer,SOMObject,somDispatchD)
  930.     (this,methodId,descriptor,ap);
  931.    va_end(ap);
  932.    return __somResult;
  933. }
  934.  
  935.  
  936. /* method: somPrintSelf */
  937. SOMObject*   somPrintSelf()
  938. {
  939. /*
  940.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  941.  *  information about this object.  The default implementation just gives
  942.  *  the object's class name and its address in memory.
  943.  *  <self> is returned.
  944.  */
  945.    return SOM_ResolveD(this,SOMDServer,SOMObject,somPrintSelf)
  946.     (this);
  947. }
  948.  
  949.  
  950. /* method: somDumpSelf */
  951. void   somDumpSelf(long level)
  952. {
  953. /*
  954.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  955.  *  and its current state.
  956.  * 
  957.  *  <level> indicates the nesting level for describing compound objects
  958.  *  it must be greater than or equal to zero.  All lines in the
  959.  *  description will be preceeded by <2*level> spaces.
  960.  * 
  961.  *  This routine only actually writes the data that concerns the object
  962.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  963.  *  the object's current state.  This approach allows readable
  964.  *  descriptions of compound objects to be constructed.
  965.  * 
  966.  *  Generally it is not necessary to override this method, if it is
  967.  *  overriden it generally must be completely replaced.
  968.  */
  969.    SOM_ResolveD(this,SOMDServer,SOMObject,somDumpSelf)
  970.     (this,level);
  971. }
  972.  
  973.  
  974. /* method: somDumpSelfInt */
  975. void   somDumpSelfInt(long level)
  976. {
  977. /*
  978.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  979.  *  Generally this method will need to be overridden.  When overriding
  980.  *  it, begin by calling the parent class form of this method and then
  981.  *  write in a description of your class's instance data. This will
  982.  *  result in a description of all the object's instance data going
  983.  *  from its root ancestor class to its specific class.
  984.  */
  985.    SOM_ResolveD(this,SOMDServer,SOMObject,somDumpSelfInt)
  986.     (this,level);
  987. }
  988.  
  989.  
  990.  
  991. };   /* SOMDServer */
  992.  
  993.  
  994.  
  995. #endif       /* SOM_SOMDServer_xh */
  996.