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