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