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