home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / tss.xh < prev    next >
Text File  |  1999-02-22  |  42KB  |  1,232 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: tss.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, 1989 Apple Computer, Inc. All rights reserved.
  23.  * 
  24.  * CLASS_NAME: somf_TSortedSequence
  25.  * 
  26.  * DESCRIPTION: A TSortedSequence is a TSequence.  It is ordered based on
  27.  *              how the elements in the collections relate to each other.
  28.  *              Any element in the TSortedSequence is Less Than or Equal to
  29.  *              the element in front of it, and Greater Than or Equal to
  30.  *              the element behind it.
  31.  * 
  32.  */
  33.  
  34.  
  35. #ifndef SOM_somf_TSortedSequence_xh
  36. #define SOM_somf_TSortedSequence_xh
  37.  
  38. class somf_TSortedSequence;
  39.  
  40. #define somf_TSortedSequence_MajorVersion 2
  41. #define somf_TSortedSequence_MinorVersion 1
  42.  
  43. /* C++ SOM defs */
  44. #include <somcls.xh>
  45. #include <somcm.xh>
  46.  
  47. /* C++ parent defs */
  48. #ifndef SOM_somf_TSequence_xh
  49. #include <tseq.xh>
  50. #endif
  51.  
  52. #ifndef somf_TSortedSequence_API
  53. #define somf_TSortedSequence_API
  54. /*
  55.  * -- The Class API
  56.  */
  57.  
  58. /*
  59.  * Start of bindings for IDL types
  60.  */
  61.  
  62. class SOMClass;
  63. class SOMObject;
  64. class somf_TIterator;
  65. class somf_TSortedSequenceNode;
  66. class somf_TSequenceIterator;
  67.  
  68. /*
  69.  * End of bindings for IDL types.
  70.  */
  71.  
  72. /*
  73.  * Passthru lines: File: "C.xh", "after"
  74.  */
  75.  
  76. #include <mcollect.xh>
  77. #include <morder.xh>
  78. #include <tssnode.xh>
  79.  
  80. /* A procedure to create the somf_TSortedSequence Class */
  81. SOMEXTERN SOMClass * SOMLINK somf_TSortedSequenceNewClass(
  82.         integer4 majorVersion,
  83.         integer4 minorVersion);
  84.  
  85. /* The API to the somf_TSortedSequence class object, and the methods it introduces. */
  86. SOMEXTERN struct somf_TSortedSequenceClassDataStructure {
  87.     SOMClass *classObject;
  88.     somMToken somfCreateSequenceIterator;
  89.     somMToken somfGetSequencingFunction;
  90.     somMToken somfSetSequencingFunction;
  91.     somMToken somfCreateSortedSequenceNode;
  92.     somMToken somfRotate;
  93.     somMToken somfSplit;
  94.     somMToken somfBalance;
  95.     somMToken somfInternalRemoveAll;
  96.     somMToken somfInternalDeleteAll;
  97.     somMToken somfAssign;
  98.     somMToken somfTSortedSequenceInitF;
  99.     somMToken somfTSortedSequenceInitS;
  100. } SOMDLINK somf_TSortedSequenceClassData;
  101. #define _somf_TSortedSequence somf_TSortedSequenceClassData.classObject
  102.  
  103. /* The API to parentMtabs for somf_TSortedSequence, and the instance data it introduces. */
  104. SOMEXTERN struct somf_TSortedSequenceCClassDataStructure {
  105.     somMethodTabs parentMtab;
  106.     somDToken              instanceDataToken;
  107. } SOMDLINK somf_TSortedSequenceCClassData;
  108.  
  109. /*
  110.  * -- Typedefs for somf_TSortedSequence Method Procedures
  111.  */
  112. SOMEXTERN {
  113. typedef somf_TSortedSequence*   SOMLINK somTP_somf_TSortedSequence_somfTSortedSequenceInitF(somf_TSortedSequence *somSelf, Environment *ev, 
  114.         somf_MOrderableCollectible_somf_MBetterOrderableCompareFn testfn);
  115. typedef somTP_somf_TSortedSequence_somfTSortedSequenceInitF *somTD_somf_TSortedSequence_somfTSortedSequenceInitF;
  116. typedef somf_TSortedSequence*   SOMLINK somTP_somf_TSortedSequence_somfTSortedSequenceInitS(somf_TSortedSequence *somSelf, Environment *ev, 
  117.         somf_TSortedSequence* s);
  118. typedef somTP_somf_TSortedSequence_somfTSortedSequenceInitS *somTD_somf_TSortedSequence_somfTSortedSequenceInitS;
  119. typedef void   SOMLINK somTP_somf_TSortedSequence_somfAssign(somf_TSortedSequence *somSelf, Environment *ev, 
  120.         somf_TSortedSequence* s);
  121. typedef somTP_somf_TSortedSequence_somfAssign *somTD_somf_TSortedSequence_somfAssign;
  122. typedef somf_TSequenceIterator*   SOMLINK somTP_somf_TSortedSequence_somfCreateSequenceIterator(somf_TSortedSequence *somSelf, Environment *ev);
  123. typedef somTP_somf_TSortedSequence_somfCreateSequenceIterator *somTD_somf_TSortedSequence_somfCreateSequenceIterator;
  124. typedef somf_MOrderableCollectible_somf_MBetterOrderableCompareFn   SOMLINK somTP_somf_TSortedSequence_somfGetSequencingFunction(somf_TSortedSequence *somSelf, Environment *ev);
  125. typedef somTP_somf_TSortedSequence_somfGetSequencingFunction *somTD_somf_TSortedSequence_somfGetSequencingFunction;
  126. typedef void   SOMLINK somTP_somf_TSortedSequence_somfSetSequencingFunction(somf_TSortedSequence *somSelf, Environment *ev, 
  127.         somf_MOrderableCollectible_somf_MBetterOrderableCompareFn fn);
  128. typedef somTP_somf_TSortedSequence_somfSetSequencingFunction *somTD_somf_TSortedSequence_somfSetSequencingFunction;
  129. typedef somf_TSortedSequenceNode*   SOMLINK somTP_somf_TSortedSequence_somfCreateSortedSequenceNode(somf_TSortedSequence *somSelf, Environment *ev, 
  130.         somf_TSortedSequenceNode* n1, 
  131.         somf_MOrderableCollectible* obj, 
  132.         somf_TSortedSequenceNode* n2);
  133. typedef somTP_somf_TSortedSequence_somfCreateSortedSequenceNode *somTD_somf_TSortedSequence_somfCreateSortedSequenceNode;
  134.  
  135. /*
  136.  * -- Typedefs for Reintroduced Wrapper Methods
  137.  */
  138. typedef somf_MCollectible*   SOMLINK somTP_somf_TSortedSequence_somfAfter(somf_TSortedSequence *somSelf, Environment *ev, 
  139.         somf_MCollectible* obj);
  140. typedef somTP_somf_TSortedSequence_somfAfter *somTD_somf_TSortedSequence_somfAfter;
  141. typedef somf_MCollectible*   SOMLINK somTP_somf_TSortedSequence_somfBefore(somf_TSortedSequence *somSelf, Environment *ev, 
  142.         somf_MCollectible* obj);
  143. typedef somTP_somf_TSortedSequence_somfBefore *somTD_somf_TSortedSequence_somfBefore;
  144. typedef somf_MCollectible*   SOMLINK somTP_somf_TSortedSequence_somfLast(somf_TSortedSequence *somSelf, Environment *ev);
  145. typedef somTP_somf_TSortedSequence_somfLast *somTD_somf_TSortedSequence_somfLast;
  146. typedef somf_MCollectible*   SOMLINK somTP_somf_TSortedSequence_somfFirst(somf_TSortedSequence *somSelf, Environment *ev);
  147. typedef somTP_somf_TSortedSequence_somfFirst *somTD_somf_TSortedSequence_somfFirst;
  148. typedef long   SOMLINK somTP_somf_TSortedSequence_somfOccurrencesOf(somf_TSortedSequence *somSelf, Environment *ev, 
  149.         somf_MCollectible* obj);
  150. typedef somTP_somf_TSortedSequence_somfOccurrencesOf *somTD_somf_TSortedSequence_somfOccurrencesOf;
  151. typedef somf_TSequence*   SOMLINK somTP_somf_TSortedSequence_somfTSequenceInit(somf_TSortedSequence *somSelf, Environment *ev, 
  152.         somf_MCollectible_somf_MCollectibleCompareFn testfn);
  153. typedef somTP_somf_TSortedSequence_somfTSequenceInit *somTD_somf_TSortedSequence_somfTSequenceInit;
  154. typedef somf_MCollectible*   SOMLINK somTP_somf_TSortedSequence_somfAdd(somf_TSortedSequence *somSelf, Environment *ev, 
  155.         somf_MCollectible* obj);
  156. typedef somTP_somf_TSortedSequence_somfAdd *somTD_somf_TSortedSequence_somfAdd;
  157. typedef somf_MCollectible*   SOMLINK somTP_somf_TSortedSequence_somfRemove(somf_TSortedSequence *somSelf, Environment *ev, 
  158.         somf_MCollectible* obj);
  159. typedef somTP_somf_TSortedSequence_somfRemove *somTD_somf_TSortedSequence_somfRemove;
  160. typedef void   SOMLINK somTP_somf_TSortedSequence_somfRemoveAll(somf_TSortedSequence *somSelf, Environment *ev);
  161. typedef somTP_somf_TSortedSequence_somfRemoveAll *somTD_somf_TSortedSequence_somfRemoveAll;
  162. typedef void   SOMLINK somTP_somf_TSortedSequence_somfDeleteAll(somf_TSortedSequence *somSelf, Environment *ev);
  163. typedef somTP_somf_TSortedSequence_somfDeleteAll *somTD_somf_TSortedSequence_somfDeleteAll;
  164. typedef long   SOMLINK somTP_somf_TSortedSequence_somfCount(somf_TSortedSequence *somSelf, Environment *ev);
  165. typedef somTP_somf_TSortedSequence_somfCount *somTD_somf_TSortedSequence_somfCount;
  166. typedef somf_TIterator*   SOMLINK somTP_somf_TSortedSequence_somfCreateIterator(somf_TSortedSequence *somSelf, Environment *ev);
  167. typedef somTP_somf_TSortedSequence_somfCreateIterator *somTD_somf_TSortedSequence_somfCreateIterator;
  168. typedef void   SOMLINK somTP_somf_TSortedSequence_somInit(somf_TSortedSequence *somSelf);
  169. typedef somTP_somf_TSortedSequence_somInit *somTD_somf_TSortedSequence_somInit;
  170. typedef void   SOMLINK somTP_somf_TSortedSequence_somfAddAll(somf_TSortedSequence *somSelf, Environment *ev, 
  171.         somf_TCollection* col);
  172. typedef somTP_somf_TSortedSequence_somfAddAll *somTD_somf_TSortedSequence_somfAddAll;
  173. typedef somf_MCollectible*   SOMLINK somTP_somf_TSortedSequence_somfMember(somf_TSortedSequence *somSelf, Environment *ev, 
  174.         somf_MCollectible* obj);
  175. typedef somTP_somf_TSortedSequence_somfMember *somTD_somf_TSortedSequence_somfMember;
  176. typedef somf_MCollectible_somf_MCollectibleCompareFn   SOMLINK somTP_somf_TSortedSequence_somfTestFunction(somf_TSortedSequence *somSelf, Environment *ev);
  177. typedef somTP_somf_TSortedSequence_somfTestFunction *somTD_somf_TSortedSequence_somfTestFunction;
  178. typedef void   SOMLINK somTP_somf_TSortedSequence_somfSetTestFunction(somf_TSortedSequence *somSelf, Environment *ev, 
  179.         somf_MCollectible_somf_MCollectibleCompareFn testfn);
  180. typedef somTP_somf_TSortedSequence_somfSetTestFunction *somTD_somf_TSortedSequence_somfSetTestFunction;
  181. typedef somf_TCollection*   SOMLINK somTP_somf_TSortedSequence_somfTCollectionInit(somf_TSortedSequence *somSelf, Environment *ev, 
  182.         somf_MCollectible_somf_MCollectibleCompareFn testfn);
  183. typedef somTP_somf_TSortedSequence_somfTCollectionInit *somTD_somf_TSortedSequence_somfTCollectionInit;
  184. typedef boolean   SOMLINK somTP_somf_TSortedSequence_somfIsEqual(somf_TSortedSequence *somSelf, Environment *ev, 
  185.         somf_MCollectible* obj);
  186. typedef somTP_somf_TSortedSequence_somfIsEqual *somTD_somf_TSortedSequence_somfIsEqual;
  187. typedef somf_MCollectible*   SOMLINK somTP_somf_TSortedSequence_somfClone(somf_TSortedSequence *somSelf, Environment *ev);
  188. typedef somTP_somf_TSortedSequence_somfClone *somTD_somf_TSortedSequence_somfClone;
  189. typedef somf_MCollectible*   SOMLINK somTP_somf_TSortedSequence_somfClonePointer(somf_TSortedSequence *somSelf, Environment *ev, 
  190.         somf_MCollectible* clonee);
  191. typedef somTP_somf_TSortedSequence_somfClonePointer *somTD_somf_TSortedSequence_somfClonePointer;
  192. typedef long   SOMLINK somTP_somf_TSortedSequence_somfHash(somf_TSortedSequence *somSelf, Environment *ev);
  193. typedef somTP_somf_TSortedSequence_somfHash *somTD_somf_TSortedSequence_somfHash;
  194. typedef boolean   SOMLINK somTP_somf_TSortedSequence_somfIsSame(somf_TSortedSequence *somSelf, Environment *ev, 
  195.         somf_MCollectible* obj);
  196. typedef somTP_somf_TSortedSequence_somfIsSame *somTD_somf_TSortedSequence_somfIsSame;
  197. typedef boolean   SOMLINK somTP_somf_TSortedSequence_somfIsNotEqual(somf_TSortedSequence *somSelf, Environment *ev, 
  198.         somf_MCollectible* obj);
  199. typedef somTP_somf_TSortedSequence_somfIsNotEqual *somTD_somf_TSortedSequence_somfIsNotEqual;
  200. typedef void   SOMLINK somTP_somf_TSortedSequence_somDefaultInit(somf_TSortedSequence *somSelf, 
  201.         som3InitCtrl* ctrl);
  202. typedef somTP_somf_TSortedSequence_somDefaultInit *somTD_somf_TSortedSequence_somDefaultInit;
  203. typedef void   SOMLINK somTP_somf_TSortedSequence_somDestruct(somf_TSortedSequence *somSelf, 
  204.         octet doFree, 
  205.         som3DestructCtrl* ctrl);
  206. typedef somTP_somf_TSortedSequence_somDestruct *somTD_somf_TSortedSequence_somDestruct;
  207. typedef void   SOMLINK somTP_somf_TSortedSequence_somDefaultCopyInit(somf_TSortedSequence *somSelf, 
  208.         som3InitCtrl* ctrl, 
  209.         SOMObject* fromObj);
  210. typedef somTP_somf_TSortedSequence_somDefaultCopyInit *somTD_somf_TSortedSequence_somDefaultCopyInit;
  211. typedef somf_TSortedSequence*   SOMLINK somTP_somf_TSortedSequence_somDefaultAssign(somf_TSortedSequence *somSelf, 
  212.         som3AssignCtrl* ctrl, 
  213.         SOMObject* fromObj);
  214. typedef somTP_somf_TSortedSequence_somDefaultAssign *somTD_somf_TSortedSequence_somDefaultAssign;
  215. typedef void   SOMLINK somTP_somf_TSortedSequence_somDefaultConstCopyInit(somf_TSortedSequence *somSelf, 
  216.         som3InitCtrl* ctrl, 
  217.         SOMObject* fromObj);
  218. typedef somTP_somf_TSortedSequence_somDefaultConstCopyInit *somTD_somf_TSortedSequence_somDefaultConstCopyInit;
  219. typedef void   SOMLINK somTP_somf_TSortedSequence_somDefaultVCopyInit(somf_TSortedSequence *somSelf, 
  220.         som3InitCtrl* ctrl, 
  221.         SOMObject* fromObj);
  222. typedef somTP_somf_TSortedSequence_somDefaultVCopyInit *somTD_somf_TSortedSequence_somDefaultVCopyInit;
  223. typedef void   SOMLINK somTP_somf_TSortedSequence_somDefaultConstVCopyInit(somf_TSortedSequence *somSelf, 
  224.         som3InitCtrl* ctrl, 
  225.         SOMObject* fromObj);
  226. typedef somTP_somf_TSortedSequence_somDefaultConstVCopyInit *somTD_somf_TSortedSequence_somDefaultConstVCopyInit;
  227. typedef somf_TSortedSequence*   SOMLINK somTP_somf_TSortedSequence_somDefaultConstAssign(somf_TSortedSequence *somSelf, 
  228.         som3AssignCtrl* ctrl, 
  229.         SOMObject* fromObj);
  230. typedef somTP_somf_TSortedSequence_somDefaultConstAssign *somTD_somf_TSortedSequence_somDefaultConstAssign;
  231. typedef somf_TSortedSequence*   SOMLINK somTP_somf_TSortedSequence_somDefaultVAssign(somf_TSortedSequence *somSelf, 
  232.         som3AssignCtrl* ctrl, 
  233.         SOMObject* fromObj);
  234. typedef somTP_somf_TSortedSequence_somDefaultVAssign *somTD_somf_TSortedSequence_somDefaultVAssign;
  235. typedef somf_TSortedSequence*   SOMLINK somTP_somf_TSortedSequence_somDefaultConstVAssign(somf_TSortedSequence *somSelf, 
  236.         som3AssignCtrl* ctrl, 
  237.         SOMObject* fromObj);
  238. typedef somTP_somf_TSortedSequence_somDefaultConstVAssign *somTD_somf_TSortedSequence_somDefaultConstVAssign;
  239. typedef void   SOMLINK somTP_somf_TSortedSequence_somFree(somf_TSortedSequence *somSelf);
  240. typedef somTP_somf_TSortedSequence_somFree *somTD_somf_TSortedSequence_somFree;
  241. typedef void   SOMLINK somTP_somf_TSortedSequence_somUninit(somf_TSortedSequence *somSelf);
  242. typedef somTP_somf_TSortedSequence_somUninit *somTD_somf_TSortedSequence_somUninit;
  243. typedef SOMClass*   SOMLINK somTP_somf_TSortedSequence_somGetClass(somf_TSortedSequence *somSelf);
  244. typedef somTP_somf_TSortedSequence_somGetClass *somTD_somf_TSortedSequence_somGetClass;
  245. typedef string   SOMLINK somTP_somf_TSortedSequence_somGetClassName(somf_TSortedSequence *somSelf);
  246. typedef somTP_somf_TSortedSequence_somGetClassName *somTD_somf_TSortedSequence_somGetClassName;
  247. typedef long   SOMLINK somTP_somf_TSortedSequence_somGetSize(somf_TSortedSequence *somSelf);
  248. typedef somTP_somf_TSortedSequence_somGetSize *somTD_somf_TSortedSequence_somGetSize;
  249. typedef boolean   SOMLINK somTP_somf_TSortedSequence_somIsA(somf_TSortedSequence *somSelf, 
  250.         SOMClass* aClassObj);
  251. typedef somTP_somf_TSortedSequence_somIsA *somTD_somf_TSortedSequence_somIsA;
  252. typedef boolean   SOMLINK somTP_somf_TSortedSequence_somIsInstanceOf(somf_TSortedSequence *somSelf, 
  253.         SOMClass* aClassObj);
  254. typedef somTP_somf_TSortedSequence_somIsInstanceOf *somTD_somf_TSortedSequence_somIsInstanceOf;
  255. typedef boolean   SOMLINK somTP_somf_TSortedSequence_somRespondsTo(somf_TSortedSequence *somSelf, 
  256.         somId mId);
  257. typedef somTP_somf_TSortedSequence_somRespondsTo *somTD_somf_TSortedSequence_somRespondsTo;
  258. typedef boolean   SOMLINK somTP_somf_TSortedSequence_somDispatch(somf_TSortedSequence *somSelf, 
  259.         somToken* retValue, 
  260.         somId methodId, 
  261.         va_list ap);
  262. typedef somTP_somf_TSortedSequence_somDispatch *somTD_somf_TSortedSequence_somDispatch;
  263. typedef boolean   SOMLINK somTP_somf_TSortedSequence_somClassDispatch(somf_TSortedSequence *somSelf, 
  264.         SOMClass* clsObj, 
  265.         somToken* retValue, 
  266.         somId methodId, 
  267.         va_list ap);
  268. typedef somTP_somf_TSortedSequence_somClassDispatch *somTD_somf_TSortedSequence_somClassDispatch;
  269. typedef boolean   SOMLINK somTP_somf_TSortedSequence_somCastObj(somf_TSortedSequence *somSelf, 
  270.         SOMClass* cls);
  271. typedef somTP_somf_TSortedSequence_somCastObj *somTD_somf_TSortedSequence_somCastObj;
  272. typedef boolean   SOMLINK somTP_somf_TSortedSequence_somResetObj(somf_TSortedSequence *somSelf);
  273. typedef somTP_somf_TSortedSequence_somResetObj *somTD_somf_TSortedSequence_somResetObj;
  274. typedef void   SOMLINK somTP_somf_TSortedSequence_somDispatchV(somf_TSortedSequence *somSelf, 
  275.         somId methodId, 
  276.         somId descriptor, 
  277.         va_list ap);
  278. typedef somTP_somf_TSortedSequence_somDispatchV *somTD_somf_TSortedSequence_somDispatchV;
  279. typedef long   SOMLINK somTP_somf_TSortedSequence_somDispatchL(somf_TSortedSequence *somSelf, 
  280.         somId methodId, 
  281.         somId descriptor, 
  282.         va_list ap);
  283. typedef somTP_somf_TSortedSequence_somDispatchL *somTD_somf_TSortedSequence_somDispatchL;
  284. typedef void*   SOMLINK somTP_somf_TSortedSequence_somDispatchA(somf_TSortedSequence *somSelf, 
  285.         somId methodId, 
  286.         somId descriptor, 
  287.         va_list ap);
  288. typedef somTP_somf_TSortedSequence_somDispatchA *somTD_somf_TSortedSequence_somDispatchA;
  289. typedef double   SOMLINK somTP_somf_TSortedSequence_somDispatchD(somf_TSortedSequence *somSelf, 
  290.         somId methodId, 
  291.         somId descriptor, 
  292.         va_list ap);
  293. typedef somTP_somf_TSortedSequence_somDispatchD *somTD_somf_TSortedSequence_somDispatchD;
  294. typedef SOMObject*   SOMLINK somTP_somf_TSortedSequence_somPrintSelf(somf_TSortedSequence *somSelf);
  295. typedef somTP_somf_TSortedSequence_somPrintSelf *somTD_somf_TSortedSequence_somPrintSelf;
  296. typedef void   SOMLINK somTP_somf_TSortedSequence_somDumpSelf(somf_TSortedSequence *somSelf, 
  297.         long level);
  298. typedef somTP_somf_TSortedSequence_somDumpSelf *somTD_somf_TSortedSequence_somDumpSelf;
  299. typedef void   SOMLINK somTP_somf_TSortedSequence_somDumpSelfInt(somf_TSortedSequence *somSelf, 
  300.         long level);
  301. typedef somTP_somf_TSortedSequence_somDumpSelfInt *somTD_somf_TSortedSequence_somDumpSelfInt;
  302. }
  303.  
  304. #endif /* somf_TSortedSequence_API */
  305.  
  306.  
  307. /*
  308.  * -- This emitter treats Method Tokens as Thunks by default.
  309.  * -- Use the sc modifier "nothunks" to change this default
  310.  */
  311. #undef somresolve_
  312. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  313.  
  314. /*
  315.  * -- The C++ Wrapper Class for somf_TSortedSequence
  316.  */
  317. class somf_TSortedSequence : public somf_TSequence
  318. {
  319. public:
  320.  
  321. // somf_TSortedSequence::new creates the class object if necessary, and then uses somNewNoInit
  322. // to allocate memory and create the object. Initialization is in ctors.
  323. void *operator new(size_t)
  324. {
  325.    if (!_somf_TSortedSequence) somf_TSortedSequenceNewClass(somf_TSortedSequence_MajorVersion,somf_TSortedSequence_MinorVersion);
  326.    return (void*)
  327.       SOM_Resolve(_somf_TSortedSequence,SOMClass,somNewNoInit)
  328.          ((SOMClass *)((void*)_somf_TSortedSequence));
  329. }
  330.  
  331. // somf_TSortedSequence::delete uses somDestruct.
  332. void operator delete(void * obj)
  333. {
  334.    if (obj && *(void**)obj) {
  335.       SOM_Resolve(obj,SOMObject,somFree)
  336.          ((SOMObject*)obj);
  337.    }
  338. }
  339.  
  340. somf_TSortedSequence& operator=(somf_TSortedSequence& fromObj)
  341. {
  342.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  343.    return *this;
  344. }
  345.  
  346. somf_TSortedSequence()
  347. {
  348.    if (*(void**)this != 
  349.        ((somParentMtabStructPtr)
  350.         (somf_TSortedSequenceCClassData.parentMtab))->mtab)
  351.       return;
  352.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  353. }
  354.  
  355. somf_TSortedSequence(somf_TSortedSequence* fromObj)
  356. {
  357.    if (*(void**)this != 
  358.        ((somParentMtabStructPtr)
  359.         (somf_TSortedSequenceCClassData.parentMtab))->mtab)
  360.       return;
  361.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  362. }
  363.  
  364. #ifdef __IBMCPP__
  365. #pragma info(nocnv,nopar)
  366. #endif
  367. somf_TSortedSequence(const somf_TSortedSequence* fromObj)
  368. {
  369.    if (*(void**)this != 
  370.        ((somParentMtabStructPtr)
  371.         (somf_TSortedSequenceCClassData.parentMtab))->mtab)
  372.       return;
  373.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  374. }
  375. #ifdef __IBMCPP__
  376. #pragma info(restore)
  377. #endif
  378.  
  379.  
  380. /* method: somfTSortedSequenceInitF */
  381. somf_TSortedSequence*   somfTSortedSequenceInitF(Environment *ev, 
  382.         somf_MOrderableCollectible_somf_MBetterOrderableCompareFn testfn)
  383. {
  384. /*
  385.  *  Initialize the new TSortedSequence
  386.  */
  387.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TSortedSequence,somfTSortedSequenceInitF)
  388.     (this, ev,testfn);
  389. }
  390.  
  391.  
  392. /* method: somfTSortedSequenceInitS */
  393. somf_TSortedSequence*   somfTSortedSequenceInitS(Environment *ev, 
  394.         somf_TSortedSequence* s)
  395. {
  396. /*
  397.  *  Initialize the new TSortedSequence
  398.  */
  399.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TSortedSequence,somfTSortedSequenceInitS)
  400.     (this, ev,s);
  401. }
  402.  
  403.  
  404. /* method: somfAssign */
  405. void   somfAssign(Environment *ev, 
  406.         somf_TSortedSequence* s)
  407. {
  408. /*
  409.  *  Assign the instance of this equal to the instance of source.
  410.  */
  411.    SOM_ResolveD(this,somf_TSortedSequence,somf_TSortedSequence,somfAssign)
  412.     (this, ev,s);
  413. }
  414.  
  415.  
  416. /* method: somfCreateSequenceIterator */
  417. somf_TSequenceIterator*   somfCreateSequenceIterator(Environment *ev)
  418. {
  419. /*
  420.  *  This method returns a new iterator which is suitable for use in iterating
  421.  *  over the objects in this collection.
  422.  */
  423.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TSortedSequence,somfCreateSequenceIterator)
  424.     (this, ev);
  425. }
  426.  
  427.  
  428. /* method: somfGetSequencingFunction */
  429. somf_MOrderableCollectible_somf_MBetterOrderableCompareFn   somfGetSequencingFunction(Environment *ev)
  430. {
  431. /*
  432.  *  Return a pointer to the function used to compare elements in the
  433.  *  collection, and consequently determines the sequence of the collection.
  434.  */
  435.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TSortedSequence,somfGetSequencingFunction)
  436.     (this, ev);
  437. }
  438.  
  439.  
  440. /* method: somfSetSequencingFunction */
  441. void   somfSetSequencingFunction(Environment *ev, 
  442.         somf_MOrderableCollectible_somf_MBetterOrderableCompareFn fn)
  443. {
  444. /*
  445.  *  Sets the pointer to the function used to compare elements in the
  446.  *  collection, and consequently determines the sequence of the collection.
  447.  */
  448.    SOM_ResolveD(this,somf_TSortedSequence,somf_TSortedSequence,somfSetSequencingFunction)
  449.     (this, ev,fn);
  450. }
  451.  
  452.  
  453. /* method: somfCreateSortedSequenceNode */
  454. somf_TSortedSequenceNode*   somfCreateSortedSequenceNode(Environment *ev, 
  455.         somf_TSortedSequenceNode* n1, 
  456.         somf_MOrderableCollectible* obj, 
  457.         somf_TSortedSequenceNode* n2)
  458. {
  459. /*
  460.  *  Create a new TSortedSequenceNode in the TSortedSequence.
  461.  */
  462.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TSortedSequence,somfCreateSortedSequenceNode)
  463.     (this, ev,n1,obj,n2);
  464. }
  465.  
  466.  
  467. /*
  468.  * Reintroduce inherited methods
  469.  */
  470.  
  471. /* method: somfAfter */
  472. somf_MCollectible*   somfAfter(Environment *ev, 
  473.         somf_MCollectible* obj)
  474. {
  475. /*
  476.  *  Return the object found after obj.
  477.  */
  478.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TSequence,somfAfter)
  479.     (this, ev,obj);
  480. }
  481.  
  482.  
  483. /* method: somfBefore */
  484. somf_MCollectible*   somfBefore(Environment *ev, 
  485.         somf_MCollectible* obj)
  486. {
  487. /*
  488.  *  Return the object found before obj.
  489.  */
  490.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TSequence,somfBefore)
  491.     (this, ev,obj);
  492. }
  493.  
  494.  
  495. /* method: somfLast */
  496. somf_MCollectible*   somfLast(Environment *ev)
  497. {
  498. /*
  499.  *  Determine the last object in this.
  500.  */
  501.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TSequence,somfLast)
  502.     (this, ev);
  503. }
  504.  
  505.  
  506. /* method: somfFirst */
  507. somf_MCollectible*   somfFirst(Environment *ev)
  508. {
  509. /*
  510.  *  Determine the first object in this.
  511.  */
  512.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TSequence,somfFirst)
  513.     (this, ev);
  514. }
  515.  
  516.  
  517. /* method: somfOccurrencesOf */
  518. long   somfOccurrencesOf(Environment *ev, 
  519.         somf_MCollectible* obj)
  520. {
  521. /*
  522.  *  Determine the number of times obj is in this.
  523.  */
  524.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TSequence,somfOccurrencesOf)
  525.     (this, ev,obj);
  526. }
  527.  
  528.  
  529. /* method: somfTSequenceInit */
  530. somf_TSequence*   somfTSequenceInit(Environment *ev, 
  531.         somf_MCollectible_somf_MCollectibleCompareFn testfn)
  532. {
  533. /*
  534.  *  This method initializes a new TSequence.
  535.  */
  536.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TSequence,somfTSequenceInit)
  537.     (this, ev,testfn);
  538. }
  539.  
  540.  
  541. /* method: somfAdd */
  542. somf_MCollectible*   somfAdd(Environment *ev, 
  543.         somf_MCollectible* obj)
  544. {
  545.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TCollection,somfAdd)
  546.     (this, ev,obj);
  547. }
  548.  
  549.  
  550. /* method: somfRemove */
  551. somf_MCollectible*   somfRemove(Environment *ev, 
  552.         somf_MCollectible* obj)
  553. {
  554.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TCollection,somfRemove)
  555.     (this, ev,obj);
  556. }
  557.  
  558.  
  559. /* method: somfRemoveAll */
  560. void   somfRemoveAll(Environment *ev)
  561. {
  562.    SOM_ResolveD(this,somf_TSortedSequence,somf_TCollection,somfRemoveAll)
  563.     (this, ev);
  564. }
  565.  
  566.  
  567. /* method: somfDeleteAll */
  568. void   somfDeleteAll(Environment *ev)
  569. {
  570.    SOM_ResolveD(this,somf_TSortedSequence,somf_TCollection,somfDeleteAll)
  571.     (this, ev);
  572. }
  573.  
  574.  
  575. /* method: somfCount */
  576. long   somfCount(Environment *ev)
  577. {
  578.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TCollection,somfCount)
  579.     (this, ev);
  580. }
  581.  
  582.  
  583. /* method: somfCreateIterator */
  584. somf_TIterator*   somfCreateIterator(Environment *ev)
  585. {
  586.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TCollection,somfCreateIterator)
  587.     (this, ev);
  588. }
  589.  
  590.  
  591. /* method: somInit */
  592. void   somInit()
  593. {
  594.    SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somInit)
  595.     (this);
  596. }
  597.  
  598.  
  599. /* method: somfAddAll */
  600. void   somfAddAll(Environment *ev, 
  601.         somf_TCollection* col)
  602. {
  603. /*
  604.  *  Add all of the objects in collection to this.  Essentially this is
  605.  *  equivalent to getting an iterator for the collection passed in and adding
  606.  *  each element in the collection to this.
  607.  */
  608.    SOM_ResolveD(this,somf_TSortedSequence,somf_TCollection,somfAddAll)
  609.     (this, ev,col);
  610. }
  611.  
  612.  
  613. /* method: somfMember */
  614. somf_MCollectible*   somfMember(Environment *ev, 
  615.         somf_MCollectible* obj)
  616. {
  617. /*
  618.  *  Each object in this is compared to obj using the function testFn.  Return the
  619.  *  object for which testFn returned TRUE.  Return SOMF_NIL if not object was found.
  620.  */
  621.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TCollection,somfMember)
  622.     (this, ev,obj);
  623. }
  624.  
  625.  
  626. /* method: somfTestFunction */
  627. somf_MCollectible_somf_MCollectibleCompareFn   somfTestFunction(Environment *ev)
  628. {
  629. /*
  630.  *  Return the test function.  This is usually either IsSame or IsEqual.
  631.  */
  632.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TCollection,somfTestFunction)
  633.     (this, ev);
  634. }
  635.  
  636.  
  637. /* method: somfSetTestFunction */
  638. void   somfSetTestFunction(Environment *ev, 
  639.         somf_MCollectible_somf_MCollectibleCompareFn testfn)
  640. {
  641. /*
  642.  *  Set the test function.
  643.  */
  644.    SOM_ResolveD(this,somf_TSortedSequence,somf_TCollection,somfSetTestFunction)
  645.     (this, ev,testfn);
  646. }
  647.  
  648.  
  649. /* method: somfTCollectionInit */
  650. somf_TCollection*   somfTCollectionInit(Environment *ev, 
  651.         somf_MCollectible_somf_MCollectibleCompareFn testfn)
  652. {
  653. /*
  654.  *  Initialize the somf_TCollection test function to testfn.
  655.  */
  656.    return SOM_ResolveD(this,somf_TSortedSequence,somf_TCollection,somfTCollectionInit)
  657.     (this, ev,testfn);
  658. }
  659.  
  660.  
  661. /* method: somfIsEqual */
  662. boolean   somfIsEqual(Environment *ev, 
  663.         somf_MCollectible* obj)
  664. {
  665.    return SOM_ResolveD(this,somf_TSortedSequence,somf_MCollectible,somfIsEqual)
  666.     (this, ev,obj);
  667. }
  668.  
  669.  
  670. /* method: somfClone */
  671. somf_MCollectible*   somfClone(Environment *ev)
  672. {
  673. /*
  674.  *  somfClone provides a general function for creating a new instance of this.
  675.  */
  676.    return SOM_ResolveD(this,somf_TSortedSequence,somf_MCollectible,somfClone)
  677.     (this, ev);
  678. }
  679.  
  680.  
  681. /* method: somfClonePointer */
  682. somf_MCollectible*   somfClonePointer(Environment *ev, 
  683.         somf_MCollectible* clonee)
  684. {
  685. /*
  686.  *  somfClonePointer returns a pointer to a Clone
  687.  */
  688.    return SOM_ResolveD(this,somf_TSortedSequence,somf_MCollectible,somfClonePointer)
  689.     (this, ev,clonee);
  690. }
  691.  
  692.  
  693. /* method: somfHash */
  694. long   somfHash(Environment *ev)
  695. {
  696. /*
  697.  *  somfHash returns a value suitable for use as a hashing probe for this.
  698.  *  The default function will simply return the address of the object.
  699.  *  The default function is almost certainly not adequate if you are overriding
  700.  *  somfIsEqual because you need to make sure that all objects that "are equal"
  701.  *  to each other return the same hash value.  For example, a TText object would
  702.  *  return a hash value computed using the characters in the string instead of
  703.  *  the address of the string.
  704.  */
  705.    return SOM_ResolveD(this,somf_TSortedSequence,somf_MCollectible,somfHash)
  706.     (this, ev);
  707. }
  708.  
  709.  
  710. /* method: somfIsSame */
  711. boolean   somfIsSame(Environment *ev, 
  712.         somf_MCollectible* obj)
  713. {
  714. /*
  715.  *  The default function for somfIsSame is a pointer comparison
  716.  */
  717.    return SOM_ResolveD(this,somf_TSortedSequence,somf_MCollectible,somfIsSame)
  718.     (this, ev,obj);
  719. }
  720.  
  721.  
  722. /* method: somfIsNotEqual */
  723. boolean   somfIsNotEqual(Environment *ev, 
  724.         somf_MCollectible* obj)
  725. {
  726. /*
  727.  *  somfIsNotEqual returns TRUE if obj is NOT isomorphic to this.  It uses
  728.  *  somfIsEqual, so overriding somfIsEqual will handle the logic of somfIsNotEqual too.
  729.  */
  730.    return SOM_ResolveD(this,somf_TSortedSequence,somf_MCollectible,somfIsNotEqual)
  731.     (this, ev,obj);
  732. }
  733.  
  734.  
  735. /* initializer method: somDefaultInit */
  736. void   somDefaultInit(som3InitCtrl* ctrl)
  737. {
  738. /*
  739.  *  A default initializer for a SOM object. Passing a null ctrl
  740.  *  indicates to the receiver that its class is the class of the
  741.  *  object being initialized, whereby the initializer will determine
  742.  *  an appropriate control structure.
  743.  */
  744.    SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDefaultInit)
  745.     (this,ctrl);
  746. }
  747.  
  748.  
  749. /* method: somDestruct */
  750. void   somDestruct(octet doFree, 
  751.         som3DestructCtrl* ctrl)
  752. {
  753. /*
  754.  *  The default destructor for a SOM object. A nonzero <doFree>
  755.  *  indicates that the object storage should be freed by the
  756.  *  object's class (via somDeallocate) after uninitialization.
  757.  *  As with somDefaultInit, a null ctrl can be passed.
  758.  */
  759.    SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDestruct)
  760.     (this,doFree,ctrl);
  761. }
  762.  
  763.  
  764. /* initializer method: somDefaultCopyInit */
  765. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  766.         SOMObject* fromObj)
  767. {
  768. /*
  769.  *  A default copy constructor. Use this to make copies of objects for
  770.  *  calling methods with "by-value" argument semantics.
  771.  */
  772.    SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDefaultCopyInit)
  773.     (this,ctrl,fromObj);
  774. }
  775.  
  776.  
  777. /* method: somDefaultAssign */
  778. somf_TSortedSequence*  somDefaultAssign(som3AssignCtrl* ctrl, 
  779.         SOMObject* fromObj)
  780. {
  781. /*
  782.  *  A default assignment operator. Use this to "assign" the state of one
  783.  *  object to another.
  784.  */
  785.    return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDefaultAssign)
  786.     (this,ctrl,fromObj);
  787. }
  788.  
  789.  
  790. /* initializer method: somDefaultConstCopyInit */
  791. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  792.         SOMObject* fromObj)
  793. {
  794. /*
  795.  *  A default copy constructor that uses a const fromObj.
  796.  */
  797.    SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDefaultConstCopyInit)
  798.     (this,ctrl,fromObj);
  799. }
  800.  
  801.  
  802. /* initializer method: somDefaultVCopyInit */
  803. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  804.         SOMObject* fromObj)
  805. {
  806. /*
  807.  *  A default copy constructor that uses a volatile fromObj.
  808.  */
  809.    SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDefaultVCopyInit)
  810.     (this,ctrl,fromObj);
  811. }
  812.  
  813.  
  814. /* initializer method: somDefaultConstVCopyInit */
  815. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  816.         SOMObject* fromObj)
  817. {
  818. /*
  819.  *  A default copy constructor that uses a const volatile fromObj.
  820.  */
  821.    SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDefaultConstVCopyInit)
  822.     (this,ctrl,fromObj);
  823. }
  824.  
  825.  
  826. /* method: somDefaultConstAssign */
  827. somf_TSortedSequence*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  828.         SOMObject* fromObj)
  829. {
  830. /*
  831.  *  A default assignment operator that uses a const fromObj.
  832.  */
  833.    return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDefaultConstAssign)
  834.     (this,ctrl,fromObj);
  835. }
  836.  
  837.  
  838. /* method: somDefaultVAssign */
  839. somf_TSortedSequence*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  840.         SOMObject* fromObj)
  841. {
  842. /*
  843.  *  A default assignment operator that uses a volatile fromObj.
  844.  */
  845.    return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDefaultVAssign)
  846.     (this,ctrl,fromObj);
  847. }
  848.  
  849.  
  850. /* method: somDefaultConstVAssign */
  851. somf_TSortedSequence*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  852.         SOMObject* fromObj)
  853. {
  854. /*
  855.  *  A default assignment operator that uses a const volatile fromObj.
  856.  */
  857.    return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDefaultConstVAssign)
  858.     (this,ctrl,fromObj);
  859. }
  860.  
  861.  
  862. /* method: somFree */
  863. void   somFree()
  864. {
  865. /*
  866.  *  Use as directed by framework implementations.
  867.  */
  868.    SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somFree)
  869.     (this);
  870. }
  871.  
  872.  
  873. /* method: somUninit */
  874. void   somUninit()
  875. {
  876. /*
  877.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  878.  */
  879.    SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somUninit)
  880.     (this);
  881. }
  882.  
  883.  
  884. /* method: somGetClass */
  885. SOMClass*   somGetClass()
  886. {
  887. /*
  888.  *  Return the receiver's class.
  889.  */
  890.    return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somGetClass)
  891.     (this);
  892. }
  893.  
  894.  
  895. /* method: somGetClassName */
  896. string   somGetClassName()
  897. {
  898. /*
  899.  *  Return the name of the receiver's class.
  900.  */
  901.    return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somGetClassName)
  902.     (this);
  903. }
  904.  
  905.  
  906. /* method: somGetSize */
  907. long   somGetSize()
  908. {
  909. /*
  910.  *  Return the size of the receiver.
  911.  */
  912.    return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somGetSize)
  913.     (this);
  914. }
  915.  
  916.  
  917. /* method: somIsA */
  918. boolean   somIsA(SOMClass* aClassObj)
  919. {
  920. /*
  921.  *  Returns 1 (true) if the receiver responds to methods
  922.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  923.  */
  924.    return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somIsA)
  925.     (this,aClassObj);
  926. }
  927.  
  928.  
  929. /* method: somIsInstanceOf */
  930. boolean   somIsInstanceOf(SOMClass* aClassObj)
  931. {
  932. /*
  933.  *  Returns 1 (true) if the receiver is an instance of
  934.  *  <aClassObj> and 0 (false) otherwise.
  935.  */
  936.    return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somIsInstanceOf)
  937.     (this,aClassObj);
  938. }
  939.  
  940.  
  941. /* method: somRespondsTo */
  942. boolean   somRespondsTo(somId mId)
  943. {
  944. /*
  945.  *  Returns 1 (true) if the indicated method can be invoked
  946.  *  on the receiver and 0 (false) otherwise.
  947.  */
  948.    return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somRespondsTo)
  949.     (this,mId);
  950. }
  951.  
  952.  
  953. /* va_list method: somDispatch */
  954.  
  955. /*
  956.  *  This method provides a generic, class-specific dispatch mechanism.
  957.  *  It accepts as input <retValue> a pointer to the memory area to be
  958.  *  loaded with the result of dispatching the method indicated by
  959.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  960.  *  on which the method is to be invoked as the first argument.
  961.  */
  962. /* the va_list invocation form */
  963. boolean   somf_TSortedSequence_somDispatch(somToken* retValue, 
  964.         somId methodId, 
  965.         va_list ap)
  966. {return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDispatch)
  967.     (this,retValue,methodId,ap);
  968. }
  969.  
  970. /* the varargs invocation form */
  971. boolean   somDispatch(somToken* retValue, 
  972.         somId methodId, 
  973.         ...)
  974. {
  975. /*
  976.  *  This method provides a generic, class-specific dispatch mechanism.
  977.  *  It accepts as input <retValue> a pointer to the memory area to be
  978.  *  loaded with the result of dispatching the method indicated by
  979.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  980.  *  on which the method is to be invoked as the first argument.
  981.  */
  982.    va_list ap;
  983.    va_start(ap, methodId);
  984.    boolean __somResult = 
  985.       SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDispatch)
  986.     (this,retValue,methodId,ap);
  987.    va_end(ap);
  988.    return __somResult;
  989. }
  990.  
  991.  
  992. /* va_list method: somClassDispatch */
  993.  
  994. /*
  995.  *  Like somDispatch, but method resolution for static methods is done
  996.  *  according to the clsObj instance method table.
  997.  */
  998. /* the va_list invocation form */
  999. boolean   somf_TSortedSequence_somClassDispatch(SOMClass* clsObj, 
  1000.         somToken* retValue, 
  1001.         somId methodId, 
  1002.         va_list ap)
  1003. {return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somClassDispatch)
  1004.     (this,clsObj,retValue,methodId,ap);
  1005. }
  1006.  
  1007. /* the varargs invocation form */
  1008. boolean   somClassDispatch(SOMClass* clsObj, 
  1009.         somToken* retValue, 
  1010.         somId methodId, 
  1011.         ...)
  1012. {
  1013. /*
  1014.  *  Like somDispatch, but method resolution for static methods is done
  1015.  *  according to the clsObj instance method table.
  1016.  */
  1017.    va_list ap;
  1018.    va_start(ap, methodId);
  1019.    boolean __somResult = 
  1020.       SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somClassDispatch)
  1021.     (this,clsObj,retValue,methodId,ap);
  1022.    va_end(ap);
  1023.    return __somResult;
  1024. }
  1025.  
  1026.  
  1027. /* method: somCastObj */
  1028. boolean   somCastObj(SOMClass* cls)
  1029. {
  1030. /*
  1031.  *  cast the receiving object to cls (which must be an ancestor of the
  1032.  *  objects true class. Returns true on success.
  1033.  */
  1034.    return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somCastObj)
  1035.     (this,cls);
  1036. }
  1037.  
  1038.  
  1039. /* method: somResetObj */
  1040. boolean   somResetObj()
  1041. {
  1042. /*
  1043.  *  reset an object to its true class. Returns true always.
  1044.  */
  1045.    return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somResetObj)
  1046.     (this);
  1047. }
  1048.  
  1049.  
  1050. /* va_list method: somDispatchV */
  1051.  
  1052. /*
  1053.  *  Obsolete. Use somDispatch instead.
  1054.  */
  1055. /* the va_list invocation form */
  1056. void   somf_TSortedSequence_somDispatchV(somId methodId, 
  1057.         somId descriptor, 
  1058.         va_list ap)
  1059. {   SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDispatchV)
  1060.     (this,methodId,descriptor,ap);
  1061. }
  1062.  
  1063. /* the varargs invocation form */
  1064. void   somDispatchV(somId methodId, 
  1065.         somId descriptor, 
  1066.         ...)
  1067. {
  1068. /*
  1069.  *  Obsolete. Use somDispatch instead.
  1070.  */
  1071.    va_list ap;
  1072.    va_start(ap, descriptor);
  1073.    SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDispatchV)
  1074.     (this,methodId,descriptor,ap);
  1075.    va_end(ap);
  1076. }
  1077.  
  1078.  
  1079. /* va_list method: somDispatchL */
  1080.  
  1081. /*
  1082.  *  Obsolete. Use somDispatch instead.
  1083.  */
  1084. /* the va_list invocation form */
  1085. long   somf_TSortedSequence_somDispatchL(somId methodId, 
  1086.         somId descriptor, 
  1087.         va_list ap)
  1088. {return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDispatchL)
  1089.     (this,methodId,descriptor,ap);
  1090. }
  1091.  
  1092. /* the varargs invocation form */
  1093. long   somDispatchL(somId methodId, 
  1094.         somId descriptor, 
  1095.         ...)
  1096. {
  1097. /*
  1098.  *  Obsolete. Use somDispatch instead.
  1099.  */
  1100.    va_list ap;
  1101.    va_start(ap, descriptor);
  1102.    long __somResult = 
  1103.       SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDispatchL)
  1104.     (this,methodId,descriptor,ap);
  1105.    va_end(ap);
  1106.    return __somResult;
  1107. }
  1108.  
  1109.  
  1110. /* va_list method: somDispatchA */
  1111.  
  1112. /*
  1113.  *  Obsolete. Use somDispatch instead.
  1114.  */
  1115. /* the va_list invocation form */
  1116. void*   somf_TSortedSequence_somDispatchA(somId methodId, 
  1117.         somId descriptor, 
  1118.         va_list ap)
  1119. {return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDispatchA)
  1120.     (this,methodId,descriptor,ap);
  1121. }
  1122.  
  1123. /* the varargs invocation form */
  1124. void*   somDispatchA(somId methodId, 
  1125.         somId descriptor, 
  1126.         ...)
  1127. {
  1128. /*
  1129.  *  Obsolete. Use somDispatch instead.
  1130.  */
  1131.    va_list ap;
  1132.    va_start(ap, descriptor);
  1133.    void* __somResult = 
  1134.       SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDispatchA)
  1135.     (this,methodId,descriptor,ap);
  1136.    va_end(ap);
  1137.    return __somResult;
  1138. }
  1139.  
  1140.  
  1141. /* va_list method: somDispatchD */
  1142.  
  1143. /*
  1144.  *  Obsolete. Use somDispatch instead.
  1145.  */
  1146. /* the va_list invocation form */
  1147. double   somf_TSortedSequence_somDispatchD(somId methodId, 
  1148.         somId descriptor, 
  1149.         va_list ap)
  1150. {return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDispatchD)
  1151.     (this,methodId,descriptor,ap);
  1152. }
  1153.  
  1154. /* the varargs invocation form */
  1155. double   somDispatchD(somId methodId, 
  1156.         somId descriptor, 
  1157.         ...)
  1158. {
  1159. /*
  1160.  *  Obsolete. Use somDispatch instead.
  1161.  */
  1162.    va_list ap;
  1163.    va_start(ap, descriptor);
  1164.    double __somResult = 
  1165.       SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDispatchD)
  1166.     (this,methodId,descriptor,ap);
  1167.    va_end(ap);
  1168.    return __somResult;
  1169. }
  1170.  
  1171.  
  1172. /* method: somPrintSelf */
  1173. SOMObject*   somPrintSelf()
  1174. {
  1175. /*
  1176.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  1177.  *  information about this object.  The default implementation just gives
  1178.  *  the object's class name and its address in memory.
  1179.  *  <self> is returned.
  1180.  */
  1181.    return SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somPrintSelf)
  1182.     (this);
  1183. }
  1184.  
  1185.  
  1186. /* method: somDumpSelf */
  1187. void   somDumpSelf(long level)
  1188. {
  1189. /*
  1190.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  1191.  *  and its current state.
  1192.  * 
  1193.  *  <level> indicates the nesting level for describing compound objects
  1194.  *  it must be greater than or equal to zero.  All lines in the
  1195.  *  description will be preceeded by <2*level> spaces.
  1196.  * 
  1197.  *  This routine only actually writes the data that concerns the object
  1198.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  1199.  *  the object's current state.  This approach allows readable
  1200.  *  descriptions of compound objects to be constructed.
  1201.  * 
  1202.  *  Generally it is not necessary to override this method, if it is
  1203.  *  overriden it generally must be completely replaced.
  1204.  */
  1205.    SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDumpSelf)
  1206.     (this,level);
  1207. }
  1208.  
  1209.  
  1210. /* method: somDumpSelfInt */
  1211. void   somDumpSelfInt(long level)
  1212. {
  1213. /*
  1214.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  1215.  *  Generally this method will need to be overridden.  When overriding
  1216.  *  it, begin by calling the parent class form of this method and then
  1217.  *  write in a description of your class's instance data. This will
  1218.  *  result in a description of all the object's instance data going
  1219.  *  from its root ancestor class to its specific class.
  1220.  */
  1221.    SOM_ResolveD(this,somf_TSortedSequence,SOMObject,somDumpSelfInt)
  1222.     (this,level);
  1223. }
  1224.  
  1225.  
  1226.  
  1227. };   /* somf_TSortedSequence */
  1228.  
  1229.  
  1230.  
  1231. #endif       /* SOM_somf_TSortedSequence_xh */
  1232.