home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / tseq.xh < prev    next >
Text File  |  1999-02-22  |  35KB  |  1,137 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: tseq.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.17
  7.  *     SOM Emitter emitxh: 2.47
  8.  */
  9.  
  10. /*
  11.  *    COMPONENT_NAME: somuc
  12.  * 
  13.  *    ORIGINS: 82, 81, 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.  *   Copyright ⌐ 1988-92 Apple Computer, Inc.  All rights reserved.
  23.  * 
  24.  * CLASS_NAME: somf_TSequence
  25.  * 
  26.  * DESCRIPTION: TSequence is an abstract superclass for collections whose
  27.  *              elements are ordered.
  28.  * 
  29.  */
  30.  
  31.  
  32. #ifndef SOM_somf_TSequence_xh
  33. #define SOM_somf_TSequence_xh
  34.  
  35. class somf_TSequence;
  36.  
  37. #define somf_TSequence_MajorVersion 2
  38. #define somf_TSequence_MinorVersion 1
  39.  
  40. /*
  41.  * Passthru lines: File: "C.xh", "before"
  42.  */
  43.  
  44. #include <mcollect.xh>
  45.  
  46. /* C++ SOM defs */
  47. #include <somcls.xh>
  48. #include <somcm.xh>
  49.  
  50. /* C++ parent defs */
  51. #ifndef SOM_somf_TCollection_xh
  52. #include <tcollect.xh>
  53. #endif
  54.  
  55. #ifndef somf_TSequence_API
  56. #define somf_TSequence_API
  57. /*
  58.  * -- The Class API
  59.  */
  60.  
  61. /*
  62.  * Start of bindings for IDL types
  63.  */
  64.  
  65. class SOMClass;
  66. class SOMObject;
  67. class somf_TIterator;
  68.  
  69. /*
  70.  * End of bindings for IDL types.
  71.  */
  72.  
  73. /* A procedure to create the somf_TSequence Class */
  74. SOMEXTERN SOMClass * SOMLINK somf_TSequenceNewClass(
  75.         integer4 majorVersion,
  76.         integer4 minorVersion);
  77.  
  78. /* The API to the somf_TSequence class object, and the methods it introduces. */
  79. SOMEXTERN struct somf_TSequenceClassDataStructure {
  80.     SOMClass *classObject;
  81.     somMToken somfFirst;
  82.     somMToken somfAfter;
  83.     somMToken somfBefore;
  84.     somMToken somfLast;
  85.     somMToken somfOccurrencesOf;
  86.     somMToken somfTSequenceInit;
  87. } SOMDLINK somf_TSequenceClassData;
  88. #define _somf_TSequence somf_TSequenceClassData.classObject
  89.  
  90. /* The API to parentMtabs for somf_TSequence, and the instance data it introduces. */
  91. SOMEXTERN struct somf_TSequenceCClassDataStructure {
  92.     somMethodTabs parentMtab;
  93.     somDToken              instanceDataToken;
  94. } SOMDLINK somf_TSequenceCClassData;
  95.  
  96. /*
  97.  * -- Typedefs for somf_TSequence Method Procedures
  98.  */
  99. SOMEXTERN {
  100. typedef somf_MCollectible*   SOMLINK somTP_somf_TSequence_somfAfter(somf_TSequence *somSelf, Environment *ev, 
  101.         somf_MCollectible* obj);
  102. typedef somTP_somf_TSequence_somfAfter *somTD_somf_TSequence_somfAfter;
  103. typedef somf_MCollectible*   SOMLINK somTP_somf_TSequence_somfBefore(somf_TSequence *somSelf, Environment *ev, 
  104.         somf_MCollectible* obj);
  105. typedef somTP_somf_TSequence_somfBefore *somTD_somf_TSequence_somfBefore;
  106. typedef somf_MCollectible*   SOMLINK somTP_somf_TSequence_somfLast(somf_TSequence *somSelf, Environment *ev);
  107. typedef somTP_somf_TSequence_somfLast *somTD_somf_TSequence_somfLast;
  108. typedef somf_MCollectible*   SOMLINK somTP_somf_TSequence_somfFirst(somf_TSequence *somSelf, Environment *ev);
  109. typedef somTP_somf_TSequence_somfFirst *somTD_somf_TSequence_somfFirst;
  110. typedef long   SOMLINK somTP_somf_TSequence_somfOccurrencesOf(somf_TSequence *somSelf, Environment *ev, 
  111.         somf_MCollectible* obj);
  112. typedef somTP_somf_TSequence_somfOccurrencesOf *somTD_somf_TSequence_somfOccurrencesOf;
  113. typedef somf_TSequence*   SOMLINK somTP_somf_TSequence_somfTSequenceInit(somf_TSequence *somSelf, Environment *ev, 
  114.         somf_MCollectible_somf_MCollectibleCompareFn testfn);
  115. typedef somTP_somf_TSequence_somfTSequenceInit *somTD_somf_TSequence_somfTSequenceInit;
  116.  
  117. /*
  118.  * -- Typedefs for Reintroduced Wrapper Methods
  119.  */
  120. typedef somf_MCollectible*   SOMLINK somTP_somf_TSequence_somfAdd(somf_TSequence *somSelf, Environment *ev, 
  121.         somf_MCollectible* obj);
  122. typedef somTP_somf_TSequence_somfAdd *somTD_somf_TSequence_somfAdd;
  123. typedef void   SOMLINK somTP_somf_TSequence_somfAddAll(somf_TSequence *somSelf, Environment *ev, 
  124.         somf_TCollection* col);
  125. typedef somTP_somf_TSequence_somfAddAll *somTD_somf_TSequence_somfAddAll;
  126. typedef somf_MCollectible*   SOMLINK somTP_somf_TSequence_somfRemove(somf_TSequence *somSelf, Environment *ev, 
  127.         somf_MCollectible* obj);
  128. typedef somTP_somf_TSequence_somfRemove *somTD_somf_TSequence_somfRemove;
  129. typedef void   SOMLINK somTP_somf_TSequence_somfRemoveAll(somf_TSequence *somSelf, Environment *ev);
  130. typedef somTP_somf_TSequence_somfRemoveAll *somTD_somf_TSequence_somfRemoveAll;
  131. typedef void   SOMLINK somTP_somf_TSequence_somfDeleteAll(somf_TSequence *somSelf, Environment *ev);
  132. typedef somTP_somf_TSequence_somfDeleteAll *somTD_somf_TSequence_somfDeleteAll;
  133. typedef long   SOMLINK somTP_somf_TSequence_somfCount(somf_TSequence *somSelf, Environment *ev);
  134. typedef somTP_somf_TSequence_somfCount *somTD_somf_TSequence_somfCount;
  135. typedef somf_MCollectible*   SOMLINK somTP_somf_TSequence_somfMember(somf_TSequence *somSelf, Environment *ev, 
  136.         somf_MCollectible* obj);
  137. typedef somTP_somf_TSequence_somfMember *somTD_somf_TSequence_somfMember;
  138. typedef somf_TIterator*   SOMLINK somTP_somf_TSequence_somfCreateIterator(somf_TSequence *somSelf, Environment *ev);
  139. typedef somTP_somf_TSequence_somfCreateIterator *somTD_somf_TSequence_somfCreateIterator;
  140. typedef somf_MCollectible_somf_MCollectibleCompareFn   SOMLINK somTP_somf_TSequence_somfTestFunction(somf_TSequence *somSelf, Environment *ev);
  141. typedef somTP_somf_TSequence_somfTestFunction *somTD_somf_TSequence_somfTestFunction;
  142. typedef void   SOMLINK somTP_somf_TSequence_somfSetTestFunction(somf_TSequence *somSelf, Environment *ev, 
  143.         somf_MCollectible_somf_MCollectibleCompareFn testfn);
  144. typedef somTP_somf_TSequence_somfSetTestFunction *somTD_somf_TSequence_somfSetTestFunction;
  145. typedef somf_TCollection*   SOMLINK somTP_somf_TSequence_somfTCollectionInit(somf_TSequence *somSelf, Environment *ev, 
  146.         somf_MCollectible_somf_MCollectibleCompareFn testfn);
  147. typedef somTP_somf_TSequence_somfTCollectionInit *somTD_somf_TSequence_somfTCollectionInit;
  148. typedef boolean   SOMLINK somTP_somf_TSequence_somfIsEqual(somf_TSequence *somSelf, Environment *ev, 
  149.         somf_MCollectible* obj);
  150. typedef somTP_somf_TSequence_somfIsEqual *somTD_somf_TSequence_somfIsEqual;
  151. typedef somf_MCollectible*   SOMLINK somTP_somf_TSequence_somfClone(somf_TSequence *somSelf, Environment *ev);
  152. typedef somTP_somf_TSequence_somfClone *somTD_somf_TSequence_somfClone;
  153. typedef somf_MCollectible*   SOMLINK somTP_somf_TSequence_somfClonePointer(somf_TSequence *somSelf, Environment *ev, 
  154.         somf_MCollectible* clonee);
  155. typedef somTP_somf_TSequence_somfClonePointer *somTD_somf_TSequence_somfClonePointer;
  156. typedef long   SOMLINK somTP_somf_TSequence_somfHash(somf_TSequence *somSelf, Environment *ev);
  157. typedef somTP_somf_TSequence_somfHash *somTD_somf_TSequence_somfHash;
  158. typedef boolean   SOMLINK somTP_somf_TSequence_somfIsSame(somf_TSequence *somSelf, Environment *ev, 
  159.         somf_MCollectible* obj);
  160. typedef somTP_somf_TSequence_somfIsSame *somTD_somf_TSequence_somfIsSame;
  161. typedef boolean   SOMLINK somTP_somf_TSequence_somfIsNotEqual(somf_TSequence *somSelf, Environment *ev, 
  162.         somf_MCollectible* obj);
  163. typedef somTP_somf_TSequence_somfIsNotEqual *somTD_somf_TSequence_somfIsNotEqual;
  164. typedef void   SOMLINK somTP_somf_TSequence_somDefaultInit(somf_TSequence *somSelf, 
  165.         som3InitCtrl* ctrl);
  166. typedef somTP_somf_TSequence_somDefaultInit *somTD_somf_TSequence_somDefaultInit;
  167. typedef void   SOMLINK somTP_somf_TSequence_somDestruct(somf_TSequence *somSelf, 
  168.         octet doFree, 
  169.         som3DestructCtrl* ctrl);
  170. typedef somTP_somf_TSequence_somDestruct *somTD_somf_TSequence_somDestruct;
  171. typedef void   SOMLINK somTP_somf_TSequence_somDefaultCopyInit(somf_TSequence *somSelf, 
  172.         som3InitCtrl* ctrl, 
  173.         SOMObject* fromObj);
  174. typedef somTP_somf_TSequence_somDefaultCopyInit *somTD_somf_TSequence_somDefaultCopyInit;
  175. typedef somf_TSequence*   SOMLINK somTP_somf_TSequence_somDefaultAssign(somf_TSequence *somSelf, 
  176.         som3AssignCtrl* ctrl, 
  177.         SOMObject* fromObj);
  178. typedef somTP_somf_TSequence_somDefaultAssign *somTD_somf_TSequence_somDefaultAssign;
  179. typedef void   SOMLINK somTP_somf_TSequence_somDefaultConstCopyInit(somf_TSequence *somSelf, 
  180.         som3InitCtrl* ctrl, 
  181.         SOMObject* fromObj);
  182. typedef somTP_somf_TSequence_somDefaultConstCopyInit *somTD_somf_TSequence_somDefaultConstCopyInit;
  183. typedef void   SOMLINK somTP_somf_TSequence_somDefaultVCopyInit(somf_TSequence *somSelf, 
  184.         som3InitCtrl* ctrl, 
  185.         SOMObject* fromObj);
  186. typedef somTP_somf_TSequence_somDefaultVCopyInit *somTD_somf_TSequence_somDefaultVCopyInit;
  187. typedef void   SOMLINK somTP_somf_TSequence_somDefaultConstVCopyInit(somf_TSequence *somSelf, 
  188.         som3InitCtrl* ctrl, 
  189.         SOMObject* fromObj);
  190. typedef somTP_somf_TSequence_somDefaultConstVCopyInit *somTD_somf_TSequence_somDefaultConstVCopyInit;
  191. typedef somf_TSequence*   SOMLINK somTP_somf_TSequence_somDefaultConstAssign(somf_TSequence *somSelf, 
  192.         som3AssignCtrl* ctrl, 
  193.         SOMObject* fromObj);
  194. typedef somTP_somf_TSequence_somDefaultConstAssign *somTD_somf_TSequence_somDefaultConstAssign;
  195. typedef somf_TSequence*   SOMLINK somTP_somf_TSequence_somDefaultVAssign(somf_TSequence *somSelf, 
  196.         som3AssignCtrl* ctrl, 
  197.         SOMObject* fromObj);
  198. typedef somTP_somf_TSequence_somDefaultVAssign *somTD_somf_TSequence_somDefaultVAssign;
  199. typedef somf_TSequence*   SOMLINK somTP_somf_TSequence_somDefaultConstVAssign(somf_TSequence *somSelf, 
  200.         som3AssignCtrl* ctrl, 
  201.         SOMObject* fromObj);
  202. typedef somTP_somf_TSequence_somDefaultConstVAssign *somTD_somf_TSequence_somDefaultConstVAssign;
  203. typedef void   SOMLINK somTP_somf_TSequence_somInit(somf_TSequence *somSelf);
  204. typedef somTP_somf_TSequence_somInit *somTD_somf_TSequence_somInit;
  205. typedef void   SOMLINK somTP_somf_TSequence_somFree(somf_TSequence *somSelf);
  206. typedef somTP_somf_TSequence_somFree *somTD_somf_TSequence_somFree;
  207. typedef void   SOMLINK somTP_somf_TSequence_somUninit(somf_TSequence *somSelf);
  208. typedef somTP_somf_TSequence_somUninit *somTD_somf_TSequence_somUninit;
  209. typedef SOMClass*   SOMLINK somTP_somf_TSequence_somGetClass(somf_TSequence *somSelf);
  210. typedef somTP_somf_TSequence_somGetClass *somTD_somf_TSequence_somGetClass;
  211. typedef string   SOMLINK somTP_somf_TSequence_somGetClassName(somf_TSequence *somSelf);
  212. typedef somTP_somf_TSequence_somGetClassName *somTD_somf_TSequence_somGetClassName;
  213. typedef long   SOMLINK somTP_somf_TSequence_somGetSize(somf_TSequence *somSelf);
  214. typedef somTP_somf_TSequence_somGetSize *somTD_somf_TSequence_somGetSize;
  215. typedef boolean   SOMLINK somTP_somf_TSequence_somIsA(somf_TSequence *somSelf, 
  216.         SOMClass* aClassObj);
  217. typedef somTP_somf_TSequence_somIsA *somTD_somf_TSequence_somIsA;
  218. typedef boolean   SOMLINK somTP_somf_TSequence_somIsInstanceOf(somf_TSequence *somSelf, 
  219.         SOMClass* aClassObj);
  220. typedef somTP_somf_TSequence_somIsInstanceOf *somTD_somf_TSequence_somIsInstanceOf;
  221. typedef boolean   SOMLINK somTP_somf_TSequence_somRespondsTo(somf_TSequence *somSelf, 
  222.         somId mId);
  223. typedef somTP_somf_TSequence_somRespondsTo *somTD_somf_TSequence_somRespondsTo;
  224. typedef boolean   SOMLINK somTP_somf_TSequence_somDispatch(somf_TSequence *somSelf, 
  225.         somToken* retValue, 
  226.         somId methodId, 
  227.         va_list ap);
  228. typedef somTP_somf_TSequence_somDispatch *somTD_somf_TSequence_somDispatch;
  229. typedef boolean   SOMLINK somTP_somf_TSequence_somClassDispatch(somf_TSequence *somSelf, 
  230.         SOMClass* clsObj, 
  231.         somToken* retValue, 
  232.         somId methodId, 
  233.         va_list ap);
  234. typedef somTP_somf_TSequence_somClassDispatch *somTD_somf_TSequence_somClassDispatch;
  235. typedef boolean   SOMLINK somTP_somf_TSequence_somCastObj(somf_TSequence *somSelf, 
  236.         SOMClass* cls);
  237. typedef somTP_somf_TSequence_somCastObj *somTD_somf_TSequence_somCastObj;
  238. typedef boolean   SOMLINK somTP_somf_TSequence_somResetObj(somf_TSequence *somSelf);
  239. typedef somTP_somf_TSequence_somResetObj *somTD_somf_TSequence_somResetObj;
  240. typedef void   SOMLINK somTP_somf_TSequence_somDispatchV(somf_TSequence *somSelf, 
  241.         somId methodId, 
  242.         somId descriptor, 
  243.         va_list ap);
  244. typedef somTP_somf_TSequence_somDispatchV *somTD_somf_TSequence_somDispatchV;
  245. typedef long   SOMLINK somTP_somf_TSequence_somDispatchL(somf_TSequence *somSelf, 
  246.         somId methodId, 
  247.         somId descriptor, 
  248.         va_list ap);
  249. typedef somTP_somf_TSequence_somDispatchL *somTD_somf_TSequence_somDispatchL;
  250. typedef void*   SOMLINK somTP_somf_TSequence_somDispatchA(somf_TSequence *somSelf, 
  251.         somId methodId, 
  252.         somId descriptor, 
  253.         va_list ap);
  254. typedef somTP_somf_TSequence_somDispatchA *somTD_somf_TSequence_somDispatchA;
  255. typedef double   SOMLINK somTP_somf_TSequence_somDispatchD(somf_TSequence *somSelf, 
  256.         somId methodId, 
  257.         somId descriptor, 
  258.         va_list ap);
  259. typedef somTP_somf_TSequence_somDispatchD *somTD_somf_TSequence_somDispatchD;
  260. typedef SOMObject*   SOMLINK somTP_somf_TSequence_somPrintSelf(somf_TSequence *somSelf);
  261. typedef somTP_somf_TSequence_somPrintSelf *somTD_somf_TSequence_somPrintSelf;
  262. typedef void   SOMLINK somTP_somf_TSequence_somDumpSelf(somf_TSequence *somSelf, 
  263.         long level);
  264. typedef somTP_somf_TSequence_somDumpSelf *somTD_somf_TSequence_somDumpSelf;
  265. typedef void   SOMLINK somTP_somf_TSequence_somDumpSelfInt(somf_TSequence *somSelf, 
  266.         long level);
  267. typedef somTP_somf_TSequence_somDumpSelfInt *somTD_somf_TSequence_somDumpSelfInt;
  268. }
  269.  
  270. #endif /* somf_TSequence_API */
  271.  
  272.  
  273. /*
  274.  * -- This emitter treats Method Tokens as Thunks by default.
  275.  * -- Use the sc modifier "nothunks" to change this default
  276.  */
  277. #undef somresolve_
  278. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  279.  
  280. /*
  281.  * -- The C++ Wrapper Class for somf_TSequence
  282.  */
  283. class somf_TSequence : public somf_TCollection
  284. {
  285. public:
  286.  
  287. // somf_TSequence::new creates the class object if necessary, and then uses somNewNoInit
  288. // to allocate memory and create the object. Initialization is in ctors.
  289. void *operator new(size_t)
  290. {
  291.    if (!_somf_TSequence) somf_TSequenceNewClass(somf_TSequence_MajorVersion,somf_TSequence_MinorVersion);
  292.    return (void*)
  293.       SOM_Resolve(_somf_TSequence,SOMClass,somNewNoInit)
  294.          ((SOMClass *)((void*)_somf_TSequence));
  295. }
  296.  
  297. // somf_TSequence::delete uses somDestruct.
  298. void operator delete(void * obj)
  299. {
  300.    if (obj && *(void**)obj) {
  301.       SOM_Resolve(obj,SOMObject,somFree)
  302.          ((SOMObject*)obj);
  303.    }
  304. }
  305.  
  306. somf_TSequence& operator=(somf_TSequence& fromObj)
  307. {
  308.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  309.    return *this;
  310. }
  311.  
  312. somf_TSequence()
  313. {
  314.    if (*(void**)this != 
  315.        ((somParentMtabStructPtr)
  316.         (somf_TSequenceCClassData.parentMtab))->mtab)
  317.       return;
  318.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  319. }
  320.  
  321. somf_TSequence(somf_TSequence* fromObj)
  322. {
  323.    if (*(void**)this != 
  324.        ((somParentMtabStructPtr)
  325.         (somf_TSequenceCClassData.parentMtab))->mtab)
  326.       return;
  327.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  328. }
  329.  
  330. #ifdef __IBMCPP__
  331. #pragma info(nocnv,nopar)
  332. #endif
  333. somf_TSequence(const somf_TSequence* fromObj)
  334. {
  335.    if (*(void**)this != 
  336.        ((somParentMtabStructPtr)
  337.         (somf_TSequenceCClassData.parentMtab))->mtab)
  338.       return;
  339.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  340. }
  341. #ifdef __IBMCPP__
  342. #pragma info(restore)
  343. #endif
  344.  
  345.  
  346. /* method: somfAfter */
  347. somf_MCollectible*   somfAfter(Environment *ev, 
  348.         somf_MCollectible* obj)
  349. {
  350. /*
  351.  *  Return the object found after obj.
  352.  */
  353.    return SOM_ResolveD(this,somf_TSequence,somf_TSequence,somfAfter)
  354.     (this, ev,obj);
  355. }
  356.  
  357.  
  358. /* method: somfBefore */
  359. somf_MCollectible*   somfBefore(Environment *ev, 
  360.         somf_MCollectible* obj)
  361. {
  362. /*
  363.  *  Return the object found before obj.
  364.  */
  365.    return SOM_ResolveD(this,somf_TSequence,somf_TSequence,somfBefore)
  366.     (this, ev,obj);
  367. }
  368.  
  369.  
  370. /* method: somfLast */
  371. somf_MCollectible*   somfLast(Environment *ev)
  372. {
  373. /*
  374.  *  Determine the last object in this.
  375.  */
  376.    return SOM_ResolveD(this,somf_TSequence,somf_TSequence,somfLast)
  377.     (this, ev);
  378. }
  379.  
  380.  
  381. /* method: somfFirst */
  382. somf_MCollectible*   somfFirst(Environment *ev)
  383. {
  384. /*
  385.  *  Determine the first object in this.
  386.  */
  387.    return SOM_ResolveD(this,somf_TSequence,somf_TSequence,somfFirst)
  388.     (this, ev);
  389. }
  390.  
  391.  
  392. /* method: somfOccurrencesOf */
  393. long   somfOccurrencesOf(Environment *ev, 
  394.         somf_MCollectible* obj)
  395. {
  396. /*
  397.  *  Determine the number of times obj is in this.
  398.  */
  399.    return SOM_ResolveD(this,somf_TSequence,somf_TSequence,somfOccurrencesOf)
  400.     (this, ev,obj);
  401. }
  402.  
  403.  
  404. /* method: somfTSequenceInit */
  405. somf_TSequence*   somfTSequenceInit(Environment *ev, 
  406.         somf_MCollectible_somf_MCollectibleCompareFn testfn)
  407. {
  408. /*
  409.  *  This method initializes a new TSequence.
  410.  */
  411.    return SOM_ResolveD(this,somf_TSequence,somf_TSequence,somfTSequenceInit)
  412.     (this, ev,testfn);
  413. }
  414.  
  415.  
  416. /*
  417.  * Reintroduce inherited methods
  418.  */
  419.  
  420. /* method: somfAdd */
  421. somf_MCollectible*   somfAdd(Environment *ev, 
  422.         somf_MCollectible* obj)
  423. {
  424. /*
  425.  *  Add obj to this.
  426.  */
  427.    return SOM_ResolveD(this,somf_TSequence,somf_TCollection,somfAdd)
  428.     (this, ev,obj);
  429. }
  430.  
  431.  
  432. /* method: somfAddAll */
  433. void   somfAddAll(Environment *ev, 
  434.         somf_TCollection* col)
  435. {
  436. /*
  437.  *  Add all of the objects in collection to this.  Essentially this is
  438.  *  equivalent to getting an iterator for the collection passed in and adding
  439.  *  each element in the collection to this.
  440.  */
  441.    SOM_ResolveD(this,somf_TSequence,somf_TCollection,somfAddAll)
  442.     (this, ev,col);
  443. }
  444.  
  445.  
  446. /* method: somfRemove */
  447. somf_MCollectible*   somfRemove(Environment *ev, 
  448.         somf_MCollectible* obj)
  449. {
  450. /*
  451.  *  Remove obj from this.  Return the object which was actually removed
  452.  *  (which if you are using an IsEqual test function may not be the same as the
  453.  *  object passed in only "equal")
  454.  */
  455.    return SOM_ResolveD(this,somf_TSequence,somf_TCollection,somfRemove)
  456.     (this, ev,obj);
  457. }
  458.  
  459.  
  460. /* method: somfRemoveAll */
  461. void   somfRemoveAll(Environment *ev)
  462. {
  463. /*
  464.  *  Remove all of the objects from this.
  465.  */
  466.    SOM_ResolveD(this,somf_TSequence,somf_TCollection,somfRemoveAll)
  467.     (this, ev);
  468. }
  469.  
  470.  
  471. /* method: somfDeleteAll */
  472. void   somfDeleteAll(Environment *ev)
  473. {
  474. /*
  475.  *  Remove all of the objects from this and deallocate the storage that these
  476.  *  objects might have owned (that is, the destructor function is called
  477.  *  for each object in the collection).
  478.  */
  479.    SOM_ResolveD(this,somf_TSequence,somf_TCollection,somfDeleteAll)
  480.     (this, ev);
  481. }
  482.  
  483.  
  484. /* method: somfCount */
  485. long   somfCount(Environment *ev)
  486. {
  487. /*
  488.  *  Return the number of objects in this.
  489.  */
  490.    return SOM_ResolveD(this,somf_TSequence,somf_TCollection,somfCount)
  491.     (this, ev);
  492. }
  493.  
  494.  
  495. /* method: somfMember */
  496. somf_MCollectible*   somfMember(Environment *ev, 
  497.         somf_MCollectible* obj)
  498. {
  499. /*
  500.  *  Each object in this is compared to obj using the function testFn.  Return the
  501.  *  object for which testFn returned TRUE.  Return SOMF_NIL if not object was found.
  502.  */
  503.    return SOM_ResolveD(this,somf_TSequence,somf_TCollection,somfMember)
  504.     (this, ev,obj);
  505. }
  506.  
  507.  
  508. /* method: somfCreateIterator */
  509. somf_TIterator*   somfCreateIterator(Environment *ev)
  510. {
  511. /*
  512.  *  This method returns a new iterator which is suitable for use in iterating
  513.  *  over the objects in this collection.
  514.  */
  515.    return SOM_ResolveD(this,somf_TSequence,somf_TCollection,somfCreateIterator)
  516.     (this, ev);
  517. }
  518.  
  519.  
  520. /* method: somfTestFunction */
  521. somf_MCollectible_somf_MCollectibleCompareFn   somfTestFunction(Environment *ev)
  522. {
  523. /*
  524.  *  Return the test function.  This is usually either IsSame or IsEqual.
  525.  */
  526.    return SOM_ResolveD(this,somf_TSequence,somf_TCollection,somfTestFunction)
  527.     (this, ev);
  528. }
  529.  
  530.  
  531. /* method: somfSetTestFunction */
  532. void   somfSetTestFunction(Environment *ev, 
  533.         somf_MCollectible_somf_MCollectibleCompareFn testfn)
  534. {
  535. /*
  536.  *  Set the test function.
  537.  */
  538.    SOM_ResolveD(this,somf_TSequence,somf_TCollection,somfSetTestFunction)
  539.     (this, ev,testfn);
  540. }
  541.  
  542.  
  543. /* method: somfTCollectionInit */
  544. somf_TCollection*   somfTCollectionInit(Environment *ev, 
  545.         somf_MCollectible_somf_MCollectibleCompareFn testfn)
  546. {
  547. /*
  548.  *  Initialize the somf_TCollection test function to testfn.
  549.  */
  550.    return SOM_ResolveD(this,somf_TSequence,somf_TCollection,somfTCollectionInit)
  551.     (this, ev,testfn);
  552. }
  553.  
  554.  
  555. /* method: somfIsEqual */
  556. boolean   somfIsEqual(Environment *ev, 
  557.         somf_MCollectible* obj)
  558. {
  559.    return SOM_ResolveD(this,somf_TSequence,somf_MCollectible,somfIsEqual)
  560.     (this, ev,obj);
  561. }
  562.  
  563.  
  564. /* method: somfClone */
  565. somf_MCollectible*   somfClone(Environment *ev)
  566. {
  567. /*
  568.  *  somfClone provides a general function for creating a new instance of this.
  569.  */
  570.    return SOM_ResolveD(this,somf_TSequence,somf_MCollectible,somfClone)
  571.     (this, ev);
  572. }
  573.  
  574.  
  575. /* method: somfClonePointer */
  576. somf_MCollectible*   somfClonePointer(Environment *ev, 
  577.         somf_MCollectible* clonee)
  578. {
  579. /*
  580.  *  somfClonePointer returns a pointer to a Clone
  581.  */
  582.    return SOM_ResolveD(this,somf_TSequence,somf_MCollectible,somfClonePointer)
  583.     (this, ev,clonee);
  584. }
  585.  
  586.  
  587. /* method: somfHash */
  588. long   somfHash(Environment *ev)
  589. {
  590. /*
  591.  *  somfHash returns a value suitable for use as a hashing probe for this.
  592.  *  The default function will simply return the address of the object.
  593.  *  The default function is almost certainly not adequate if you are overriding
  594.  *  somfIsEqual because you need to make sure that all objects that "are equal"
  595.  *  to each other return the same hash value.  For example, a TText object would
  596.  *  return a hash value computed using the characters in the string instead of
  597.  *  the address of the string.
  598.  */
  599.    return SOM_ResolveD(this,somf_TSequence,somf_MCollectible,somfHash)
  600.     (this, ev);
  601. }
  602.  
  603.  
  604. /* method: somfIsSame */
  605. boolean   somfIsSame(Environment *ev, 
  606.         somf_MCollectible* obj)
  607. {
  608. /*
  609.  *  The default function for somfIsSame is a pointer comparison
  610.  */
  611.    return SOM_ResolveD(this,somf_TSequence,somf_MCollectible,somfIsSame)
  612.     (this, ev,obj);
  613. }
  614.  
  615.  
  616. /* method: somfIsNotEqual */
  617. boolean   somfIsNotEqual(Environment *ev, 
  618.         somf_MCollectible* obj)
  619. {
  620. /*
  621.  *  somfIsNotEqual returns TRUE if obj is NOT isomorphic to this.  It uses
  622.  *  somfIsEqual, so overriding somfIsEqual will handle the logic of somfIsNotEqual too.
  623.  */
  624.    return SOM_ResolveD(this,somf_TSequence,somf_MCollectible,somfIsNotEqual)
  625.     (this, ev,obj);
  626. }
  627.  
  628.  
  629. /* initializer method: somDefaultInit */
  630. void   somDefaultInit(som3InitCtrl* ctrl)
  631. {
  632. /*
  633.  *  A default initializer for a SOM object. Passing a null ctrl
  634.  *  indicates to the receiver that its class is the class of the
  635.  *  object being initialized, whereby the initializer will determine
  636.  *  an appropriate control structure.
  637.  */
  638.    SOM_ResolveD(this,somf_TSequence,SOMObject,somDefaultInit)
  639.     (this,ctrl);
  640. }
  641.  
  642.  
  643. /* method: somDestruct */
  644. void   somDestruct(octet doFree, 
  645.         som3DestructCtrl* ctrl)
  646. {
  647. /*
  648.  *  The default destructor for a SOM object. A nonzero <doFree>
  649.  *  indicates that the object storage should be freed by the
  650.  *  object's class (via somDeallocate) after uninitialization.
  651.  *  As with somDefaultInit, a null ctrl can be passed.
  652.  */
  653.    SOM_ResolveD(this,somf_TSequence,SOMObject,somDestruct)
  654.     (this,doFree,ctrl);
  655. }
  656.  
  657.  
  658. /* initializer method: somDefaultCopyInit */
  659. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  660.         SOMObject* fromObj)
  661. {
  662. /*
  663.  *  A default copy constructor. Use this to make copies of objects for
  664.  *  calling methods with "by-value" argument semantics.
  665.  */
  666.    SOM_ResolveD(this,somf_TSequence,SOMObject,somDefaultCopyInit)
  667.     (this,ctrl,fromObj);
  668. }
  669.  
  670.  
  671. /* method: somDefaultAssign */
  672. somf_TSequence*  somDefaultAssign(som3AssignCtrl* ctrl, 
  673.         SOMObject* fromObj)
  674. {
  675. /*
  676.  *  A default assignment operator. Use this to "assign" the state of one
  677.  *  object to another.
  678.  */
  679.    return SOM_ResolveD(this,somf_TSequence,SOMObject,somDefaultAssign)
  680.     (this,ctrl,fromObj);
  681. }
  682.  
  683.  
  684. /* initializer method: somDefaultConstCopyInit */
  685. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  686.         SOMObject* fromObj)
  687. {
  688. /*
  689.  *  A default copy constructor that uses a const fromObj.
  690.  */
  691.    SOM_ResolveD(this,somf_TSequence,SOMObject,somDefaultConstCopyInit)
  692.     (this,ctrl,fromObj);
  693. }
  694.  
  695.  
  696. /* initializer method: somDefaultVCopyInit */
  697. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  698.         SOMObject* fromObj)
  699. {
  700. /*
  701.  *  A default copy constructor that uses a volatile fromObj.
  702.  */
  703.    SOM_ResolveD(this,somf_TSequence,SOMObject,somDefaultVCopyInit)
  704.     (this,ctrl,fromObj);
  705. }
  706.  
  707.  
  708. /* initializer method: somDefaultConstVCopyInit */
  709. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  710.         SOMObject* fromObj)
  711. {
  712. /*
  713.  *  A default copy constructor that uses a const volatile fromObj.
  714.  */
  715.    SOM_ResolveD(this,somf_TSequence,SOMObject,somDefaultConstVCopyInit)
  716.     (this,ctrl,fromObj);
  717. }
  718.  
  719.  
  720. /* method: somDefaultConstAssign */
  721. somf_TSequence*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  722.         SOMObject* fromObj)
  723. {
  724. /*
  725.  *  A default assignment operator that uses a const fromObj.
  726.  */
  727.    return SOM_ResolveD(this,somf_TSequence,SOMObject,somDefaultConstAssign)
  728.     (this,ctrl,fromObj);
  729. }
  730.  
  731.  
  732. /* method: somDefaultVAssign */
  733. somf_TSequence*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  734.         SOMObject* fromObj)
  735. {
  736. /*
  737.  *  A default assignment operator that uses a volatile fromObj.
  738.  */
  739.    return SOM_ResolveD(this,somf_TSequence,SOMObject,somDefaultVAssign)
  740.     (this,ctrl,fromObj);
  741. }
  742.  
  743.  
  744. /* method: somDefaultConstVAssign */
  745. somf_TSequence*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  746.         SOMObject* fromObj)
  747. {
  748. /*
  749.  *  A default assignment operator that uses a const volatile fromObj.
  750.  */
  751.    return SOM_ResolveD(this,somf_TSequence,SOMObject,somDefaultConstVAssign)
  752.     (this,ctrl,fromObj);
  753. }
  754.  
  755.  
  756. /* method: somInit */
  757. void   somInit()
  758. {
  759. /*
  760.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  761.  */
  762.    SOM_ResolveD(this,somf_TSequence,SOMObject,somInit)
  763.     (this);
  764. }
  765.  
  766.  
  767. /* method: somFree */
  768. void   somFree()
  769. {
  770. /*
  771.  *  Use as directed by framework implementations.
  772.  */
  773.    SOM_ResolveD(this,somf_TSequence,SOMObject,somFree)
  774.     (this);
  775. }
  776.  
  777.  
  778. /* method: somUninit */
  779. void   somUninit()
  780. {
  781. /*
  782.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  783.  */
  784.    SOM_ResolveD(this,somf_TSequence,SOMObject,somUninit)
  785.     (this);
  786. }
  787.  
  788.  
  789. /* method: somGetClass */
  790. SOMClass*   somGetClass()
  791. {
  792. /*
  793.  *  Return the receiver's class.
  794.  */
  795.    return SOM_ResolveD(this,somf_TSequence,SOMObject,somGetClass)
  796.     (this);
  797. }
  798.  
  799.  
  800. /* method: somGetClassName */
  801. string   somGetClassName()
  802. {
  803. /*
  804.  *  Return the name of the receiver's class.
  805.  */
  806.    return SOM_ResolveD(this,somf_TSequence,SOMObject,somGetClassName)
  807.     (this);
  808. }
  809.  
  810.  
  811. /* method: somGetSize */
  812. long   somGetSize()
  813. {
  814. /*
  815.  *  Return the size of the receiver.
  816.  */
  817.    return SOM_ResolveD(this,somf_TSequence,SOMObject,somGetSize)
  818.     (this);
  819. }
  820.  
  821.  
  822. /* method: somIsA */
  823. boolean   somIsA(SOMClass* aClassObj)
  824. {
  825. /*
  826.  *  Returns 1 (true) if the receiver responds to methods
  827.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  828.  */
  829.    return SOM_ResolveD(this,somf_TSequence,SOMObject,somIsA)
  830.     (this,aClassObj);
  831. }
  832.  
  833.  
  834. /* method: somIsInstanceOf */
  835. boolean   somIsInstanceOf(SOMClass* aClassObj)
  836. {
  837. /*
  838.  *  Returns 1 (true) if the receiver is an instance of
  839.  *  <aClassObj> and 0 (false) otherwise.
  840.  */
  841.    return SOM_ResolveD(this,somf_TSequence,SOMObject,somIsInstanceOf)
  842.     (this,aClassObj);
  843. }
  844.  
  845.  
  846. /* method: somRespondsTo */
  847. boolean   somRespondsTo(somId mId)
  848. {
  849. /*
  850.  *  Returns 1 (true) if the indicated method can be invoked
  851.  *  on the receiver and 0 (false) otherwise.
  852.  */
  853.    return SOM_ResolveD(this,somf_TSequence,SOMObject,somRespondsTo)
  854.     (this,mId);
  855. }
  856.  
  857.  
  858. /* va_list method: somDispatch */
  859.  
  860. /*
  861.  *  This method provides a generic, class-specific dispatch mechanism.
  862.  *  It accepts as input <retValue> a pointer to the memory area to be
  863.  *  loaded with the result of dispatching the method indicated by
  864.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  865.  *  on which the method is to be invoked as the first argument.
  866.  */
  867. /* the va_list invocation form */
  868. boolean   somf_TSequence_somDispatch(somToken* retValue, 
  869.         somId methodId, 
  870.         va_list ap)
  871. {return SOM_ResolveD(this,somf_TSequence,SOMObject,somDispatch)
  872.     (this,retValue,methodId,ap);
  873. }
  874.  
  875. /* the varargs invocation form */
  876. boolean   somDispatch(somToken* retValue, 
  877.         somId methodId, 
  878.         ...)
  879. {
  880. /*
  881.  *  This method provides a generic, class-specific dispatch mechanism.
  882.  *  It accepts as input <retValue> a pointer to the memory area to be
  883.  *  loaded with the result of dispatching the method indicated by
  884.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  885.  *  on which the method is to be invoked as the first argument.
  886.  */
  887.    va_list ap;
  888.    va_start(ap, methodId);
  889.    boolean __somResult = 
  890.       SOM_ResolveD(this,somf_TSequence,SOMObject,somDispatch)
  891.     (this,retValue,methodId,ap);
  892.    va_end(ap);
  893.    return __somResult;
  894. }
  895.  
  896.  
  897. /* va_list method: somClassDispatch */
  898.  
  899. /*
  900.  *  Like somDispatch, but method resolution for static methods is done
  901.  *  according to the clsObj instance method table.
  902.  */
  903. /* the va_list invocation form */
  904. boolean   somf_TSequence_somClassDispatch(SOMClass* clsObj, 
  905.         somToken* retValue, 
  906.         somId methodId, 
  907.         va_list ap)
  908. {return SOM_ResolveD(this,somf_TSequence,SOMObject,somClassDispatch)
  909.     (this,clsObj,retValue,methodId,ap);
  910. }
  911.  
  912. /* the varargs invocation form */
  913. boolean   somClassDispatch(SOMClass* clsObj, 
  914.         somToken* retValue, 
  915.         somId methodId, 
  916.         ...)
  917. {
  918. /*
  919.  *  Like somDispatch, but method resolution for static methods is done
  920.  *  according to the clsObj instance method table.
  921.  */
  922.    va_list ap;
  923.    va_start(ap, methodId);
  924.    boolean __somResult = 
  925.       SOM_ResolveD(this,somf_TSequence,SOMObject,somClassDispatch)
  926.     (this,clsObj,retValue,methodId,ap);
  927.    va_end(ap);
  928.    return __somResult;
  929. }
  930.  
  931.  
  932. /* method: somCastObj */
  933. boolean   somCastObj(SOMClass* cls)
  934. {
  935. /*
  936.  *  cast the receiving object to cls (which must be an ancestor of the
  937.  *  objects true class. Returns true on success.
  938.  */
  939.    return SOM_ResolveD(this,somf_TSequence,SOMObject,somCastObj)
  940.     (this,cls);
  941. }
  942.  
  943.  
  944. /* method: somResetObj */
  945. boolean   somResetObj()
  946. {
  947. /*
  948.  *  reset an object to its true class. Returns true always.
  949.  */
  950.    return SOM_ResolveD(this,somf_TSequence,SOMObject,somResetObj)
  951.     (this);
  952. }
  953.  
  954.  
  955. /* va_list method: somDispatchV */
  956.  
  957. /*
  958.  *  Obsolete. Use somDispatch instead.
  959.  */
  960. /* the va_list invocation form */
  961. void   somf_TSequence_somDispatchV(somId methodId, 
  962.         somId descriptor, 
  963.         va_list ap)
  964. {   SOM_ResolveD(this,somf_TSequence,SOMObject,somDispatchV)
  965.     (this,methodId,descriptor,ap);
  966. }
  967.  
  968. /* the varargs invocation form */
  969. void   somDispatchV(somId methodId, 
  970.         somId descriptor, 
  971.         ...)
  972. {
  973. /*
  974.  *  Obsolete. Use somDispatch instead.
  975.  */
  976.    va_list ap;
  977.    va_start(ap, descriptor);
  978.    SOM_ResolveD(this,somf_TSequence,SOMObject,somDispatchV)
  979.     (this,methodId,descriptor,ap);
  980.    va_end(ap);
  981. }
  982.  
  983.  
  984. /* va_list method: somDispatchL */
  985.  
  986. /*
  987.  *  Obsolete. Use somDispatch instead.
  988.  */
  989. /* the va_list invocation form */
  990. long   somf_TSequence_somDispatchL(somId methodId, 
  991.         somId descriptor, 
  992.         va_list ap)
  993. {return SOM_ResolveD(this,somf_TSequence,SOMObject,somDispatchL)
  994.     (this,methodId,descriptor,ap);
  995. }
  996.  
  997. /* the varargs invocation form */
  998. long   somDispatchL(somId methodId, 
  999.         somId descriptor, 
  1000.         ...)
  1001. {
  1002. /*
  1003.  *  Obsolete. Use somDispatch instead.
  1004.  */
  1005.    va_list ap;
  1006.    va_start(ap, descriptor);
  1007.    long __somResult = 
  1008.       SOM_ResolveD(this,somf_TSequence,SOMObject,somDispatchL)
  1009.     (this,methodId,descriptor,ap);
  1010.    va_end(ap);
  1011.    return __somResult;
  1012. }
  1013.  
  1014.  
  1015. /* va_list method: somDispatchA */
  1016.  
  1017. /*
  1018.  *  Obsolete. Use somDispatch instead.
  1019.  */
  1020. /* the va_list invocation form */
  1021. void*   somf_TSequence_somDispatchA(somId methodId, 
  1022.         somId descriptor, 
  1023.         va_list ap)
  1024. {return SOM_ResolveD(this,somf_TSequence,SOMObject,somDispatchA)
  1025.     (this,methodId,descriptor,ap);
  1026. }
  1027.  
  1028. /* the varargs invocation form */
  1029. void*   somDispatchA(somId methodId, 
  1030.         somId descriptor, 
  1031.         ...)
  1032. {
  1033. /*
  1034.  *  Obsolete. Use somDispatch instead.
  1035.  */
  1036.    va_list ap;
  1037.    va_start(ap, descriptor);
  1038.    void* __somResult = 
  1039.       SOM_ResolveD(this,somf_TSequence,SOMObject,somDispatchA)
  1040.     (this,methodId,descriptor,ap);
  1041.    va_end(ap);
  1042.    return __somResult;
  1043. }
  1044.  
  1045.  
  1046. /* va_list method: somDispatchD */
  1047.  
  1048. /*
  1049.  *  Obsolete. Use somDispatch instead.
  1050.  */
  1051. /* the va_list invocation form */
  1052. double   somf_TSequence_somDispatchD(somId methodId, 
  1053.         somId descriptor, 
  1054.         va_list ap)
  1055. {return SOM_ResolveD(this,somf_TSequence,SOMObject,somDispatchD)
  1056.     (this,methodId,descriptor,ap);
  1057. }
  1058.  
  1059. /* the varargs invocation form */
  1060. double   somDispatchD(somId methodId, 
  1061.         somId descriptor, 
  1062.         ...)
  1063. {
  1064. /*
  1065.  *  Obsolete. Use somDispatch instead.
  1066.  */
  1067.    va_list ap;
  1068.    va_start(ap, descriptor);
  1069.    double __somResult = 
  1070.       SOM_ResolveD(this,somf_TSequence,SOMObject,somDispatchD)
  1071.     (this,methodId,descriptor,ap);
  1072.    va_end(ap);
  1073.    return __somResult;
  1074. }
  1075.  
  1076.  
  1077. /* method: somPrintSelf */
  1078. SOMObject*   somPrintSelf()
  1079. {
  1080. /*
  1081.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  1082.  *  information about this object.  The default implementation just gives
  1083.  *  the object's class name and its address in memory.
  1084.  *  <self> is returned.
  1085.  */
  1086.    return SOM_ResolveD(this,somf_TSequence,SOMObject,somPrintSelf)
  1087.     (this);
  1088. }
  1089.  
  1090.  
  1091. /* method: somDumpSelf */
  1092. void   somDumpSelf(long level)
  1093. {
  1094. /*
  1095.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  1096.  *  and its current state.
  1097.  * 
  1098.  *  <level> indicates the nesting level for describing compound objects
  1099.  *  it must be greater than or equal to zero.  All lines in the
  1100.  *  description will be preceeded by <2*level> spaces.
  1101.  * 
  1102.  *  This routine only actually writes the data that concerns the object
  1103.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  1104.  *  the object's current state.  This approach allows readable
  1105.  *  descriptions of compound objects to be constructed.
  1106.  * 
  1107.  *  Generally it is not necessary to override this method, if it is
  1108.  *  overriden it generally must be completely replaced.
  1109.  */
  1110.    SOM_ResolveD(this,somf_TSequence,SOMObject,somDumpSelf)
  1111.     (this,level);
  1112. }
  1113.  
  1114.  
  1115. /* method: somDumpSelfInt */
  1116. void   somDumpSelfInt(long level)
  1117. {
  1118. /*
  1119.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  1120.  *  Generally this method will need to be overridden.  When overriding
  1121.  *  it, begin by calling the parent class form of this method and then
  1122.  *  write in a description of your class's instance data. This will
  1123.  *  result in a description of all the object's instance data going
  1124.  *  from its root ancestor class to its specific class.
  1125.  */
  1126.    SOM_ResolveD(this,somf_TSequence,SOMObject,somDumpSelfInt)
  1127.     (this,level);
  1128. }
  1129.  
  1130.  
  1131.  
  1132. };   /* somf_TSequence */
  1133.  
  1134.  
  1135.  
  1136. #endif       /* SOM_somf_TSequence_xh */
  1137.