home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / somr.xh < prev    next >
Text File  |  1999-02-22  |  21KB  |  795 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: somr.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.17
  7.  *     SOM Emitter emitxh: 2.47
  8.  */
  9.  
  10. /*
  11.  *    COMPONENT_NAME: somr
  12.  * 
  13.  *    ORIGINS: 27
  14.  * 
  15.  * 
  16.  *    10H9767, 10H9769  (C) COPYRIGHT International Business Machines Corp. 1992,1994
  17.  *    All Rights Reserved
  18.  *    Licensed Materials - Property of IBM
  19.  *    US Government Users Restricted Rights - Use, duplication or
  20.  *    disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  21.  * 
  22.  */
  23.  
  24.  
  25. #ifndef SOM_SOMR_xh
  26. #define SOM_SOMR_xh
  27.  
  28. class SOMR;
  29.  
  30. /*
  31.  * This class creates one of a kind managers needed for the replication framework.
  32.  * Any application wanting to use the framework must create an instance of this
  33.  * class at the very beginning (for example,  in its main program).
  34.  */
  35.  
  36. #define SOMR_MajorVersion 2
  37. #define SOMR_MinorVersion 1
  38.  
  39. /* C++ SOM defs */
  40. #include <somcls.xh>
  41. #include <somcm.xh>
  42.  
  43. /* C++ parent defs */
  44. #ifndef SOM_SOMObject_xh
  45. #include <somobj.xh>
  46. #endif
  47.  
  48. /*
  49.  * C++ metaclass def
  50.  */
  51. #include <snglicls.xh>
  52.  
  53. #ifndef SOMR_API
  54. #define SOMR_API
  55. /*
  56.  * -- The Class API
  57.  */
  58.  
  59. /*
  60.  * Start of bindings for IDL types
  61.  */
  62.  
  63. class SOMClass;
  64. class SOMObject;
  65.  
  66. /*
  67.  * End of bindings for IDL types.
  68.  */
  69.  
  70. /* A procedure to create the SOMR Class */
  71. class SOMMSingleInstance;
  72. SOMEXTERN SOMMSingleInstance * SOMLINK SOMRNewClass(
  73.         integer4 majorVersion,
  74.         integer4 minorVersion);
  75.  
  76. /* The API to the SOMR class object, and the methods it introduces. */
  77. SOMEXTERN struct SOMRClassDataStructure {
  78.     SOMMSingleInstance *classObject;
  79. } SOMDLINK SOMRClassData;
  80. #define _SOMR SOMRClassData.classObject
  81.  
  82. /* The API to parentMtabs for SOMR, and the instance data it introduces. */
  83. SOMEXTERN struct SOMRCClassDataStructure {
  84.     somMethodTabs parentMtab;
  85.     somDToken              instanceDataToken;
  86. } SOMDLINK SOMRCClassData;
  87.  
  88. /*
  89.  * -- Typedefs for SOMR Method Procedures
  90.  */
  91. SOMEXTERN {
  92.  
  93. /*
  94.  * -- Typedefs for Reintroduced Wrapper Methods
  95.  */
  96. typedef void   SOMLINK somTP_SOMR_somDefaultInit(SOMR *somSelf, 
  97.         som3InitCtrl* ctrl);
  98. typedef somTP_SOMR_somDefaultInit *somTD_SOMR_somDefaultInit;
  99. typedef void   SOMLINK somTP_SOMR_somDestruct(SOMR *somSelf, 
  100.         octet doFree, 
  101.         som3DestructCtrl* ctrl);
  102. typedef somTP_SOMR_somDestruct *somTD_SOMR_somDestruct;
  103. typedef void   SOMLINK somTP_SOMR_somDefaultCopyInit(SOMR *somSelf, 
  104.         som3InitCtrl* ctrl, 
  105.         SOMObject* fromObj);
  106. typedef somTP_SOMR_somDefaultCopyInit *somTD_SOMR_somDefaultCopyInit;
  107. typedef SOMR*   SOMLINK somTP_SOMR_somDefaultAssign(SOMR *somSelf, 
  108.         som3AssignCtrl* ctrl, 
  109.         SOMObject* fromObj);
  110. typedef somTP_SOMR_somDefaultAssign *somTD_SOMR_somDefaultAssign;
  111. typedef void   SOMLINK somTP_SOMR_somDefaultConstCopyInit(SOMR *somSelf, 
  112.         som3InitCtrl* ctrl, 
  113.         SOMObject* fromObj);
  114. typedef somTP_SOMR_somDefaultConstCopyInit *somTD_SOMR_somDefaultConstCopyInit;
  115. typedef void   SOMLINK somTP_SOMR_somDefaultVCopyInit(SOMR *somSelf, 
  116.         som3InitCtrl* ctrl, 
  117.         SOMObject* fromObj);
  118. typedef somTP_SOMR_somDefaultVCopyInit *somTD_SOMR_somDefaultVCopyInit;
  119. typedef void   SOMLINK somTP_SOMR_somDefaultConstVCopyInit(SOMR *somSelf, 
  120.         som3InitCtrl* ctrl, 
  121.         SOMObject* fromObj);
  122. typedef somTP_SOMR_somDefaultConstVCopyInit *somTD_SOMR_somDefaultConstVCopyInit;
  123. typedef SOMR*   SOMLINK somTP_SOMR_somDefaultConstAssign(SOMR *somSelf, 
  124.         som3AssignCtrl* ctrl, 
  125.         SOMObject* fromObj);
  126. typedef somTP_SOMR_somDefaultConstAssign *somTD_SOMR_somDefaultConstAssign;
  127. typedef SOMR*   SOMLINK somTP_SOMR_somDefaultVAssign(SOMR *somSelf, 
  128.         som3AssignCtrl* ctrl, 
  129.         SOMObject* fromObj);
  130. typedef somTP_SOMR_somDefaultVAssign *somTD_SOMR_somDefaultVAssign;
  131. typedef SOMR*   SOMLINK somTP_SOMR_somDefaultConstVAssign(SOMR *somSelf, 
  132.         som3AssignCtrl* ctrl, 
  133.         SOMObject* fromObj);
  134. typedef somTP_SOMR_somDefaultConstVAssign *somTD_SOMR_somDefaultConstVAssign;
  135. typedef void   SOMLINK somTP_SOMR_somInit(SOMR *somSelf);
  136. typedef somTP_SOMR_somInit *somTD_SOMR_somInit;
  137. typedef void   SOMLINK somTP_SOMR_somFree(SOMR *somSelf);
  138. typedef somTP_SOMR_somFree *somTD_SOMR_somFree;
  139. typedef void   SOMLINK somTP_SOMR_somUninit(SOMR *somSelf);
  140. typedef somTP_SOMR_somUninit *somTD_SOMR_somUninit;
  141. typedef SOMMSingleInstance*   SOMLINK somTP_SOMR_somGetClass(SOMR *somSelf);
  142. typedef somTP_SOMR_somGetClass *somTD_SOMR_somGetClass;
  143. typedef string   SOMLINK somTP_SOMR_somGetClassName(SOMR *somSelf);
  144. typedef somTP_SOMR_somGetClassName *somTD_SOMR_somGetClassName;
  145. typedef long   SOMLINK somTP_SOMR_somGetSize(SOMR *somSelf);
  146. typedef somTP_SOMR_somGetSize *somTD_SOMR_somGetSize;
  147. typedef boolean   SOMLINK somTP_SOMR_somIsA(SOMR *somSelf, 
  148.         SOMClass* aClassObj);
  149. typedef somTP_SOMR_somIsA *somTD_SOMR_somIsA;
  150. typedef boolean   SOMLINK somTP_SOMR_somIsInstanceOf(SOMR *somSelf, 
  151.         SOMClass* aClassObj);
  152. typedef somTP_SOMR_somIsInstanceOf *somTD_SOMR_somIsInstanceOf;
  153. typedef boolean   SOMLINK somTP_SOMR_somRespondsTo(SOMR *somSelf, 
  154.         somId mId);
  155. typedef somTP_SOMR_somRespondsTo *somTD_SOMR_somRespondsTo;
  156. typedef boolean   SOMLINK somTP_SOMR_somDispatch(SOMR *somSelf, 
  157.         somToken* retValue, 
  158.         somId methodId, 
  159.         va_list ap);
  160. typedef somTP_SOMR_somDispatch *somTD_SOMR_somDispatch;
  161. typedef boolean   SOMLINK somTP_SOMR_somClassDispatch(SOMR *somSelf, 
  162.         SOMClass* clsObj, 
  163.         somToken* retValue, 
  164.         somId methodId, 
  165.         va_list ap);
  166. typedef somTP_SOMR_somClassDispatch *somTD_SOMR_somClassDispatch;
  167. typedef boolean   SOMLINK somTP_SOMR_somCastObj(SOMR *somSelf, 
  168.         SOMClass* cls);
  169. typedef somTP_SOMR_somCastObj *somTD_SOMR_somCastObj;
  170. typedef boolean   SOMLINK somTP_SOMR_somResetObj(SOMR *somSelf);
  171. typedef somTP_SOMR_somResetObj *somTD_SOMR_somResetObj;
  172. typedef void   SOMLINK somTP_SOMR_somDispatchV(SOMR *somSelf, 
  173.         somId methodId, 
  174.         somId descriptor, 
  175.         va_list ap);
  176. typedef somTP_SOMR_somDispatchV *somTD_SOMR_somDispatchV;
  177. typedef long   SOMLINK somTP_SOMR_somDispatchL(SOMR *somSelf, 
  178.         somId methodId, 
  179.         somId descriptor, 
  180.         va_list ap);
  181. typedef somTP_SOMR_somDispatchL *somTD_SOMR_somDispatchL;
  182. typedef void*   SOMLINK somTP_SOMR_somDispatchA(SOMR *somSelf, 
  183.         somId methodId, 
  184.         somId descriptor, 
  185.         va_list ap);
  186. typedef somTP_SOMR_somDispatchA *somTD_SOMR_somDispatchA;
  187. typedef double   SOMLINK somTP_SOMR_somDispatchD(SOMR *somSelf, 
  188.         somId methodId, 
  189.         somId descriptor, 
  190.         va_list ap);
  191. typedef somTP_SOMR_somDispatchD *somTD_SOMR_somDispatchD;
  192. typedef SOMObject*   SOMLINK somTP_SOMR_somPrintSelf(SOMR *somSelf);
  193. typedef somTP_SOMR_somPrintSelf *somTD_SOMR_somPrintSelf;
  194. typedef void   SOMLINK somTP_SOMR_somDumpSelf(SOMR *somSelf, 
  195.         long level);
  196. typedef somTP_SOMR_somDumpSelf *somTD_SOMR_somDumpSelf;
  197. typedef void   SOMLINK somTP_SOMR_somDumpSelfInt(SOMR *somSelf, 
  198.         long level);
  199. typedef somTP_SOMR_somDumpSelfInt *somTD_SOMR_somDumpSelfInt;
  200. }
  201.  
  202. #endif /* SOMR_API */
  203.  
  204.  
  205. /*
  206.  * -- This emitter treats Method Tokens as Thunks by default.
  207.  * -- Use the sc modifier "nothunks" to change this default
  208.  */
  209. #undef somresolve_
  210. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  211.  
  212. /*
  213.  * -- The C++ Wrapper Class for SOMR
  214.  */
  215. class SOMR : public SOMObject
  216. {
  217. /*
  218.  * This class creates one of a kind managers needed for the replication framework.
  219.  * Any application wanting to use the framework must create an instance of this
  220.  * class at the very beginning (for example,  in its main program).
  221.  */
  222. public:
  223.  
  224. // SOMR::new creates the class object if necessary, and then uses somNewNoInit
  225. // to allocate memory and create the object. Initialization is in ctors.
  226. void *operator new(size_t)
  227. {
  228.    if (!_SOMR) SOMRNewClass(SOMR_MajorVersion,SOMR_MinorVersion);
  229.    return (void*)
  230.       SOM_Resolve(_SOMR,SOMClass,somNewNoInit)
  231.          ((SOMClass *)((void*)_SOMR));
  232. }
  233.  
  234. // SOMR::delete uses somDestruct.
  235. void operator delete(void * obj)
  236. {
  237.    if (obj && *(void**)obj) {
  238.       SOM_Resolve(obj,SOMObject,somFree)
  239.          ((SOMObject*)obj);
  240.    }
  241. }
  242.  
  243. SOMR& operator=(SOMR& fromObj)
  244. {
  245.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  246.    return *this;
  247. }
  248.  
  249. SOMR()
  250. {
  251.    if (*(void**)this != 
  252.        ((somParentMtabStructPtr)
  253.         (SOMRCClassData.parentMtab))->mtab)
  254.       return;
  255.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  256. }
  257.  
  258. SOMR(SOMR* fromObj)
  259. {
  260.    if (*(void**)this != 
  261.        ((somParentMtabStructPtr)
  262.         (SOMRCClassData.parentMtab))->mtab)
  263.       return;
  264.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  265. }
  266.  
  267. #ifdef __IBMCPP__
  268. #pragma info(nocnv,nopar)
  269. #endif
  270. SOMR(const SOMR* fromObj)
  271. {
  272.    if (*(void**)this != 
  273.        ((somParentMtabStructPtr)
  274.         (SOMRCClassData.parentMtab))->mtab)
  275.       return;
  276.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  277. }
  278. #ifdef __IBMCPP__
  279. #pragma info(restore)
  280. #endif
  281.  
  282.  
  283. /*
  284.  * Reintroduce inherited methods
  285.  */
  286.  
  287. /* initializer method: somDefaultInit */
  288. void   somDefaultInit(som3InitCtrl* ctrl)
  289. {
  290. /*
  291.  *  A default initializer for a SOM object. Passing a null ctrl
  292.  *  indicates to the receiver that its class is the class of the
  293.  *  object being initialized, whereby the initializer will determine
  294.  *  an appropriate control structure.
  295.  */
  296.    SOM_ResolveD(this,SOMR,SOMObject,somDefaultInit)
  297.     (this,ctrl);
  298. }
  299.  
  300.  
  301. /* method: somDestruct */
  302. void   somDestruct(octet doFree, 
  303.         som3DestructCtrl* ctrl)
  304. {
  305. /*
  306.  *  The default destructor for a SOM object. A nonzero <doFree>
  307.  *  indicates that the object storage should be freed by the
  308.  *  object's class (via somDeallocate) after uninitialization.
  309.  *  As with somDefaultInit, a null ctrl can be passed.
  310.  */
  311.    SOM_ResolveD(this,SOMR,SOMObject,somDestruct)
  312.     (this,doFree,ctrl);
  313. }
  314.  
  315.  
  316. /* initializer method: somDefaultCopyInit */
  317. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  318.         SOMObject* fromObj)
  319. {
  320. /*
  321.  *  A default copy constructor. Use this to make copies of objects for
  322.  *  calling methods with "by-value" argument semantics.
  323.  */
  324.    SOM_ResolveD(this,SOMR,SOMObject,somDefaultCopyInit)
  325.     (this,ctrl,fromObj);
  326. }
  327.  
  328.  
  329. /* method: somDefaultAssign */
  330. SOMR*  somDefaultAssign(som3AssignCtrl* ctrl, 
  331.         SOMObject* fromObj)
  332. {
  333. /*
  334.  *  A default assignment operator. Use this to "assign" the state of one
  335.  *  object to another.
  336.  */
  337.    return SOM_ResolveD(this,SOMR,SOMObject,somDefaultAssign)
  338.     (this,ctrl,fromObj);
  339. }
  340.  
  341.  
  342. /* initializer method: somDefaultConstCopyInit */
  343. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  344.         SOMObject* fromObj)
  345. {
  346. /*
  347.  *  A default copy constructor that uses a const fromObj.
  348.  */
  349.    SOM_ResolveD(this,SOMR,SOMObject,somDefaultConstCopyInit)
  350.     (this,ctrl,fromObj);
  351. }
  352.  
  353.  
  354. /* initializer method: somDefaultVCopyInit */
  355. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  356.         SOMObject* fromObj)
  357. {
  358. /*
  359.  *  A default copy constructor that uses a volatile fromObj.
  360.  */
  361.    SOM_ResolveD(this,SOMR,SOMObject,somDefaultVCopyInit)
  362.     (this,ctrl,fromObj);
  363. }
  364.  
  365.  
  366. /* initializer method: somDefaultConstVCopyInit */
  367. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  368.         SOMObject* fromObj)
  369. {
  370. /*
  371.  *  A default copy constructor that uses a const volatile fromObj.
  372.  */
  373.    SOM_ResolveD(this,SOMR,SOMObject,somDefaultConstVCopyInit)
  374.     (this,ctrl,fromObj);
  375. }
  376.  
  377.  
  378. /* method: somDefaultConstAssign */
  379. SOMR*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  380.         SOMObject* fromObj)
  381. {
  382. /*
  383.  *  A default assignment operator that uses a const fromObj.
  384.  */
  385.    return SOM_ResolveD(this,SOMR,SOMObject,somDefaultConstAssign)
  386.     (this,ctrl,fromObj);
  387. }
  388.  
  389.  
  390. /* method: somDefaultVAssign */
  391. SOMR*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  392.         SOMObject* fromObj)
  393. {
  394. /*
  395.  *  A default assignment operator that uses a volatile fromObj.
  396.  */
  397.    return SOM_ResolveD(this,SOMR,SOMObject,somDefaultVAssign)
  398.     (this,ctrl,fromObj);
  399. }
  400.  
  401.  
  402. /* method: somDefaultConstVAssign */
  403. SOMR*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  404.         SOMObject* fromObj)
  405. {
  406. /*
  407.  *  A default assignment operator that uses a const volatile fromObj.
  408.  */
  409.    return SOM_ResolveD(this,SOMR,SOMObject,somDefaultConstVAssign)
  410.     (this,ctrl,fromObj);
  411. }
  412.  
  413.  
  414. /* method: somInit */
  415. void   somInit()
  416. {
  417. /*
  418.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  419.  */
  420.    SOM_ResolveD(this,SOMR,SOMObject,somInit)
  421.     (this);
  422. }
  423.  
  424.  
  425. /* method: somFree */
  426. void   somFree()
  427. {
  428. /*
  429.  *  Use as directed by framework implementations.
  430.  */
  431.    SOM_ResolveD(this,SOMR,SOMObject,somFree)
  432.     (this);
  433. }
  434.  
  435.  
  436. /* method: somUninit */
  437. void   somUninit()
  438. {
  439. /*
  440.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  441.  */
  442.    SOM_ResolveD(this,SOMR,SOMObject,somUninit)
  443.     (this);
  444. }
  445.  
  446.  
  447. /* method: somGetClass */
  448. SOMMSingleInstance*  somGetClass()
  449. {
  450. /*
  451.  *  Return the receiver's class.
  452.  */
  453.    return SOM_ResolveD(this,SOMR,SOMObject,somGetClass)
  454.     (this);
  455. }
  456.  
  457.  
  458. /* method: somGetClassName */
  459. string   somGetClassName()
  460. {
  461. /*
  462.  *  Return the name of the receiver's class.
  463.  */
  464.    return SOM_ResolveD(this,SOMR,SOMObject,somGetClassName)
  465.     (this);
  466. }
  467.  
  468.  
  469. /* method: somGetSize */
  470. long   somGetSize()
  471. {
  472. /*
  473.  *  Return the size of the receiver.
  474.  */
  475.    return SOM_ResolveD(this,SOMR,SOMObject,somGetSize)
  476.     (this);
  477. }
  478.  
  479.  
  480. /* method: somIsA */
  481. boolean   somIsA(SOMClass* aClassObj)
  482. {
  483. /*
  484.  *  Returns 1 (true) if the receiver responds to methods
  485.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  486.  */
  487.    return SOM_ResolveD(this,SOMR,SOMObject,somIsA)
  488.     (this,aClassObj);
  489. }
  490.  
  491.  
  492. /* method: somIsInstanceOf */
  493. boolean   somIsInstanceOf(SOMClass* aClassObj)
  494. {
  495. /*
  496.  *  Returns 1 (true) if the receiver is an instance of
  497.  *  <aClassObj> and 0 (false) otherwise.
  498.  */
  499.    return SOM_ResolveD(this,SOMR,SOMObject,somIsInstanceOf)
  500.     (this,aClassObj);
  501. }
  502.  
  503.  
  504. /* method: somRespondsTo */
  505. boolean   somRespondsTo(somId mId)
  506. {
  507. /*
  508.  *  Returns 1 (true) if the indicated method can be invoked
  509.  *  on the receiver and 0 (false) otherwise.
  510.  */
  511.    return SOM_ResolveD(this,SOMR,SOMObject,somRespondsTo)
  512.     (this,mId);
  513. }
  514.  
  515.  
  516. /* va_list method: somDispatch */
  517.  
  518. /*
  519.  *  This method provides a generic, class-specific dispatch mechanism.
  520.  *  It accepts as input <retValue> a pointer to the memory area to be
  521.  *  loaded with the result of dispatching the method indicated by
  522.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  523.  *  on which the method is to be invoked as the first argument.
  524.  */
  525. /* the va_list invocation form */
  526. boolean   SOMR_somDispatch(somToken* retValue, 
  527.         somId methodId, 
  528.         va_list ap)
  529. {return SOM_ResolveD(this,SOMR,SOMObject,somDispatch)
  530.     (this,retValue,methodId,ap);
  531. }
  532.  
  533. /* the varargs invocation form */
  534. boolean   somDispatch(somToken* retValue, 
  535.         somId methodId, 
  536.         ...)
  537. {
  538. /*
  539.  *  This method provides a generic, class-specific dispatch mechanism.
  540.  *  It accepts as input <retValue> a pointer to the memory area to be
  541.  *  loaded with the result of dispatching the method indicated by
  542.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  543.  *  on which the method is to be invoked as the first argument.
  544.  */
  545.    va_list ap;
  546.    va_start(ap, methodId);
  547.    boolean __somResult = 
  548.       SOM_ResolveD(this,SOMR,SOMObject,somDispatch)
  549.     (this,retValue,methodId,ap);
  550.    va_end(ap);
  551.    return __somResult;
  552. }
  553.  
  554.  
  555. /* va_list method: somClassDispatch */
  556.  
  557. /*
  558.  *  Like somDispatch, but method resolution for static methods is done
  559.  *  according to the clsObj instance method table.
  560.  */
  561. /* the va_list invocation form */
  562. boolean   SOMR_somClassDispatch(SOMClass* clsObj, 
  563.         somToken* retValue, 
  564.         somId methodId, 
  565.         va_list ap)
  566. {return SOM_ResolveD(this,SOMR,SOMObject,somClassDispatch)
  567.     (this,clsObj,retValue,methodId,ap);
  568. }
  569.  
  570. /* the varargs invocation form */
  571. boolean   somClassDispatch(SOMClass* clsObj, 
  572.         somToken* retValue, 
  573.         somId methodId, 
  574.         ...)
  575. {
  576. /*
  577.  *  Like somDispatch, but method resolution for static methods is done
  578.  *  according to the clsObj instance method table.
  579.  */
  580.    va_list ap;
  581.    va_start(ap, methodId);
  582.    boolean __somResult = 
  583.       SOM_ResolveD(this,SOMR,SOMObject,somClassDispatch)
  584.     (this,clsObj,retValue,methodId,ap);
  585.    va_end(ap);
  586.    return __somResult;
  587. }
  588.  
  589.  
  590. /* method: somCastObj */
  591. boolean   somCastObj(SOMClass* cls)
  592. {
  593. /*
  594.  *  cast the receiving object to cls (which must be an ancestor of the
  595.  *  objects true class. Returns true on success.
  596.  */
  597.    return SOM_ResolveD(this,SOMR,SOMObject,somCastObj)
  598.     (this,cls);
  599. }
  600.  
  601.  
  602. /* method: somResetObj */
  603. boolean   somResetObj()
  604. {
  605. /*
  606.  *  reset an object to its true class. Returns true always.
  607.  */
  608.    return SOM_ResolveD(this,SOMR,SOMObject,somResetObj)
  609.     (this);
  610. }
  611.  
  612.  
  613. /* va_list method: somDispatchV */
  614.  
  615. /*
  616.  *  Obsolete. Use somDispatch instead.
  617.  */
  618. /* the va_list invocation form */
  619. void   SOMR_somDispatchV(somId methodId, 
  620.         somId descriptor, 
  621.         va_list ap)
  622. {   SOM_ResolveD(this,SOMR,SOMObject,somDispatchV)
  623.     (this,methodId,descriptor,ap);
  624. }
  625.  
  626. /* the varargs invocation form */
  627. void   somDispatchV(somId methodId, 
  628.         somId descriptor, 
  629.         ...)
  630. {
  631. /*
  632.  *  Obsolete. Use somDispatch instead.
  633.  */
  634.    va_list ap;
  635.    va_start(ap, descriptor);
  636.    SOM_ResolveD(this,SOMR,SOMObject,somDispatchV)
  637.     (this,methodId,descriptor,ap);
  638.    va_end(ap);
  639. }
  640.  
  641.  
  642. /* va_list method: somDispatchL */
  643.  
  644. /*
  645.  *  Obsolete. Use somDispatch instead.
  646.  */
  647. /* the va_list invocation form */
  648. long   SOMR_somDispatchL(somId methodId, 
  649.         somId descriptor, 
  650.         va_list ap)
  651. {return SOM_ResolveD(this,SOMR,SOMObject,somDispatchL)
  652.     (this,methodId,descriptor,ap);
  653. }
  654.  
  655. /* the varargs invocation form */
  656. long   somDispatchL(somId methodId, 
  657.         somId descriptor, 
  658.         ...)
  659. {
  660. /*
  661.  *  Obsolete. Use somDispatch instead.
  662.  */
  663.    va_list ap;
  664.    va_start(ap, descriptor);
  665.    long __somResult = 
  666.       SOM_ResolveD(this,SOMR,SOMObject,somDispatchL)
  667.     (this,methodId,descriptor,ap);
  668.    va_end(ap);
  669.    return __somResult;
  670. }
  671.  
  672.  
  673. /* va_list method: somDispatchA */
  674.  
  675. /*
  676.  *  Obsolete. Use somDispatch instead.
  677.  */
  678. /* the va_list invocation form */
  679. void*   SOMR_somDispatchA(somId methodId, 
  680.         somId descriptor, 
  681.         va_list ap)
  682. {return SOM_ResolveD(this,SOMR,SOMObject,somDispatchA)
  683.     (this,methodId,descriptor,ap);
  684. }
  685.  
  686. /* the varargs invocation form */
  687. void*   somDispatchA(somId methodId, 
  688.         somId descriptor, 
  689.         ...)
  690. {
  691. /*
  692.  *  Obsolete. Use somDispatch instead.
  693.  */
  694.    va_list ap;
  695.    va_start(ap, descriptor);
  696.    void* __somResult = 
  697.       SOM_ResolveD(this,SOMR,SOMObject,somDispatchA)
  698.     (this,methodId,descriptor,ap);
  699.    va_end(ap);
  700.    return __somResult;
  701. }
  702.  
  703.  
  704. /* va_list method: somDispatchD */
  705.  
  706. /*
  707.  *  Obsolete. Use somDispatch instead.
  708.  */
  709. /* the va_list invocation form */
  710. double   SOMR_somDispatchD(somId methodId, 
  711.         somId descriptor, 
  712.         va_list ap)
  713. {return SOM_ResolveD(this,SOMR,SOMObject,somDispatchD)
  714.     (this,methodId,descriptor,ap);
  715. }
  716.  
  717. /* the varargs invocation form */
  718. double   somDispatchD(somId methodId, 
  719.         somId descriptor, 
  720.         ...)
  721. {
  722. /*
  723.  *  Obsolete. Use somDispatch instead.
  724.  */
  725.    va_list ap;
  726.    va_start(ap, descriptor);
  727.    double __somResult = 
  728.       SOM_ResolveD(this,SOMR,SOMObject,somDispatchD)
  729.     (this,methodId,descriptor,ap);
  730.    va_end(ap);
  731.    return __somResult;
  732. }
  733.  
  734.  
  735. /* method: somPrintSelf */
  736. SOMObject*   somPrintSelf()
  737. {
  738. /*
  739.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  740.  *  information about this object.  The default implementation just gives
  741.  *  the object's class name and its address in memory.
  742.  *  <self> is returned.
  743.  */
  744.    return SOM_ResolveD(this,SOMR,SOMObject,somPrintSelf)
  745.     (this);
  746. }
  747.  
  748.  
  749. /* method: somDumpSelf */
  750. void   somDumpSelf(long level)
  751. {
  752. /*
  753.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  754.  *  and its current state.
  755.  * 
  756.  *  <level> indicates the nesting level for describing compound objects
  757.  *  it must be greater than or equal to zero.  All lines in the
  758.  *  description will be preceeded by <2*level> spaces.
  759.  * 
  760.  *  This routine only actually writes the data that concerns the object
  761.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  762.  *  the object's current state.  This approach allows readable
  763.  *  descriptions of compound objects to be constructed.
  764.  * 
  765.  *  Generally it is not necessary to override this method, if it is
  766.  *  overriden it generally must be completely replaced.
  767.  */
  768.    SOM_ResolveD(this,SOMR,SOMObject,somDumpSelf)
  769.     (this,level);
  770. }
  771.  
  772.  
  773. /* method: somDumpSelfInt */
  774. void   somDumpSelfInt(long level)
  775. {
  776. /*
  777.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  778.  *  Generally this method will need to be overridden.  When overriding
  779.  *  it, begin by calling the parent class form of this method and then
  780.  *  write in a description of your class's instance data. This will
  781.  *  result in a description of all the object's instance data going
  782.  *  from its root ancestor class to its specific class.
  783.  */
  784.    SOM_ResolveD(this,SOMR,SOMObject,somDumpSelfInt)
  785.     (this,level);
  786. }
  787.  
  788.  
  789.  
  790. };   /* SOMR */
  791.  
  792.  
  793.  
  794. #endif       /* SOM_SOMR_xh */
  795.