home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / somdobj.xh < prev    next >
Text File  |  1999-02-22  |  29KB  |  986 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: somdobj.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.17
  7.  *     SOM Emitter emitxh: 2.47
  8.  */
  9.  
  10. /*
  11.  *    Interface for CORBA Object Reference.
  12.  * 
  13.  *    This is the class that implements the behavior of CORBA object references,
  14.  *    e.g., get_implementation, get_interface, duplicate, release, etc.
  15.  * 
  16.  *    In addition, there are some private methods, which are exposed only to
  17.  *    the ORB classes, to implement the ORB functions related to object
  18.  *    references (e.g., ORB_object_to_string).
  19.  * 
  20.  *    In DSOM, there is also another derivation of this class:  SOMDClientProxy.
  21.  *    This subclass inherits the implementation of this class, but extends it
  22.  *    by overriding somDispatch with a "remote dispatch" method, and caches the
  23.  *    binding to the server process.  Whenever a remote object is accessed, it
  24.  *    is represented in the client process by a SOMDClientProxy object.
  25.  * 
  26.  * 
  27.  */
  28.  
  29.  
  30. #ifndef SOM_SOMDObject_xh
  31. #define SOM_SOMDObject_xh
  32.  
  33. class SOMDObject;
  34.  
  35. #define SOMDObject_MajorVersion 2
  36. #define SOMDObject_MinorVersion 1
  37.  
  38. /*
  39.  * Passthru lines: File: "C.xh", "before"
  40.  */
  41.  
  42. #include <somdtype.xh>
  43.  
  44.  
  45. /* C++ SOM defs */
  46. #include <somcls.xh>
  47. #include <somcm.xh>
  48.  
  49. /* C++ parent defs */
  50. #ifndef SOM_SOMObject_xh
  51. #include <somobj.xh>
  52. #endif
  53.  
  54. #ifndef SOMDObject_API
  55. #define SOMDObject_API
  56. /*
  57.  * -- The Class API
  58.  */
  59.  
  60. /*
  61.  * Start of bindings for IDL types
  62.  */
  63.  
  64. class SOMClass;
  65. class SOMObject;
  66. class Container;
  67. class ImplementationDef;
  68. class InterfaceDef;
  69. class NVList;
  70. class Context;
  71. class Request;
  72.  
  73. /*
  74.  * End of bindings for IDL types.
  75.  */
  76.  
  77. /* A procedure to create the SOMDObject Class */
  78. SOMEXTERN SOMClass * SOMLINK SOMDObjectNewClass(
  79.         integer4 majorVersion,
  80.         integer4 minorVersion);
  81.  
  82. /* The API to the SOMDObject class object, and the methods it introduces. */
  83. SOMEXTERN struct SOMDObjectClassDataStructure {
  84.     SOMClass *classObject;
  85.     somMToken get_implementation;
  86.     somMToken get_interface;
  87.     somMToken set_to_nil;
  88.     somMethodProc *is_nil;
  89.     somMToken is_SOM_ref;
  90.     somMToken is_constant;
  91.     somMToken is_proxy;
  92.     somMToken duplicate;
  93.     somMToken release;
  94.     somMToken create_request;
  95.     somMToken create_request_args;
  96.     somMToken _get_somd_tag;
  97.     somMToken _get_somd_flags;
  98.     somMToken _set_somd_flags;
  99.     somMToken _get_somd_impl;
  100.     somMToken _set_somd_impl;
  101.     somMToken _get_somd_rid;
  102.     somMToken _set_somd_rid;
  103.     somMToken _get_somd_id;
  104.     somMToken _set_somd_id;
  105. } SOMDLINK SOMDObjectClassData;
  106. #define _SOMDObject SOMDObjectClassData.classObject
  107.  
  108. /* The API to parentMtabs for SOMDObject, and the instance data it introduces. */
  109. SOMEXTERN struct SOMDObjectCClassDataStructure {
  110.     somMethodTabs parentMtab;
  111.     somDToken              instanceDataToken;
  112. } SOMDLINK SOMDObjectCClassData;
  113.  
  114. /*
  115.  * -- Typedefs for SOMDObject Method Procedures
  116.  */
  117. SOMEXTERN {
  118. typedef ImplementationDef*   SOMLINK somTP_SOMDObject_get_implementation(SOMDObject *somSelf, Environment *ev);
  119. typedef somTP_SOMDObject_get_implementation *somTD_SOMDObject_get_implementation;
  120. typedef InterfaceDef*   SOMLINK somTP_SOMDObject_get_interface(SOMDObject *somSelf, Environment *ev);
  121. typedef somTP_SOMDObject_get_interface *somTD_SOMDObject_get_interface;
  122. typedef boolean   SOMLINK somTP_SOMDObject_is_nil(SOMDObject *somSelf, Environment *ev);
  123. typedef somTP_SOMDObject_is_nil *somTD_SOMDObject_is_nil;
  124. typedef boolean   SOMLINK somTP_SOMDObject_is_SOM_ref(SOMDObject *somSelf, Environment *ev);
  125. typedef somTP_SOMDObject_is_SOM_ref *somTD_SOMDObject_is_SOM_ref;
  126. typedef boolean   SOMLINK somTP_SOMDObject_is_constant(SOMDObject *somSelf, Environment *ev);
  127. typedef somTP_SOMDObject_is_constant *somTD_SOMDObject_is_constant;
  128. typedef boolean   SOMLINK somTP_SOMDObject_is_proxy(SOMDObject *somSelf, Environment *ev);
  129. typedef somTP_SOMDObject_is_proxy *somTD_SOMDObject_is_proxy;
  130. typedef SOMDObject*   SOMLINK somTP_SOMDObject_duplicate(SOMDObject *somSelf, Environment *ev);
  131. typedef somTP_SOMDObject_duplicate *somTD_SOMDObject_duplicate;
  132. typedef void   SOMLINK somTP_SOMDObject_release(SOMDObject *somSelf, Environment *ev);
  133. typedef somTP_SOMDObject_release *somTD_SOMDObject_release;
  134. typedef ORBStatus   SOMLINK somTP_SOMDObject_create_request(SOMDObject *somSelf, Environment *ev, 
  135.         Context* ctx, 
  136.         Identifier operation, 
  137.         NVList* arg_list, 
  138.         NamedValue* result, 
  139.         Request** request, 
  140.         Flags req_flags);
  141. typedef somTP_SOMDObject_create_request *somTD_SOMDObject_create_request;
  142. typedef ORBStatus   SOMLINK somTP_SOMDObject_create_request_args(SOMDObject *somSelf, Environment *ev, 
  143.         Identifier operation, 
  144.         NVList** arg_list, 
  145.         NamedValue* result);
  146. typedef somTP_SOMDObject_create_request_args *somTD_SOMDObject_create_request_args;
  147.  
  148. /*
  149.  * -- Typedefs for Reintroduced Wrapper Methods
  150.  */
  151. typedef void   SOMLINK somTP_SOMDObject_somDefaultInit(SOMDObject *somSelf, 
  152.         som3InitCtrl* ctrl);
  153. typedef somTP_SOMDObject_somDefaultInit *somTD_SOMDObject_somDefaultInit;
  154. typedef void   SOMLINK somTP_SOMDObject_somDestruct(SOMDObject *somSelf, 
  155.         octet doFree, 
  156.         som3DestructCtrl* ctrl);
  157. typedef somTP_SOMDObject_somDestruct *somTD_SOMDObject_somDestruct;
  158. typedef void   SOMLINK somTP_SOMDObject_somDefaultCopyInit(SOMDObject *somSelf, 
  159.         som3InitCtrl* ctrl, 
  160.         SOMObject* fromObj);
  161. typedef somTP_SOMDObject_somDefaultCopyInit *somTD_SOMDObject_somDefaultCopyInit;
  162. typedef SOMDObject*   SOMLINK somTP_SOMDObject_somDefaultAssign(SOMDObject *somSelf, 
  163.         som3AssignCtrl* ctrl, 
  164.         SOMObject* fromObj);
  165. typedef somTP_SOMDObject_somDefaultAssign *somTD_SOMDObject_somDefaultAssign;
  166. typedef void   SOMLINK somTP_SOMDObject_somDefaultConstCopyInit(SOMDObject *somSelf, 
  167.         som3InitCtrl* ctrl, 
  168.         SOMObject* fromObj);
  169. typedef somTP_SOMDObject_somDefaultConstCopyInit *somTD_SOMDObject_somDefaultConstCopyInit;
  170. typedef void   SOMLINK somTP_SOMDObject_somDefaultVCopyInit(SOMDObject *somSelf, 
  171.         som3InitCtrl* ctrl, 
  172.         SOMObject* fromObj);
  173. typedef somTP_SOMDObject_somDefaultVCopyInit *somTD_SOMDObject_somDefaultVCopyInit;
  174. typedef void   SOMLINK somTP_SOMDObject_somDefaultConstVCopyInit(SOMDObject *somSelf, 
  175.         som3InitCtrl* ctrl, 
  176.         SOMObject* fromObj);
  177. typedef somTP_SOMDObject_somDefaultConstVCopyInit *somTD_SOMDObject_somDefaultConstVCopyInit;
  178. typedef SOMDObject*   SOMLINK somTP_SOMDObject_somDefaultConstAssign(SOMDObject *somSelf, 
  179.         som3AssignCtrl* ctrl, 
  180.         SOMObject* fromObj);
  181. typedef somTP_SOMDObject_somDefaultConstAssign *somTD_SOMDObject_somDefaultConstAssign;
  182. typedef SOMDObject*   SOMLINK somTP_SOMDObject_somDefaultVAssign(SOMDObject *somSelf, 
  183.         som3AssignCtrl* ctrl, 
  184.         SOMObject* fromObj);
  185. typedef somTP_SOMDObject_somDefaultVAssign *somTD_SOMDObject_somDefaultVAssign;
  186. typedef SOMDObject*   SOMLINK somTP_SOMDObject_somDefaultConstVAssign(SOMDObject *somSelf, 
  187.         som3AssignCtrl* ctrl, 
  188.         SOMObject* fromObj);
  189. typedef somTP_SOMDObject_somDefaultConstVAssign *somTD_SOMDObject_somDefaultConstVAssign;
  190. typedef void   SOMLINK somTP_SOMDObject_somInit(SOMDObject *somSelf);
  191. typedef somTP_SOMDObject_somInit *somTD_SOMDObject_somInit;
  192. typedef void   SOMLINK somTP_SOMDObject_somFree(SOMDObject *somSelf);
  193. typedef somTP_SOMDObject_somFree *somTD_SOMDObject_somFree;
  194. typedef void   SOMLINK somTP_SOMDObject_somUninit(SOMDObject *somSelf);
  195. typedef somTP_SOMDObject_somUninit *somTD_SOMDObject_somUninit;
  196. typedef SOMClass*   SOMLINK somTP_SOMDObject_somGetClass(SOMDObject *somSelf);
  197. typedef somTP_SOMDObject_somGetClass *somTD_SOMDObject_somGetClass;
  198. typedef string   SOMLINK somTP_SOMDObject_somGetClassName(SOMDObject *somSelf);
  199. typedef somTP_SOMDObject_somGetClassName *somTD_SOMDObject_somGetClassName;
  200. typedef long   SOMLINK somTP_SOMDObject_somGetSize(SOMDObject *somSelf);
  201. typedef somTP_SOMDObject_somGetSize *somTD_SOMDObject_somGetSize;
  202. typedef boolean   SOMLINK somTP_SOMDObject_somIsA(SOMDObject *somSelf, 
  203.         SOMClass* aClassObj);
  204. typedef somTP_SOMDObject_somIsA *somTD_SOMDObject_somIsA;
  205. typedef boolean   SOMLINK somTP_SOMDObject_somIsInstanceOf(SOMDObject *somSelf, 
  206.         SOMClass* aClassObj);
  207. typedef somTP_SOMDObject_somIsInstanceOf *somTD_SOMDObject_somIsInstanceOf;
  208. typedef boolean   SOMLINK somTP_SOMDObject_somRespondsTo(SOMDObject *somSelf, 
  209.         somId mId);
  210. typedef somTP_SOMDObject_somRespondsTo *somTD_SOMDObject_somRespondsTo;
  211. typedef boolean   SOMLINK somTP_SOMDObject_somDispatch(SOMDObject *somSelf, 
  212.         somToken* retValue, 
  213.         somId methodId, 
  214.         va_list ap);
  215. typedef somTP_SOMDObject_somDispatch *somTD_SOMDObject_somDispatch;
  216. typedef boolean   SOMLINK somTP_SOMDObject_somClassDispatch(SOMDObject *somSelf, 
  217.         SOMClass* clsObj, 
  218.         somToken* retValue, 
  219.         somId methodId, 
  220.         va_list ap);
  221. typedef somTP_SOMDObject_somClassDispatch *somTD_SOMDObject_somClassDispatch;
  222. typedef boolean   SOMLINK somTP_SOMDObject_somCastObj(SOMDObject *somSelf, 
  223.         SOMClass* cls);
  224. typedef somTP_SOMDObject_somCastObj *somTD_SOMDObject_somCastObj;
  225. typedef boolean   SOMLINK somTP_SOMDObject_somResetObj(SOMDObject *somSelf);
  226. typedef somTP_SOMDObject_somResetObj *somTD_SOMDObject_somResetObj;
  227. typedef void   SOMLINK somTP_SOMDObject_somDispatchV(SOMDObject *somSelf, 
  228.         somId methodId, 
  229.         somId descriptor, 
  230.         va_list ap);
  231. typedef somTP_SOMDObject_somDispatchV *somTD_SOMDObject_somDispatchV;
  232. typedef long   SOMLINK somTP_SOMDObject_somDispatchL(SOMDObject *somSelf, 
  233.         somId methodId, 
  234.         somId descriptor, 
  235.         va_list ap);
  236. typedef somTP_SOMDObject_somDispatchL *somTD_SOMDObject_somDispatchL;
  237. typedef void*   SOMLINK somTP_SOMDObject_somDispatchA(SOMDObject *somSelf, 
  238.         somId methodId, 
  239.         somId descriptor, 
  240.         va_list ap);
  241. typedef somTP_SOMDObject_somDispatchA *somTD_SOMDObject_somDispatchA;
  242. typedef double   SOMLINK somTP_SOMDObject_somDispatchD(SOMDObject *somSelf, 
  243.         somId methodId, 
  244.         somId descriptor, 
  245.         va_list ap);
  246. typedef somTP_SOMDObject_somDispatchD *somTD_SOMDObject_somDispatchD;
  247. typedef SOMObject*   SOMLINK somTP_SOMDObject_somPrintSelf(SOMDObject *somSelf);
  248. typedef somTP_SOMDObject_somPrintSelf *somTD_SOMDObject_somPrintSelf;
  249. typedef void   SOMLINK somTP_SOMDObject_somDumpSelf(SOMDObject *somSelf, 
  250.         long level);
  251. typedef somTP_SOMDObject_somDumpSelf *somTD_SOMDObject_somDumpSelf;
  252. typedef void   SOMLINK somTP_SOMDObject_somDumpSelfInt(SOMDObject *somSelf, 
  253.         long level);
  254. typedef somTP_SOMDObject_somDumpSelfInt *somTD_SOMDObject_somDumpSelfInt;
  255. }
  256.  
  257. #endif /* SOMDObject_API */
  258.  
  259.  
  260. /*
  261.  * -- This emitter treats Method Tokens as Thunks by default.
  262.  * -- Use the sc modifier "nothunks" to change this default
  263.  */
  264. #undef somresolve_
  265. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  266.  
  267. /*
  268.  * -- The C++ Wrapper Class for SOMDObject
  269.  */
  270. class SOMDObject : public SOMObject
  271. {
  272. public:
  273.  
  274. // SOMDObject::new creates the class object if necessary, and then uses somNewNoInit
  275. // to allocate memory and create the object. Initialization is in ctors.
  276. void *operator new(size_t)
  277. {
  278.    if (!_SOMDObject) SOMDObjectNewClass(SOMDObject_MajorVersion,SOMDObject_MinorVersion);
  279.    return (void*)
  280.       SOM_Resolve(_SOMDObject,SOMClass,somNewNoInit)
  281.          ((SOMClass *)((void*)_SOMDObject));
  282. }
  283.  
  284. // SOMDObject::delete uses somDestruct.
  285. void operator delete(void * obj)
  286. {
  287.    if (obj && *(void**)obj) {
  288.       SOM_Resolve(obj,SOMObject,somFree)
  289.          ((SOMObject*)obj);
  290.    }
  291. }
  292.  
  293. SOMDObject& operator=(SOMDObject& fromObj)
  294. {
  295.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  296.    return *this;
  297. }
  298.  
  299. SOMDObject()
  300. {
  301.    if (*(void**)this != 
  302.        ((somParentMtabStructPtr)
  303.         (SOMDObjectCClassData.parentMtab))->mtab)
  304.       return;
  305.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  306. }
  307.  
  308. SOMDObject(SOMDObject* fromObj)
  309. {
  310.    if (*(void**)this != 
  311.        ((somParentMtabStructPtr)
  312.         (SOMDObjectCClassData.parentMtab))->mtab)
  313.       return;
  314.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  315. }
  316.  
  317. #ifdef __IBMCPP__
  318. #pragma info(nocnv,nopar)
  319. #endif
  320. SOMDObject(const SOMDObject* fromObj)
  321. {
  322.    if (*(void**)this != 
  323.        ((somParentMtabStructPtr)
  324.         (SOMDObjectCClassData.parentMtab))->mtab)
  325.       return;
  326.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  327. }
  328. #ifdef __IBMCPP__
  329. #pragma info(restore)
  330. #endif
  331.  
  332.  
  333. /* method: get_implementation */
  334. ImplementationDef*   get_implementation(Environment *ev)
  335. {
  336. /*
  337.  *  Returns the implementation definition for the referenced object.
  338.  */
  339.    return SOM_ResolveD(this,SOMDObject,SOMDObject,get_implementation)
  340.     (this, ev);
  341. }
  342.  
  343.  
  344. /* method: get_interface */
  345. InterfaceDef*   get_interface(Environment *ev)
  346. {
  347. /*
  348.  *  Returns the interface definition for the referenced object.
  349.  */
  350.    return SOM_ResolveD(this,SOMDObject,SOMDObject,get_interface)
  351.     (this, ev);
  352. }
  353.  
  354.  
  355. /* procedure: is_nil */
  356. static boolean   is_nil(SOMDObject *somSelf, Environment *ev)
  357. {
  358. /*
  359.  *  Tests to see if the object reference is nil.
  360.  *  This is a procedure method.  Therefore, it can be invoked on OBJECT_NIL
  361.  *  (a null pointer), but it cannot be overridden.
  362.  */
  363.    return ((somTD_SOMDObject_is_nil)SOMDObjectClassData.is_nil)
  364.     (somSelf, ev);
  365. }
  366.  
  367.  
  368. /* method: is_SOM_ref */
  369. boolean   is_SOM_ref(Environment *ev)
  370. {
  371. /*
  372.  *  Returns TRUE if object reference was created by SOMOA::create_SOM_ref
  373.  *  else returns FALSE.
  374.  */
  375.    return SOM_ResolveD(this,SOMDObject,SOMDObject,is_SOM_ref)
  376.     (this, ev);
  377. }
  378.  
  379.  
  380. /* method: is_constant */
  381. boolean   is_constant(Environment *ev)
  382. {
  383. /*
  384.  *  Returns TRUE if object reference was created by SOMOA::create_constant
  385.  *  else returns FALSE.
  386.  */
  387.    return SOM_ResolveD(this,SOMDObject,SOMDObject,is_constant)
  388.     (this, ev);
  389. }
  390.  
  391.  
  392. /* method: is_proxy */
  393. boolean   is_proxy(Environment *ev)
  394. {
  395. /*
  396.  *  Returns TRUE if object reference (self) is a DSOM client proxy object
  397.  *  (i.e., the target object is remote).  Returns FALSE if the referenced
  398.  *  object is in the same process as the reference.
  399.  * 
  400.  *  The default implementation returns FALSE.  Proxy classes which are
  401.  *  subclasses of SOMDObject (like SOMDClientProxy) should override this
  402.  *  method to return TRUE.
  403.  */
  404.    return SOM_ResolveD(this,SOMDObject,SOMDObject,is_proxy)
  405.     (this, ev);
  406. }
  407.  
  408.  
  409. /* method: duplicate */
  410. SOMDObject*   duplicate(Environment *ev)
  411. {
  412. /*
  413.  *  Makes a duplicate of the object reference.
  414.  *  OWNERSHIP of returned object is transferred to the caller.
  415.  *  Call release to free the object.
  416.  */
  417.    return SOM_ResolveD(this,SOMDObject,SOMDObject,duplicate)
  418.     (this, ev);
  419. }
  420.  
  421.  
  422. /* method: release */
  423. void   release(Environment *ev)
  424. {
  425. /*
  426.  *  Releases the memory associated with the object reference.
  427.  */
  428.    SOM_ResolveD(this,SOMDObject,SOMDObject,release)
  429.     (this, ev);
  430. }
  431.  
  432.  
  433. /* method: create_request */
  434. ORBStatus   create_request(Environment *ev, 
  435.         Context* ctx, 
  436.         Identifier operation, 
  437.         NVList* arg_list, 
  438.         NamedValue* result, 
  439.         Request** request, 
  440.         Flags req_flags)
  441. {
  442. /*
  443.  *  Creates a request to execute a particular operation on the
  444.  *  referenced object.
  445.  * 
  446.  *  CORBA 1.1 introduces this method in this class, but DSOM actually
  447.  *  implements this method in the SOMDClientProxy subclass.
  448.  */
  449.    return SOM_ResolveD(this,SOMDObject,SOMDObject,create_request)
  450.     (this, ev,ctx,operation,arg_list,result,request,req_flags);
  451. }
  452.  
  453.  
  454. /* method: create_request_args */
  455. ORBStatus   create_request_args(Environment *ev, 
  456.         Identifier operation, 
  457.         NVList** arg_list, 
  458.         NamedValue* result)
  459. {
  460. /*
  461.  *  Creates the appropriate arg_list (NVList) for the specified operation.
  462.  *  Also creates a NamedValue to hold the result.
  463.  *  (Similar in function to ORB_create_operation_list.)
  464.  * 
  465.  *  This method is defined in this class, as a companion to the
  466.  *  "create_request" method, but DSOM implements this method in the
  467.  *  SOMDClientProxy subclass.
  468.  */
  469.    return SOM_ResolveD(this,SOMDObject,SOMDObject,create_request_args)
  470.     (this, ev,operation,arg_list,result);
  471. }
  472.  
  473.  
  474. /*
  475.  * Reintroduce inherited methods
  476.  */
  477.  
  478. /* initializer method: somDefaultInit */
  479. void   somDefaultInit(som3InitCtrl* ctrl)
  480. {
  481. /*
  482.  *  A default initializer for a SOM object. Passing a null ctrl
  483.  *  indicates to the receiver that its class is the class of the
  484.  *  object being initialized, whereby the initializer will determine
  485.  *  an appropriate control structure.
  486.  */
  487.    SOM_ResolveD(this,SOMDObject,SOMObject,somDefaultInit)
  488.     (this,ctrl);
  489. }
  490.  
  491.  
  492. /* method: somDestruct */
  493. void   somDestruct(octet doFree, 
  494.         som3DestructCtrl* ctrl)
  495. {
  496. /*
  497.  *  The default destructor for a SOM object. A nonzero <doFree>
  498.  *  indicates that the object storage should be freed by the
  499.  *  object's class (via somDeallocate) after uninitialization.
  500.  *  As with somDefaultInit, a null ctrl can be passed.
  501.  */
  502.    SOM_ResolveD(this,SOMDObject,SOMObject,somDestruct)
  503.     (this,doFree,ctrl);
  504. }
  505.  
  506.  
  507. /* initializer method: somDefaultCopyInit */
  508. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  509.         SOMObject* fromObj)
  510. {
  511. /*
  512.  *  A default copy constructor. Use this to make copies of objects for
  513.  *  calling methods with "by-value" argument semantics.
  514.  */
  515.    SOM_ResolveD(this,SOMDObject,SOMObject,somDefaultCopyInit)
  516.     (this,ctrl,fromObj);
  517. }
  518.  
  519.  
  520. /* method: somDefaultAssign */
  521. SOMDObject*  somDefaultAssign(som3AssignCtrl* ctrl, 
  522.         SOMObject* fromObj)
  523. {
  524. /*
  525.  *  A default assignment operator. Use this to "assign" the state of one
  526.  *  object to another.
  527.  */
  528.    return SOM_ResolveD(this,SOMDObject,SOMObject,somDefaultAssign)
  529.     (this,ctrl,fromObj);
  530. }
  531.  
  532.  
  533. /* initializer method: somDefaultConstCopyInit */
  534. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  535.         SOMObject* fromObj)
  536. {
  537. /*
  538.  *  A default copy constructor that uses a const fromObj.
  539.  */
  540.    SOM_ResolveD(this,SOMDObject,SOMObject,somDefaultConstCopyInit)
  541.     (this,ctrl,fromObj);
  542. }
  543.  
  544.  
  545. /* initializer method: somDefaultVCopyInit */
  546. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  547.         SOMObject* fromObj)
  548. {
  549. /*
  550.  *  A default copy constructor that uses a volatile fromObj.
  551.  */
  552.    SOM_ResolveD(this,SOMDObject,SOMObject,somDefaultVCopyInit)
  553.     (this,ctrl,fromObj);
  554. }
  555.  
  556.  
  557. /* initializer method: somDefaultConstVCopyInit */
  558. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  559.         SOMObject* fromObj)
  560. {
  561. /*
  562.  *  A default copy constructor that uses a const volatile fromObj.
  563.  */
  564.    SOM_ResolveD(this,SOMDObject,SOMObject,somDefaultConstVCopyInit)
  565.     (this,ctrl,fromObj);
  566. }
  567.  
  568.  
  569. /* method: somDefaultConstAssign */
  570. SOMDObject*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  571.         SOMObject* fromObj)
  572. {
  573. /*
  574.  *  A default assignment operator that uses a const fromObj.
  575.  */
  576.    return SOM_ResolveD(this,SOMDObject,SOMObject,somDefaultConstAssign)
  577.     (this,ctrl,fromObj);
  578. }
  579.  
  580.  
  581. /* method: somDefaultVAssign */
  582. SOMDObject*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  583.         SOMObject* fromObj)
  584. {
  585. /*
  586.  *  A default assignment operator that uses a volatile fromObj.
  587.  */
  588.    return SOM_ResolveD(this,SOMDObject,SOMObject,somDefaultVAssign)
  589.     (this,ctrl,fromObj);
  590. }
  591.  
  592.  
  593. /* method: somDefaultConstVAssign */
  594. SOMDObject*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  595.         SOMObject* fromObj)
  596. {
  597. /*
  598.  *  A default assignment operator that uses a const volatile fromObj.
  599.  */
  600.    return SOM_ResolveD(this,SOMDObject,SOMObject,somDefaultConstVAssign)
  601.     (this,ctrl,fromObj);
  602. }
  603.  
  604.  
  605. /* method: somInit */
  606. void   somInit()
  607. {
  608. /*
  609.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  610.  */
  611.    SOM_ResolveD(this,SOMDObject,SOMObject,somInit)
  612.     (this);
  613. }
  614.  
  615.  
  616. /* method: somFree */
  617. void   somFree()
  618. {
  619. /*
  620.  *  Use as directed by framework implementations.
  621.  */
  622.    SOM_ResolveD(this,SOMDObject,SOMObject,somFree)
  623.     (this);
  624. }
  625.  
  626.  
  627. /* method: somUninit */
  628. void   somUninit()
  629. {
  630. /*
  631.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  632.  */
  633.    SOM_ResolveD(this,SOMDObject,SOMObject,somUninit)
  634.     (this);
  635. }
  636.  
  637.  
  638. /* method: somGetClass */
  639. SOMClass*   somGetClass()
  640. {
  641. /*
  642.  *  Return the receiver's class.
  643.  */
  644.    return SOM_ResolveD(this,SOMDObject,SOMObject,somGetClass)
  645.     (this);
  646. }
  647.  
  648.  
  649. /* method: somGetClassName */
  650. string   somGetClassName()
  651. {
  652. /*
  653.  *  Return the name of the receiver's class.
  654.  */
  655.    return SOM_ResolveD(this,SOMDObject,SOMObject,somGetClassName)
  656.     (this);
  657. }
  658.  
  659.  
  660. /* method: somGetSize */
  661. long   somGetSize()
  662. {
  663. /*
  664.  *  Return the size of the receiver.
  665.  */
  666.    return SOM_ResolveD(this,SOMDObject,SOMObject,somGetSize)
  667.     (this);
  668. }
  669.  
  670.  
  671. /* method: somIsA */
  672. boolean   somIsA(SOMClass* aClassObj)
  673. {
  674. /*
  675.  *  Returns 1 (true) if the receiver responds to methods
  676.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  677.  */
  678.    return SOM_ResolveD(this,SOMDObject,SOMObject,somIsA)
  679.     (this,aClassObj);
  680. }
  681.  
  682.  
  683. /* method: somIsInstanceOf */
  684. boolean   somIsInstanceOf(SOMClass* aClassObj)
  685. {
  686. /*
  687.  *  Returns 1 (true) if the receiver is an instance of
  688.  *  <aClassObj> and 0 (false) otherwise.
  689.  */
  690.    return SOM_ResolveD(this,SOMDObject,SOMObject,somIsInstanceOf)
  691.     (this,aClassObj);
  692. }
  693.  
  694.  
  695. /* method: somRespondsTo */
  696. boolean   somRespondsTo(somId mId)
  697. {
  698. /*
  699.  *  Returns 1 (true) if the indicated method can be invoked
  700.  *  on the receiver and 0 (false) otherwise.
  701.  */
  702.    return SOM_ResolveD(this,SOMDObject,SOMObject,somRespondsTo)
  703.     (this,mId);
  704. }
  705.  
  706.  
  707. /* va_list method: somDispatch */
  708.  
  709. /*
  710.  *  This method provides a generic, class-specific dispatch mechanism.
  711.  *  It accepts as input <retValue> a pointer to the memory area to be
  712.  *  loaded with the result of dispatching the method indicated by
  713.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  714.  *  on which the method is to be invoked as the first argument.
  715.  */
  716. /* the va_list invocation form */
  717. boolean   SOMDObject_somDispatch(somToken* retValue, 
  718.         somId methodId, 
  719.         va_list ap)
  720. {return SOM_ResolveD(this,SOMDObject,SOMObject,somDispatch)
  721.     (this,retValue,methodId,ap);
  722. }
  723.  
  724. /* the varargs invocation form */
  725. boolean   somDispatch(somToken* retValue, 
  726.         somId methodId, 
  727.         ...)
  728. {
  729. /*
  730.  *  This method provides a generic, class-specific dispatch mechanism.
  731.  *  It accepts as input <retValue> a pointer to the memory area to be
  732.  *  loaded with the result of dispatching the method indicated by
  733.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  734.  *  on which the method is to be invoked as the first argument.
  735.  */
  736.    va_list ap;
  737.    va_start(ap, methodId);
  738.    boolean __somResult = 
  739.       SOM_ResolveD(this,SOMDObject,SOMObject,somDispatch)
  740.     (this,retValue,methodId,ap);
  741.    va_end(ap);
  742.    return __somResult;
  743. }
  744.  
  745.  
  746. /* va_list method: somClassDispatch */
  747.  
  748. /*
  749.  *  Like somDispatch, but method resolution for static methods is done
  750.  *  according to the clsObj instance method table.
  751.  */
  752. /* the va_list invocation form */
  753. boolean   SOMDObject_somClassDispatch(SOMClass* clsObj, 
  754.         somToken* retValue, 
  755.         somId methodId, 
  756.         va_list ap)
  757. {return SOM_ResolveD(this,SOMDObject,SOMObject,somClassDispatch)
  758.     (this,clsObj,retValue,methodId,ap);
  759. }
  760.  
  761. /* the varargs invocation form */
  762. boolean   somClassDispatch(SOMClass* clsObj, 
  763.         somToken* retValue, 
  764.         somId methodId, 
  765.         ...)
  766. {
  767. /*
  768.  *  Like somDispatch, but method resolution for static methods is done
  769.  *  according to the clsObj instance method table.
  770.  */
  771.    va_list ap;
  772.    va_start(ap, methodId);
  773.    boolean __somResult = 
  774.       SOM_ResolveD(this,SOMDObject,SOMObject,somClassDispatch)
  775.     (this,clsObj,retValue,methodId,ap);
  776.    va_end(ap);
  777.    return __somResult;
  778. }
  779.  
  780.  
  781. /* method: somCastObj */
  782. boolean   somCastObj(SOMClass* cls)
  783. {
  784. /*
  785.  *  cast the receiving object to cls (which must be an ancestor of the
  786.  *  objects true class. Returns true on success.
  787.  */
  788.    return SOM_ResolveD(this,SOMDObject,SOMObject,somCastObj)
  789.     (this,cls);
  790. }
  791.  
  792.  
  793. /* method: somResetObj */
  794. boolean   somResetObj()
  795. {
  796. /*
  797.  *  reset an object to its true class. Returns true always.
  798.  */
  799.    return SOM_ResolveD(this,SOMDObject,SOMObject,somResetObj)
  800.     (this);
  801. }
  802.  
  803.  
  804. /* va_list method: somDispatchV */
  805.  
  806. /*
  807.  *  Obsolete. Use somDispatch instead.
  808.  */
  809. /* the va_list invocation form */
  810. void   SOMDObject_somDispatchV(somId methodId, 
  811.         somId descriptor, 
  812.         va_list ap)
  813. {   SOM_ResolveD(this,SOMDObject,SOMObject,somDispatchV)
  814.     (this,methodId,descriptor,ap);
  815. }
  816.  
  817. /* the varargs invocation form */
  818. void   somDispatchV(somId methodId, 
  819.         somId descriptor, 
  820.         ...)
  821. {
  822. /*
  823.  *  Obsolete. Use somDispatch instead.
  824.  */
  825.    va_list ap;
  826.    va_start(ap, descriptor);
  827.    SOM_ResolveD(this,SOMDObject,SOMObject,somDispatchV)
  828.     (this,methodId,descriptor,ap);
  829.    va_end(ap);
  830. }
  831.  
  832.  
  833. /* va_list method: somDispatchL */
  834.  
  835. /*
  836.  *  Obsolete. Use somDispatch instead.
  837.  */
  838. /* the va_list invocation form */
  839. long   SOMDObject_somDispatchL(somId methodId, 
  840.         somId descriptor, 
  841.         va_list ap)
  842. {return SOM_ResolveD(this,SOMDObject,SOMObject,somDispatchL)
  843.     (this,methodId,descriptor,ap);
  844. }
  845.  
  846. /* the varargs invocation form */
  847. long   somDispatchL(somId methodId, 
  848.         somId descriptor, 
  849.         ...)
  850. {
  851. /*
  852.  *  Obsolete. Use somDispatch instead.
  853.  */
  854.    va_list ap;
  855.    va_start(ap, descriptor);
  856.    long __somResult = 
  857.       SOM_ResolveD(this,SOMDObject,SOMObject,somDispatchL)
  858.     (this,methodId,descriptor,ap);
  859.    va_end(ap);
  860.    return __somResult;
  861. }
  862.  
  863.  
  864. /* va_list method: somDispatchA */
  865.  
  866. /*
  867.  *  Obsolete. Use somDispatch instead.
  868.  */
  869. /* the va_list invocation form */
  870. void*   SOMDObject_somDispatchA(somId methodId, 
  871.         somId descriptor, 
  872.         va_list ap)
  873. {return SOM_ResolveD(this,SOMDObject,SOMObject,somDispatchA)
  874.     (this,methodId,descriptor,ap);
  875. }
  876.  
  877. /* the varargs invocation form */
  878. void*   somDispatchA(somId methodId, 
  879.         somId descriptor, 
  880.         ...)
  881. {
  882. /*
  883.  *  Obsolete. Use somDispatch instead.
  884.  */
  885.    va_list ap;
  886.    va_start(ap, descriptor);
  887.    void* __somResult = 
  888.       SOM_ResolveD(this,SOMDObject,SOMObject,somDispatchA)
  889.     (this,methodId,descriptor,ap);
  890.    va_end(ap);
  891.    return __somResult;
  892. }
  893.  
  894.  
  895. /* va_list method: somDispatchD */
  896.  
  897. /*
  898.  *  Obsolete. Use somDispatch instead.
  899.  */
  900. /* the va_list invocation form */
  901. double   SOMDObject_somDispatchD(somId methodId, 
  902.         somId descriptor, 
  903.         va_list ap)
  904. {return SOM_ResolveD(this,SOMDObject,SOMObject,somDispatchD)
  905.     (this,methodId,descriptor,ap);
  906. }
  907.  
  908. /* the varargs invocation form */
  909. double   somDispatchD(somId methodId, 
  910.         somId descriptor, 
  911.         ...)
  912. {
  913. /*
  914.  *  Obsolete. Use somDispatch instead.
  915.  */
  916.    va_list ap;
  917.    va_start(ap, descriptor);
  918.    double __somResult = 
  919.       SOM_ResolveD(this,SOMDObject,SOMObject,somDispatchD)
  920.     (this,methodId,descriptor,ap);
  921.    va_end(ap);
  922.    return __somResult;
  923. }
  924.  
  925.  
  926. /* method: somPrintSelf */
  927. SOMObject*   somPrintSelf()
  928. {
  929. /*
  930.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  931.  *  information about this object.  The default implementation just gives
  932.  *  the object's class name and its address in memory.
  933.  *  <self> is returned.
  934.  */
  935.    return SOM_ResolveD(this,SOMDObject,SOMObject,somPrintSelf)
  936.     (this);
  937. }
  938.  
  939.  
  940. /* method: somDumpSelf */
  941. void   somDumpSelf(long level)
  942. {
  943. /*
  944.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  945.  *  and its current state.
  946.  * 
  947.  *  <level> indicates the nesting level for describing compound objects
  948.  *  it must be greater than or equal to zero.  All lines in the
  949.  *  description will be preceeded by <2*level> spaces.
  950.  * 
  951.  *  This routine only actually writes the data that concerns the object
  952.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  953.  *  the object's current state.  This approach allows readable
  954.  *  descriptions of compound objects to be constructed.
  955.  * 
  956.  *  Generally it is not necessary to override this method, if it is
  957.  *  overriden it generally must be completely replaced.
  958.  */
  959.    SOM_ResolveD(this,SOMDObject,SOMObject,somDumpSelf)
  960.     (this,level);
  961. }
  962.  
  963.  
  964. /* method: somDumpSelfInt */
  965. void   somDumpSelfInt(long level)
  966. {
  967. /*
  968.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  969.  *  Generally this method will need to be overridden.  When overriding
  970.  *  it, begin by calling the parent class form of this method and then
  971.  *  write in a description of your class's instance data. This will
  972.  *  result in a description of all the object's instance data going
  973.  *  from its root ancestor class to its specific class.
  974.  */
  975.    SOM_ResolveD(this,SOMDObject,SOMObject,somDumpSelfInt)
  976.     (this,level);
  977. }
  978.  
  979.  
  980.  
  981. };   /* SOMDObject */
  982.  
  983.  
  984.  
  985. #endif       /* SOM_SOMDObject_xh */
  986.