home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / orb.xh < prev    next >
Text File  |  1999-02-22  |  23KB  |  882 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: orb.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.17
  7.  *     SOM Emitter emitxh: 2.47
  8.  */
  9.  
  10. /*
  11.  *    Interface for ORB pseudo-object, from CORBA document (8.1).
  12.  */
  13.  
  14.  
  15. #ifndef SOM_ORB_xh
  16. #define SOM_ORB_xh
  17.  
  18. class ORB;
  19.  
  20. #define ORB_MajorVersion 2
  21. #define ORB_MinorVersion 1
  22.  
  23. /* C++ SOM defs */
  24. #include <somcls.xh>
  25. #include <somcm.xh>
  26.  
  27. /* C++ parent defs */
  28. #ifndef SOM_SOMObject_xh
  29. #include <somobj.xh>
  30. #endif
  31.  
  32. /*
  33.  * C++ metaclass def
  34.  */
  35. #include <snglicls.xh>
  36.  
  37. #ifndef ORB_API
  38. #define ORB_API
  39. /*
  40.  * -- The Class API
  41.  */
  42.  
  43. /*
  44.  * Start of bindings for IDL types
  45.  */
  46.  
  47. class SOMClass;
  48. class SOMObject;
  49. class Container;
  50. class OperationDef;
  51. class SOMDObject;
  52. class NVList;
  53. class Context;
  54.  
  55. /*
  56.  * End of bindings for IDL types.
  57.  */
  58.  
  59. /*
  60.  * Passthru lines: File: "C.xh", "after"
  61.  */
  62.  
  63. class ORB;
  64. SOMEXTERN ORB * SOMD_ORBObject;
  65.  
  66. #include <somdobj.xh>
  67.  
  68.  
  69. /* A procedure to create the ORB Class */
  70. class SOMMSingleInstance;
  71. SOMEXTERN SOMMSingleInstance * SOMLINK ORBNewClass(
  72.         integer4 majorVersion,
  73.         integer4 minorVersion);
  74.  
  75. /* The API to the ORB class object, and the methods it introduces. */
  76. SOMEXTERN struct ORBClassDataStructure {
  77.     SOMMSingleInstance *classObject;
  78.     somMToken object_to_string;
  79.     somMToken string_to_object;
  80.     somMToken create_list;
  81.     somMToken create_operation_list;
  82.     somMToken get_default_context;
  83.     somMToken object_to_binary;
  84.     somMToken binary_to_object;
  85. } SOMDLINK ORBClassData;
  86. #define _ORB ORBClassData.classObject
  87.  
  88. /* The API to parentMtabs for ORB, and the instance data it introduces. */
  89. SOMEXTERN struct ORBCClassDataStructure {
  90.     somMethodTabs parentMtab;
  91.     somDToken              instanceDataToken;
  92. } SOMDLINK ORBCClassData;
  93.  
  94. /*
  95.  * -- Typedefs for ORB Method Procedures
  96.  */
  97. SOMEXTERN {
  98. typedef string   SOMLINK somTP_ORB_object_to_string(ORB *somSelf, Environment *ev, 
  99.         SOMDObject* obj);
  100. typedef somTP_ORB_object_to_string *somTD_ORB_object_to_string;
  101. typedef SOMDObject*   SOMLINK somTP_ORB_string_to_object(ORB *somSelf, Environment *ev, 
  102.         string str);
  103. typedef somTP_ORB_string_to_object *somTD_ORB_string_to_object;
  104. typedef ORBStatus   SOMLINK somTP_ORB_create_list(ORB *somSelf, Environment *ev, 
  105.         long count, 
  106.         NVList** new_list);
  107. typedef somTP_ORB_create_list *somTD_ORB_create_list;
  108. typedef ORBStatus   SOMLINK somTP_ORB_create_operation_list(ORB *somSelf, Environment *ev, 
  109.         OperationDef* oper, 
  110.         NVList** new_list);
  111. typedef somTP_ORB_create_operation_list *somTD_ORB_create_operation_list;
  112. typedef ORBStatus   SOMLINK somTP_ORB_get_default_context(ORB *somSelf, Environment *ev, 
  113.         Context** ctx);
  114. typedef somTP_ORB_get_default_context *somTD_ORB_get_default_context;
  115.  
  116. /*
  117.  * -- Typedefs for Reintroduced Wrapper Methods
  118.  */
  119. typedef void   SOMLINK somTP_ORB_somDefaultInit(ORB *somSelf, 
  120.         som3InitCtrl* ctrl);
  121. typedef somTP_ORB_somDefaultInit *somTD_ORB_somDefaultInit;
  122. typedef void   SOMLINK somTP_ORB_somDestruct(ORB *somSelf, 
  123.         octet doFree, 
  124.         som3DestructCtrl* ctrl);
  125. typedef somTP_ORB_somDestruct *somTD_ORB_somDestruct;
  126. typedef void   SOMLINK somTP_ORB_somDefaultCopyInit(ORB *somSelf, 
  127.         som3InitCtrl* ctrl, 
  128.         SOMObject* fromObj);
  129. typedef somTP_ORB_somDefaultCopyInit *somTD_ORB_somDefaultCopyInit;
  130. typedef ORB*   SOMLINK somTP_ORB_somDefaultAssign(ORB *somSelf, 
  131.         som3AssignCtrl* ctrl, 
  132.         SOMObject* fromObj);
  133. typedef somTP_ORB_somDefaultAssign *somTD_ORB_somDefaultAssign;
  134. typedef void   SOMLINK somTP_ORB_somDefaultConstCopyInit(ORB *somSelf, 
  135.         som3InitCtrl* ctrl, 
  136.         SOMObject* fromObj);
  137. typedef somTP_ORB_somDefaultConstCopyInit *somTD_ORB_somDefaultConstCopyInit;
  138. typedef void   SOMLINK somTP_ORB_somDefaultVCopyInit(ORB *somSelf, 
  139.         som3InitCtrl* ctrl, 
  140.         SOMObject* fromObj);
  141. typedef somTP_ORB_somDefaultVCopyInit *somTD_ORB_somDefaultVCopyInit;
  142. typedef void   SOMLINK somTP_ORB_somDefaultConstVCopyInit(ORB *somSelf, 
  143.         som3InitCtrl* ctrl, 
  144.         SOMObject* fromObj);
  145. typedef somTP_ORB_somDefaultConstVCopyInit *somTD_ORB_somDefaultConstVCopyInit;
  146. typedef ORB*   SOMLINK somTP_ORB_somDefaultConstAssign(ORB *somSelf, 
  147.         som3AssignCtrl* ctrl, 
  148.         SOMObject* fromObj);
  149. typedef somTP_ORB_somDefaultConstAssign *somTD_ORB_somDefaultConstAssign;
  150. typedef ORB*   SOMLINK somTP_ORB_somDefaultVAssign(ORB *somSelf, 
  151.         som3AssignCtrl* ctrl, 
  152.         SOMObject* fromObj);
  153. typedef somTP_ORB_somDefaultVAssign *somTD_ORB_somDefaultVAssign;
  154. typedef ORB*   SOMLINK somTP_ORB_somDefaultConstVAssign(ORB *somSelf, 
  155.         som3AssignCtrl* ctrl, 
  156.         SOMObject* fromObj);
  157. typedef somTP_ORB_somDefaultConstVAssign *somTD_ORB_somDefaultConstVAssign;
  158. typedef void   SOMLINK somTP_ORB_somInit(ORB *somSelf);
  159. typedef somTP_ORB_somInit *somTD_ORB_somInit;
  160. typedef void   SOMLINK somTP_ORB_somFree(ORB *somSelf);
  161. typedef somTP_ORB_somFree *somTD_ORB_somFree;
  162. typedef void   SOMLINK somTP_ORB_somUninit(ORB *somSelf);
  163. typedef somTP_ORB_somUninit *somTD_ORB_somUninit;
  164. typedef SOMMSingleInstance*   SOMLINK somTP_ORB_somGetClass(ORB *somSelf);
  165. typedef somTP_ORB_somGetClass *somTD_ORB_somGetClass;
  166. typedef string   SOMLINK somTP_ORB_somGetClassName(ORB *somSelf);
  167. typedef somTP_ORB_somGetClassName *somTD_ORB_somGetClassName;
  168. typedef long   SOMLINK somTP_ORB_somGetSize(ORB *somSelf);
  169. typedef somTP_ORB_somGetSize *somTD_ORB_somGetSize;
  170. typedef boolean   SOMLINK somTP_ORB_somIsA(ORB *somSelf, 
  171.         SOMClass* aClassObj);
  172. typedef somTP_ORB_somIsA *somTD_ORB_somIsA;
  173. typedef boolean   SOMLINK somTP_ORB_somIsInstanceOf(ORB *somSelf, 
  174.         SOMClass* aClassObj);
  175. typedef somTP_ORB_somIsInstanceOf *somTD_ORB_somIsInstanceOf;
  176. typedef boolean   SOMLINK somTP_ORB_somRespondsTo(ORB *somSelf, 
  177.         somId mId);
  178. typedef somTP_ORB_somRespondsTo *somTD_ORB_somRespondsTo;
  179. typedef boolean   SOMLINK somTP_ORB_somDispatch(ORB *somSelf, 
  180.         somToken* retValue, 
  181.         somId methodId, 
  182.         va_list ap);
  183. typedef somTP_ORB_somDispatch *somTD_ORB_somDispatch;
  184. typedef boolean   SOMLINK somTP_ORB_somClassDispatch(ORB *somSelf, 
  185.         SOMClass* clsObj, 
  186.         somToken* retValue, 
  187.         somId methodId, 
  188.         va_list ap);
  189. typedef somTP_ORB_somClassDispatch *somTD_ORB_somClassDispatch;
  190. typedef boolean   SOMLINK somTP_ORB_somCastObj(ORB *somSelf, 
  191.         SOMClass* cls);
  192. typedef somTP_ORB_somCastObj *somTD_ORB_somCastObj;
  193. typedef boolean   SOMLINK somTP_ORB_somResetObj(ORB *somSelf);
  194. typedef somTP_ORB_somResetObj *somTD_ORB_somResetObj;
  195. typedef void   SOMLINK somTP_ORB_somDispatchV(ORB *somSelf, 
  196.         somId methodId, 
  197.         somId descriptor, 
  198.         va_list ap);
  199. typedef somTP_ORB_somDispatchV *somTD_ORB_somDispatchV;
  200. typedef long   SOMLINK somTP_ORB_somDispatchL(ORB *somSelf, 
  201.         somId methodId, 
  202.         somId descriptor, 
  203.         va_list ap);
  204. typedef somTP_ORB_somDispatchL *somTD_ORB_somDispatchL;
  205. typedef void*   SOMLINK somTP_ORB_somDispatchA(ORB *somSelf, 
  206.         somId methodId, 
  207.         somId descriptor, 
  208.         va_list ap);
  209. typedef somTP_ORB_somDispatchA *somTD_ORB_somDispatchA;
  210. typedef double   SOMLINK somTP_ORB_somDispatchD(ORB *somSelf, 
  211.         somId methodId, 
  212.         somId descriptor, 
  213.         va_list ap);
  214. typedef somTP_ORB_somDispatchD *somTD_ORB_somDispatchD;
  215. typedef SOMObject*   SOMLINK somTP_ORB_somPrintSelf(ORB *somSelf);
  216. typedef somTP_ORB_somPrintSelf *somTD_ORB_somPrintSelf;
  217. typedef void   SOMLINK somTP_ORB_somDumpSelf(ORB *somSelf, 
  218.         long level);
  219. typedef somTP_ORB_somDumpSelf *somTD_ORB_somDumpSelf;
  220. typedef void   SOMLINK somTP_ORB_somDumpSelfInt(ORB *somSelf, 
  221.         long level);
  222. typedef somTP_ORB_somDumpSelfInt *somTD_ORB_somDumpSelfInt;
  223. }
  224.  
  225. #endif /* ORB_API */
  226.  
  227.  
  228. /*
  229.  * -- This emitter treats Method Tokens as Thunks by default.
  230.  * -- Use the sc modifier "nothunks" to change this default
  231.  */
  232. #undef somresolve_
  233. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  234.  
  235. /*
  236.  * -- The C++ Wrapper Class for ORB
  237.  */
  238. class ORB : public SOMObject
  239. {
  240. public:
  241.  
  242. // ORB::new creates the class object if necessary, and then uses somNewNoInit
  243. // to allocate memory and create the object. Initialization is in ctors.
  244. void *operator new(size_t)
  245. {
  246.    if (!_ORB) ORBNewClass(ORB_MajorVersion,ORB_MinorVersion);
  247.    return (void*)
  248.       SOM_Resolve(_ORB,SOMClass,somNewNoInit)
  249.          ((SOMClass *)((void*)_ORB));
  250. }
  251.  
  252. // ORB::delete uses somDestruct.
  253. void operator delete(void * obj)
  254. {
  255.    if (obj && *(void**)obj) {
  256.       SOM_Resolve(obj,SOMObject,somFree)
  257.          ((SOMObject*)obj);
  258.    }
  259. }
  260.  
  261. ORB& operator=(ORB& fromObj)
  262. {
  263.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  264.    return *this;
  265. }
  266.  
  267. ORB()
  268. {
  269.    if (*(void**)this != 
  270.        ((somParentMtabStructPtr)
  271.         (ORBCClassData.parentMtab))->mtab)
  272.       return;
  273.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  274. }
  275.  
  276. ORB(ORB* fromObj)
  277. {
  278.    if (*(void**)this != 
  279.        ((somParentMtabStructPtr)
  280.         (ORBCClassData.parentMtab))->mtab)
  281.       return;
  282.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  283. }
  284.  
  285. #ifdef __IBMCPP__
  286. #pragma info(nocnv,nopar)
  287. #endif
  288. ORB(const ORB* fromObj)
  289. {
  290.    if (*(void**)this != 
  291.        ((somParentMtabStructPtr)
  292.         (ORBCClassData.parentMtab))->mtab)
  293.       return;
  294.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  295. }
  296. #ifdef __IBMCPP__
  297. #pragma info(restore)
  298. #endif
  299.  
  300.  
  301. /* method: object_to_string */
  302. string   object_to_string(Environment *ev, 
  303.         SOMDObject* obj)
  304. {
  305. /*
  306.  *  Converts an object reference to its external form.
  307.  *  OWNERSHIP of allocated memory is transferred to the caller.
  308.  *  Use ORBfree to release the allocated memory.
  309.  */
  310.    return SOM_ResolveD(this,ORB,ORB,object_to_string)
  311.     (this, ev,obj);
  312. }
  313.  
  314.  
  315. /* method: string_to_object */
  316. SOMDObject*   string_to_object(Environment *ev, 
  317.         string str)
  318. {
  319. /*
  320.  *  Converts externalized form back to an object reference.
  321.  */
  322.    return SOM_ResolveD(this,ORB,ORB,string_to_object)
  323.     (this, ev,str);
  324. }
  325.  
  326.  
  327. /* method: create_list */
  328. ORBStatus   create_list(Environment *ev, 
  329.         long count, 
  330.         NVList** new_list)
  331. {
  332. /*
  333.  *  Creates a NamedValue list, of specified size,
  334.  *  for use in Requests.
  335.  *  OWNERSHIP of allocated "new_list" is transferred to the caller.
  336.  */
  337.    return SOM_ResolveD(this,ORB,ORB,create_list)
  338.     (this, ev,count,new_list);
  339. }
  340.  
  341.  
  342. /* method: create_operation_list */
  343. ORBStatus   create_operation_list(Environment *ev, 
  344.         OperationDef* oper, 
  345.         NVList** new_list)
  346. {
  347. /*
  348.  *  Creates a NamedValue list for the specified operation,
  349.  *  for use in Requests invoking that operation.
  350.  *  OWNERSHIP of allocated "new_list" is transferred to the caller.
  351.  */
  352.    return SOM_ResolveD(this,ORB,ORB,create_operation_list)
  353.     (this, ev,oper,new_list);
  354. }
  355.  
  356.  
  357. /* method: get_default_context */
  358. ORBStatus   get_default_context(Environment *ev, 
  359.         Context** ctx)
  360. {
  361. /*
  362.  *  Get default context.
  363.  *  OWNERSHIP of allocated Context object is transferred to the caller.
  364.  */
  365.    return SOM_ResolveD(this,ORB,ORB,get_default_context)
  366.     (this, ev,ctx);
  367. }
  368.  
  369.  
  370. /*
  371.  * Reintroduce inherited methods
  372.  */
  373.  
  374. /* initializer method: somDefaultInit */
  375. void   somDefaultInit(som3InitCtrl* ctrl)
  376. {
  377. /*
  378.  *  A default initializer for a SOM object. Passing a null ctrl
  379.  *  indicates to the receiver that its class is the class of the
  380.  *  object being initialized, whereby the initializer will determine
  381.  *  an appropriate control structure.
  382.  */
  383.    SOM_ResolveD(this,ORB,SOMObject,somDefaultInit)
  384.     (this,ctrl);
  385. }
  386.  
  387.  
  388. /* method: somDestruct */
  389. void   somDestruct(octet doFree, 
  390.         som3DestructCtrl* ctrl)
  391. {
  392. /*
  393.  *  The default destructor for a SOM object. A nonzero <doFree>
  394.  *  indicates that the object storage should be freed by the
  395.  *  object's class (via somDeallocate) after uninitialization.
  396.  *  As with somDefaultInit, a null ctrl can be passed.
  397.  */
  398.    SOM_ResolveD(this,ORB,SOMObject,somDestruct)
  399.     (this,doFree,ctrl);
  400. }
  401.  
  402.  
  403. /* initializer method: somDefaultCopyInit */
  404. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  405.         SOMObject* fromObj)
  406. {
  407. /*
  408.  *  A default copy constructor. Use this to make copies of objects for
  409.  *  calling methods with "by-value" argument semantics.
  410.  */
  411.    SOM_ResolveD(this,ORB,SOMObject,somDefaultCopyInit)
  412.     (this,ctrl,fromObj);
  413. }
  414.  
  415.  
  416. /* method: somDefaultAssign */
  417. ORB*  somDefaultAssign(som3AssignCtrl* ctrl, 
  418.         SOMObject* fromObj)
  419. {
  420. /*
  421.  *  A default assignment operator. Use this to "assign" the state of one
  422.  *  object to another.
  423.  */
  424.    return SOM_ResolveD(this,ORB,SOMObject,somDefaultAssign)
  425.     (this,ctrl,fromObj);
  426. }
  427.  
  428.  
  429. /* initializer method: somDefaultConstCopyInit */
  430. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  431.         SOMObject* fromObj)
  432. {
  433. /*
  434.  *  A default copy constructor that uses a const fromObj.
  435.  */
  436.    SOM_ResolveD(this,ORB,SOMObject,somDefaultConstCopyInit)
  437.     (this,ctrl,fromObj);
  438. }
  439.  
  440.  
  441. /* initializer method: somDefaultVCopyInit */
  442. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  443.         SOMObject* fromObj)
  444. {
  445. /*
  446.  *  A default copy constructor that uses a volatile fromObj.
  447.  */
  448.    SOM_ResolveD(this,ORB,SOMObject,somDefaultVCopyInit)
  449.     (this,ctrl,fromObj);
  450. }
  451.  
  452.  
  453. /* initializer method: somDefaultConstVCopyInit */
  454. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  455.         SOMObject* fromObj)
  456. {
  457. /*
  458.  *  A default copy constructor that uses a const volatile fromObj.
  459.  */
  460.    SOM_ResolveD(this,ORB,SOMObject,somDefaultConstVCopyInit)
  461.     (this,ctrl,fromObj);
  462. }
  463.  
  464.  
  465. /* method: somDefaultConstAssign */
  466. ORB*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  467.         SOMObject* fromObj)
  468. {
  469. /*
  470.  *  A default assignment operator that uses a const fromObj.
  471.  */
  472.    return SOM_ResolveD(this,ORB,SOMObject,somDefaultConstAssign)
  473.     (this,ctrl,fromObj);
  474. }
  475.  
  476.  
  477. /* method: somDefaultVAssign */
  478. ORB*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  479.         SOMObject* fromObj)
  480. {
  481. /*
  482.  *  A default assignment operator that uses a volatile fromObj.
  483.  */
  484.    return SOM_ResolveD(this,ORB,SOMObject,somDefaultVAssign)
  485.     (this,ctrl,fromObj);
  486. }
  487.  
  488.  
  489. /* method: somDefaultConstVAssign */
  490. ORB*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  491.         SOMObject* fromObj)
  492. {
  493. /*
  494.  *  A default assignment operator that uses a const volatile fromObj.
  495.  */
  496.    return SOM_ResolveD(this,ORB,SOMObject,somDefaultConstVAssign)
  497.     (this,ctrl,fromObj);
  498. }
  499.  
  500.  
  501. /* method: somInit */
  502. void   somInit()
  503. {
  504. /*
  505.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  506.  */
  507.    SOM_ResolveD(this,ORB,SOMObject,somInit)
  508.     (this);
  509. }
  510.  
  511.  
  512. /* method: somFree */
  513. void   somFree()
  514. {
  515. /*
  516.  *  Use as directed by framework implementations.
  517.  */
  518.    SOM_ResolveD(this,ORB,SOMObject,somFree)
  519.     (this);
  520. }
  521.  
  522.  
  523. /* method: somUninit */
  524. void   somUninit()
  525. {
  526. /*
  527.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  528.  */
  529.    SOM_ResolveD(this,ORB,SOMObject,somUninit)
  530.     (this);
  531. }
  532.  
  533.  
  534. /* method: somGetClass */
  535. SOMMSingleInstance*  somGetClass()
  536. {
  537. /*
  538.  *  Return the receiver's class.
  539.  */
  540.    return SOM_ResolveD(this,ORB,SOMObject,somGetClass)
  541.     (this);
  542. }
  543.  
  544.  
  545. /* method: somGetClassName */
  546. string   somGetClassName()
  547. {
  548. /*
  549.  *  Return the name of the receiver's class.
  550.  */
  551.    return SOM_ResolveD(this,ORB,SOMObject,somGetClassName)
  552.     (this);
  553. }
  554.  
  555.  
  556. /* method: somGetSize */
  557. long   somGetSize()
  558. {
  559. /*
  560.  *  Return the size of the receiver.
  561.  */
  562.    return SOM_ResolveD(this,ORB,SOMObject,somGetSize)
  563.     (this);
  564. }
  565.  
  566.  
  567. /* method: somIsA */
  568. boolean   somIsA(SOMClass* aClassObj)
  569. {
  570. /*
  571.  *  Returns 1 (true) if the receiver responds to methods
  572.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  573.  */
  574.    return SOM_ResolveD(this,ORB,SOMObject,somIsA)
  575.     (this,aClassObj);
  576. }
  577.  
  578.  
  579. /* method: somIsInstanceOf */
  580. boolean   somIsInstanceOf(SOMClass* aClassObj)
  581. {
  582. /*
  583.  *  Returns 1 (true) if the receiver is an instance of
  584.  *  <aClassObj> and 0 (false) otherwise.
  585.  */
  586.    return SOM_ResolveD(this,ORB,SOMObject,somIsInstanceOf)
  587.     (this,aClassObj);
  588. }
  589.  
  590.  
  591. /* method: somRespondsTo */
  592. boolean   somRespondsTo(somId mId)
  593. {
  594. /*
  595.  *  Returns 1 (true) if the indicated method can be invoked
  596.  *  on the receiver and 0 (false) otherwise.
  597.  */
  598.    return SOM_ResolveD(this,ORB,SOMObject,somRespondsTo)
  599.     (this,mId);
  600. }
  601.  
  602.  
  603. /* va_list method: somDispatch */
  604.  
  605. /*
  606.  *  This method provides a generic, class-specific dispatch mechanism.
  607.  *  It accepts as input <retValue> a pointer to the memory area to be
  608.  *  loaded with the result of dispatching the method indicated by
  609.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  610.  *  on which the method is to be invoked as the first argument.
  611.  */
  612. /* the va_list invocation form */
  613. boolean   ORB_somDispatch(somToken* retValue, 
  614.         somId methodId, 
  615.         va_list ap)
  616. {return SOM_ResolveD(this,ORB,SOMObject,somDispatch)
  617.     (this,retValue,methodId,ap);
  618. }
  619.  
  620. /* the varargs invocation form */
  621. boolean   somDispatch(somToken* retValue, 
  622.         somId methodId, 
  623.         ...)
  624. {
  625. /*
  626.  *  This method provides a generic, class-specific dispatch mechanism.
  627.  *  It accepts as input <retValue> a pointer to the memory area to be
  628.  *  loaded with the result of dispatching the method indicated by
  629.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  630.  *  on which the method is to be invoked as the first argument.
  631.  */
  632.    va_list ap;
  633.    va_start(ap, methodId);
  634.    boolean __somResult = 
  635.       SOM_ResolveD(this,ORB,SOMObject,somDispatch)
  636.     (this,retValue,methodId,ap);
  637.    va_end(ap);
  638.    return __somResult;
  639. }
  640.  
  641.  
  642. /* va_list method: somClassDispatch */
  643.  
  644. /*
  645.  *  Like somDispatch, but method resolution for static methods is done
  646.  *  according to the clsObj instance method table.
  647.  */
  648. /* the va_list invocation form */
  649. boolean   ORB_somClassDispatch(SOMClass* clsObj, 
  650.         somToken* retValue, 
  651.         somId methodId, 
  652.         va_list ap)
  653. {return SOM_ResolveD(this,ORB,SOMObject,somClassDispatch)
  654.     (this,clsObj,retValue,methodId,ap);
  655. }
  656.  
  657. /* the varargs invocation form */
  658. boolean   somClassDispatch(SOMClass* clsObj, 
  659.         somToken* retValue, 
  660.         somId methodId, 
  661.         ...)
  662. {
  663. /*
  664.  *  Like somDispatch, but method resolution for static methods is done
  665.  *  according to the clsObj instance method table.
  666.  */
  667.    va_list ap;
  668.    va_start(ap, methodId);
  669.    boolean __somResult = 
  670.       SOM_ResolveD(this,ORB,SOMObject,somClassDispatch)
  671.     (this,clsObj,retValue,methodId,ap);
  672.    va_end(ap);
  673.    return __somResult;
  674. }
  675.  
  676.  
  677. /* method: somCastObj */
  678. boolean   somCastObj(SOMClass* cls)
  679. {
  680. /*
  681.  *  cast the receiving object to cls (which must be an ancestor of the
  682.  *  objects true class. Returns true on success.
  683.  */
  684.    return SOM_ResolveD(this,ORB,SOMObject,somCastObj)
  685.     (this,cls);
  686. }
  687.  
  688.  
  689. /* method: somResetObj */
  690. boolean   somResetObj()
  691. {
  692. /*
  693.  *  reset an object to its true class. Returns true always.
  694.  */
  695.    return SOM_ResolveD(this,ORB,SOMObject,somResetObj)
  696.     (this);
  697. }
  698.  
  699.  
  700. /* va_list method: somDispatchV */
  701.  
  702. /*
  703.  *  Obsolete. Use somDispatch instead.
  704.  */
  705. /* the va_list invocation form */
  706. void   ORB_somDispatchV(somId methodId, 
  707.         somId descriptor, 
  708.         va_list ap)
  709. {   SOM_ResolveD(this,ORB,SOMObject,somDispatchV)
  710.     (this,methodId,descriptor,ap);
  711. }
  712.  
  713. /* the varargs invocation form */
  714. void   somDispatchV(somId methodId, 
  715.         somId descriptor, 
  716.         ...)
  717. {
  718. /*
  719.  *  Obsolete. Use somDispatch instead.
  720.  */
  721.    va_list ap;
  722.    va_start(ap, descriptor);
  723.    SOM_ResolveD(this,ORB,SOMObject,somDispatchV)
  724.     (this,methodId,descriptor,ap);
  725.    va_end(ap);
  726. }
  727.  
  728.  
  729. /* va_list method: somDispatchL */
  730.  
  731. /*
  732.  *  Obsolete. Use somDispatch instead.
  733.  */
  734. /* the va_list invocation form */
  735. long   ORB_somDispatchL(somId methodId, 
  736.         somId descriptor, 
  737.         va_list ap)
  738. {return SOM_ResolveD(this,ORB,SOMObject,somDispatchL)
  739.     (this,methodId,descriptor,ap);
  740. }
  741.  
  742. /* the varargs invocation form */
  743. long   somDispatchL(somId methodId, 
  744.         somId descriptor, 
  745.         ...)
  746. {
  747. /*
  748.  *  Obsolete. Use somDispatch instead.
  749.  */
  750.    va_list ap;
  751.    va_start(ap, descriptor);
  752.    long __somResult = 
  753.       SOM_ResolveD(this,ORB,SOMObject,somDispatchL)
  754.     (this,methodId,descriptor,ap);
  755.    va_end(ap);
  756.    return __somResult;
  757. }
  758.  
  759.  
  760. /* va_list method: somDispatchA */
  761.  
  762. /*
  763.  *  Obsolete. Use somDispatch instead.
  764.  */
  765. /* the va_list invocation form */
  766. void*   ORB_somDispatchA(somId methodId, 
  767.         somId descriptor, 
  768.         va_list ap)
  769. {return SOM_ResolveD(this,ORB,SOMObject,somDispatchA)
  770.     (this,methodId,descriptor,ap);
  771. }
  772.  
  773. /* the varargs invocation form */
  774. void*   somDispatchA(somId methodId, 
  775.         somId descriptor, 
  776.         ...)
  777. {
  778. /*
  779.  *  Obsolete. Use somDispatch instead.
  780.  */
  781.    va_list ap;
  782.    va_start(ap, descriptor);
  783.    void* __somResult = 
  784.       SOM_ResolveD(this,ORB,SOMObject,somDispatchA)
  785.     (this,methodId,descriptor,ap);
  786.    va_end(ap);
  787.    return __somResult;
  788. }
  789.  
  790.  
  791. /* va_list method: somDispatchD */
  792.  
  793. /*
  794.  *  Obsolete. Use somDispatch instead.
  795.  */
  796. /* the va_list invocation form */
  797. double   ORB_somDispatchD(somId methodId, 
  798.         somId descriptor, 
  799.         va_list ap)
  800. {return SOM_ResolveD(this,ORB,SOMObject,somDispatchD)
  801.     (this,methodId,descriptor,ap);
  802. }
  803.  
  804. /* the varargs invocation form */
  805. double   somDispatchD(somId methodId, 
  806.         somId descriptor, 
  807.         ...)
  808. {
  809. /*
  810.  *  Obsolete. Use somDispatch instead.
  811.  */
  812.    va_list ap;
  813.    va_start(ap, descriptor);
  814.    double __somResult = 
  815.       SOM_ResolveD(this,ORB,SOMObject,somDispatchD)
  816.     (this,methodId,descriptor,ap);
  817.    va_end(ap);
  818.    return __somResult;
  819. }
  820.  
  821.  
  822. /* method: somPrintSelf */
  823. SOMObject*   somPrintSelf()
  824. {
  825. /*
  826.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  827.  *  information about this object.  The default implementation just gives
  828.  *  the object's class name and its address in memory.
  829.  *  <self> is returned.
  830.  */
  831.    return SOM_ResolveD(this,ORB,SOMObject,somPrintSelf)
  832.     (this);
  833. }
  834.  
  835.  
  836. /* method: somDumpSelf */
  837. void   somDumpSelf(long level)
  838. {
  839. /*
  840.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  841.  *  and its current state.
  842.  * 
  843.  *  <level> indicates the nesting level for describing compound objects
  844.  *  it must be greater than or equal to zero.  All lines in the
  845.  *  description will be preceeded by <2*level> spaces.
  846.  * 
  847.  *  This routine only actually writes the data that concerns the object
  848.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  849.  *  the object's current state.  This approach allows readable
  850.  *  descriptions of compound objects to be constructed.
  851.  * 
  852.  *  Generally it is not necessary to override this method, if it is
  853.  *  overriden it generally must be completely replaced.
  854.  */
  855.    SOM_ResolveD(this,ORB,SOMObject,somDumpSelf)
  856.     (this,level);
  857. }
  858.  
  859.  
  860. /* method: somDumpSelfInt */
  861. void   somDumpSelfInt(long level)
  862. {
  863. /*
  864.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  865.  *  Generally this method will need to be overridden.  When overriding
  866.  *  it, begin by calling the parent class form of this method and then
  867.  *  write in a description of your class's instance data. This will
  868.  *  result in a description of all the object's instance data going
  869.  *  from its root ancestor class to its specific class.
  870.  */
  871.    SOM_ResolveD(this,ORB,SOMObject,somDumpSelfInt)
  872.     (this,level);
  873. }
  874.  
  875.  
  876.  
  877. };   /* ORB */
  878.  
  879.  
  880.  
  881. #endif       /* SOM_ORB_xh */
  882.