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