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