home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / tset.xh < prev    next >
Text File  |  1999-02-22  |  40KB  |  1,363 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: tset.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_TSet
  25.  * 
  26.  * DESCRIPTION: The somf_TSet class is a subclass of somf_TCollection.  It
  27.  *              represents an unordered collection of objects in which objects
  28.  *              can appear only once.  Objects which are inserted into the
  29.  *              somf_TSet should override the Hash() method and the IsSame() or
  30.  *              IsEqual() method.
  31.  * 
  32.  *  This file was generated by the SOM Compiler.
  33.  *  FileName: TSet.id2.
  34.  *  Generated using:
  35.  *      SOM Precompiler spc: 6.13
  36.  *      SOM Emitter emitidl.dll: 6.18
  37.  */
  38.  
  39.  
  40. #ifndef SOM_somf_TSet_xh
  41. #define SOM_somf_TSet_xh
  42.  
  43. class somf_TSet;
  44.  
  45. #define somf_TSet_MajorVersion 2
  46. #define somf_TSet_MinorVersion 1
  47.  
  48. /* C++ SOM defs */
  49. #include <somcls.xh>
  50. #include <somcm.xh>
  51.  
  52. /* C++ parent defs */
  53. #ifndef SOM_somf_TCollection_xh
  54. #include <tcollect.xh>
  55. #endif
  56.  
  57. #ifndef somf_TSet_API
  58. #define somf_TSet_API
  59. /*
  60.  * -- The Class API
  61.  */
  62.  
  63. /*
  64.  * Start of bindings for IDL types
  65.  */
  66.  
  67. class SOMClass;
  68. class SOMObject;
  69. class somf_TIterator;
  70. class TSAssoc;
  71. typedef unsigned long somf_TSet_ESetClassification;
  72. #define somf_TSet_kUnchecked 1UL
  73. #define somf_TSet_kNormal 2UL
  74. #define somf_TSet_kFast 3UL
  75.  
  76. #ifndef SOM_DONT_USE_SHORT_NAMES
  77. #ifndef SOMTGD_ESetClassification
  78.     #ifdef ESetClassification
  79.         #undef ESetClassification
  80.         #define SOMTGD_ESetClassification 1
  81.     #else
  82.         #define ESetClassification somf_TSet_ESetClassification
  83.     #endif /* ESetClassification */
  84. #endif /* SOMTGD_ESetClassification */
  85. #endif /* SOM_DONT_USE_SHORT_NAMES */
  86.  
  87. /*
  88.  * End of bindings for IDL types.
  89.  */
  90.  
  91. /*
  92.  * Passthru lines: File: "C.xh", "after"
  93.  */
  94.  
  95.  
  96. #include <titeratr.xh>
  97. #include <mcollect.xh>
  98.  
  99. /* A procedure to create the somf_TSet Class */
  100. SOMEXTERN SOMClass * SOMLINK somf_TSetNewClass(
  101.         integer4 majorVersion,
  102.         integer4 minorVersion);
  103.  
  104. /* The API to the somf_TSet class object, and the methods it introduces. */
  105. SOMEXTERN struct somf_TSetClassDataStructure {
  106.     SOMClass *classObject;
  107.     somMToken somfDifferenceS;
  108.     somMToken somfDifferenceSS;
  109.     somMToken somfIntersectionS;
  110.     somMToken somfIntersectionSS;
  111.     somMToken somfUnionS;
  112.     somMToken somfUnionSS;
  113.     somMToken somfXorS;
  114.     somMToken somfXorSS;
  115.     somMToken somfSetHashFunction;
  116.     somMToken somfGetHashFunction;
  117.     somMToken somfRehash;
  118.     somMToken somfFind;
  119.     somMToken somfMakeNewTable;
  120.     somMToken somfCopyIn;
  121.     somMToken somfGrow;
  122.     somMToken somfAssign;
  123.     somMToken somfTSetInitFL;
  124.     somMToken somfTSetInitF;
  125.     somMToken somfTSetInitLF;
  126.     somMToken somfTSetInitL;
  127.     somMToken somfTSetInitS;
  128. } SOMDLINK somf_TSetClassData;
  129. #define _somf_TSet somf_TSetClassData.classObject
  130.  
  131. /* The API to parentMtabs for somf_TSet, and the instance data it introduces. */
  132. SOMEXTERN struct somf_TSetCClassDataStructure {
  133.     somMethodTabs parentMtab;
  134.     somDToken              instanceDataToken;
  135. } SOMDLINK somf_TSetCClassData;
  136.  
  137. /*
  138.  * -- Typedefs for somf_TSet Method Procedures
  139.  */
  140. SOMEXTERN {
  141. typedef somf_TSet*   SOMLINK somTP_somf_TSet_somfTSetInitFL(somf_TSet *somSelf, Environment *ev, 
  142.         somf_MCollectible_somf_MCollectibleCompareFn testfn, 
  143.         long setSizeHint);
  144. typedef somTP_somf_TSet_somfTSetInitFL *somTD_somf_TSet_somfTSetInitFL;
  145. typedef somf_TSet*   SOMLINK somTP_somf_TSet_somfTSetInitF(somf_TSet *somSelf, Environment *ev, 
  146.         somf_MCollectible_somf_MCollectibleCompareFn testfn);
  147. typedef somTP_somf_TSet_somfTSetInitF *somTD_somf_TSet_somfTSetInitF;
  148. typedef somf_TSet*   SOMLINK somTP_somf_TSet_somfTSetInitLF(somf_TSet *somSelf, Environment *ev, 
  149.         long setSizeHint, 
  150.         somf_MCollectible_somf_MCollectibleCompareFn testfn);
  151. typedef somTP_somf_TSet_somfTSetInitLF *somTD_somf_TSet_somfTSetInitLF;
  152. typedef somf_TSet*   SOMLINK somTP_somf_TSet_somfTSetInitL(somf_TSet *somSelf, Environment *ev, 
  153.         long setSizeHint);
  154. typedef somTP_somf_TSet_somfTSetInitL *somTD_somf_TSet_somfTSetInitL;
  155. typedef somf_TSet*   SOMLINK somTP_somf_TSet_somfTSetInitS(somf_TSet *somSelf, Environment *ev, 
  156.         somf_TSet* s);
  157. typedef somTP_somf_TSet_somfTSetInitS *somTD_somf_TSet_somfTSetInitS;
  158. typedef void   SOMLINK somTP_somf_TSet_somfAssign(somf_TSet *somSelf, Environment *ev, 
  159.         somf_TSet* source);
  160. typedef somTP_somf_TSet_somfAssign *somTD_somf_TSet_somfAssign;
  161. typedef void   SOMLINK somTP_somf_TSet_somfDifferenceS(somf_TSet *somSelf, Environment *ev, 
  162.         somf_TSet* set1);
  163. typedef somTP_somf_TSet_somfDifferenceS *somTD_somf_TSet_somfDifferenceS;
  164. typedef void   SOMLINK somTP_somf_TSet_somfDifferenceSS(somf_TSet *somSelf, Environment *ev, 
  165.         somf_TSet* set1, 
  166.         somf_TSet* resultSet);
  167. typedef somTP_somf_TSet_somfDifferenceSS *somTD_somf_TSet_somfDifferenceSS;
  168. typedef void   SOMLINK somTP_somf_TSet_somfIntersectionS(somf_TSet *somSelf, Environment *ev, 
  169.         somf_TSet* set1);
  170. typedef somTP_somf_TSet_somfIntersectionS *somTD_somf_TSet_somfIntersectionS;
  171. typedef void   SOMLINK somTP_somf_TSet_somfIntersectionSS(somf_TSet *somSelf, Environment *ev, 
  172.         somf_TSet* set1, 
  173.         somf_TSet* resultSet);
  174. typedef somTP_somf_TSet_somfIntersectionSS *somTD_somf_TSet_somfIntersectionSS;
  175. typedef void   SOMLINK somTP_somf_TSet_somfUnionS(somf_TSet *somSelf, Environment *ev, 
  176.         somf_TSet* set1);
  177. typedef somTP_somf_TSet_somfUnionS *somTD_somf_TSet_somfUnionS;
  178. typedef void   SOMLINK somTP_somf_TSet_somfUnionSS(somf_TSet *somSelf, Environment *ev, 
  179.         somf_TSet* set1, 
  180.         somf_TSet* resultSet);
  181. typedef somTP_somf_TSet_somfUnionSS *somTD_somf_TSet_somfUnionSS;
  182. typedef void   SOMLINK somTP_somf_TSet_somfXorS(somf_TSet *somSelf, Environment *ev, 
  183.         somf_TSet* set1);
  184. typedef somTP_somf_TSet_somfXorS *somTD_somf_TSet_somfXorS;
  185. typedef void   SOMLINK somTP_somf_TSet_somfXorSS(somf_TSet *somSelf, Environment *ev, 
  186.         somf_TSet* set1, 
  187.         somf_TSet* resultSet);
  188. typedef somTP_somf_TSet_somfXorSS *somTD_somf_TSet_somfXorSS;
  189. typedef void   SOMLINK somTP_somf_TSet_somfSetHashFunction(somf_TSet *somSelf, Environment *ev, 
  190.         somf_MCollectible_somf_MCollectibleHashFn fn);
  191. typedef somTP_somf_TSet_somfSetHashFunction *somTD_somf_TSet_somfSetHashFunction;
  192. typedef somf_MCollectible_somf_MCollectibleHashFn   SOMLINK somTP_somf_TSet_somfGetHashFunction(somf_TSet *somSelf, Environment *ev);
  193. typedef somTP_somf_TSet_somfGetHashFunction *somTD_somf_TSet_somfGetHashFunction;
  194. typedef void   SOMLINK somTP_somf_TSet_somfRehash(somf_TSet *somSelf, Environment *ev);
  195. typedef somTP_somf_TSet_somfRehash *somTD_somf_TSet_somfRehash;
  196.  
  197. /*
  198.  * -- Typedefs for Reintroduced Wrapper Methods
  199.  */
  200. typedef somf_MCollectible*   SOMLINK somTP_somf_TSet_somfAdd(somf_TSet *somSelf, Environment *ev, 
  201.         somf_MCollectible* obj);
  202. typedef somTP_somf_TSet_somfAdd *somTD_somf_TSet_somfAdd;
  203. typedef void   SOMLINK somTP_somf_TSet_somfAddAll(somf_TSet *somSelf, Environment *ev, 
  204.         somf_TCollection* col);
  205. typedef somTP_somf_TSet_somfAddAll *somTD_somf_TSet_somfAddAll;
  206. typedef somf_MCollectible*   SOMLINK somTP_somf_TSet_somfRemove(somf_TSet *somSelf, Environment *ev, 
  207.         somf_MCollectible* obj);
  208. typedef somTP_somf_TSet_somfRemove *somTD_somf_TSet_somfRemove;
  209. typedef void   SOMLINK somTP_somf_TSet_somfRemoveAll(somf_TSet *somSelf, Environment *ev);
  210. typedef somTP_somf_TSet_somfRemoveAll *somTD_somf_TSet_somfRemoveAll;
  211. typedef void   SOMLINK somTP_somf_TSet_somfDeleteAll(somf_TSet *somSelf, Environment *ev);
  212. typedef somTP_somf_TSet_somfDeleteAll *somTD_somf_TSet_somfDeleteAll;
  213. typedef long   SOMLINK somTP_somf_TSet_somfCount(somf_TSet *somSelf, Environment *ev);
  214. typedef somTP_somf_TSet_somfCount *somTD_somf_TSet_somfCount;
  215. typedef somf_MCollectible*   SOMLINK somTP_somf_TSet_somfMember(somf_TSet *somSelf, Environment *ev, 
  216.         somf_MCollectible* obj);
  217. typedef somTP_somf_TSet_somfMember *somTD_somf_TSet_somfMember;
  218. typedef somf_TIterator*   SOMLINK somTP_somf_TSet_somfCreateIterator(somf_TSet *somSelf, Environment *ev);
  219. typedef somTP_somf_TSet_somfCreateIterator *somTD_somf_TSet_somfCreateIterator;
  220. typedef somf_MCollectible_somf_MCollectibleCompareFn   SOMLINK somTP_somf_TSet_somfTestFunction(somf_TSet *somSelf, Environment *ev);
  221. typedef somTP_somf_TSet_somfTestFunction *somTD_somf_TSet_somfTestFunction;
  222. typedef void   SOMLINK somTP_somf_TSet_somfSetTestFunction(somf_TSet *somSelf, Environment *ev, 
  223.         somf_MCollectible_somf_MCollectibleCompareFn testfn);
  224. typedef somTP_somf_TSet_somfSetTestFunction *somTD_somf_TSet_somfSetTestFunction;
  225. typedef somf_TCollection*   SOMLINK somTP_somf_TSet_somfTCollectionInit(somf_TSet *somSelf, Environment *ev, 
  226.         somf_MCollectible_somf_MCollectibleCompareFn testfn);
  227. typedef somTP_somf_TSet_somfTCollectionInit *somTD_somf_TSet_somfTCollectionInit;
  228. typedef boolean   SOMLINK somTP_somf_TSet_somfIsEqual(somf_TSet *somSelf, Environment *ev, 
  229.         somf_MCollectible* obj);
  230. typedef somTP_somf_TSet_somfIsEqual *somTD_somf_TSet_somfIsEqual;
  231. typedef somf_MCollectible*   SOMLINK somTP_somf_TSet_somfClone(somf_TSet *somSelf, Environment *ev);
  232. typedef somTP_somf_TSet_somfClone *somTD_somf_TSet_somfClone;
  233. typedef somf_MCollectible*   SOMLINK somTP_somf_TSet_somfClonePointer(somf_TSet *somSelf, Environment *ev, 
  234.         somf_MCollectible* clonee);
  235. typedef somTP_somf_TSet_somfClonePointer *somTD_somf_TSet_somfClonePointer;
  236. typedef long   SOMLINK somTP_somf_TSet_somfHash(somf_TSet *somSelf, Environment *ev);
  237. typedef somTP_somf_TSet_somfHash *somTD_somf_TSet_somfHash;
  238. typedef boolean   SOMLINK somTP_somf_TSet_somfIsSame(somf_TSet *somSelf, Environment *ev, 
  239.         somf_MCollectible* obj);
  240. typedef somTP_somf_TSet_somfIsSame *somTD_somf_TSet_somfIsSame;
  241. typedef boolean   SOMLINK somTP_somf_TSet_somfIsNotEqual(somf_TSet *somSelf, Environment *ev, 
  242.         somf_MCollectible* obj);
  243. typedef somTP_somf_TSet_somfIsNotEqual *somTD_somf_TSet_somfIsNotEqual;
  244. typedef void   SOMLINK somTP_somf_TSet_somDefaultInit(somf_TSet *somSelf, 
  245.         som3InitCtrl* ctrl);
  246. typedef somTP_somf_TSet_somDefaultInit *somTD_somf_TSet_somDefaultInit;
  247. typedef void   SOMLINK somTP_somf_TSet_somDestruct(somf_TSet *somSelf, 
  248.         octet doFree, 
  249.         som3DestructCtrl* ctrl);
  250. typedef somTP_somf_TSet_somDestruct *somTD_somf_TSet_somDestruct;
  251. typedef void   SOMLINK somTP_somf_TSet_somDefaultCopyInit(somf_TSet *somSelf, 
  252.         som3InitCtrl* ctrl, 
  253.         SOMObject* fromObj);
  254. typedef somTP_somf_TSet_somDefaultCopyInit *somTD_somf_TSet_somDefaultCopyInit;
  255. typedef somf_TSet*   SOMLINK somTP_somf_TSet_somDefaultAssign(somf_TSet *somSelf, 
  256.         som3AssignCtrl* ctrl, 
  257.         SOMObject* fromObj);
  258. typedef somTP_somf_TSet_somDefaultAssign *somTD_somf_TSet_somDefaultAssign;
  259. typedef void   SOMLINK somTP_somf_TSet_somDefaultConstCopyInit(somf_TSet *somSelf, 
  260.         som3InitCtrl* ctrl, 
  261.         SOMObject* fromObj);
  262. typedef somTP_somf_TSet_somDefaultConstCopyInit *somTD_somf_TSet_somDefaultConstCopyInit;
  263. typedef void   SOMLINK somTP_somf_TSet_somDefaultVCopyInit(somf_TSet *somSelf, 
  264.         som3InitCtrl* ctrl, 
  265.         SOMObject* fromObj);
  266. typedef somTP_somf_TSet_somDefaultVCopyInit *somTD_somf_TSet_somDefaultVCopyInit;
  267. typedef void   SOMLINK somTP_somf_TSet_somDefaultConstVCopyInit(somf_TSet *somSelf, 
  268.         som3InitCtrl* ctrl, 
  269.         SOMObject* fromObj);
  270. typedef somTP_somf_TSet_somDefaultConstVCopyInit *somTD_somf_TSet_somDefaultConstVCopyInit;
  271. typedef somf_TSet*   SOMLINK somTP_somf_TSet_somDefaultConstAssign(somf_TSet *somSelf, 
  272.         som3AssignCtrl* ctrl, 
  273.         SOMObject* fromObj);
  274. typedef somTP_somf_TSet_somDefaultConstAssign *somTD_somf_TSet_somDefaultConstAssign;
  275. typedef somf_TSet*   SOMLINK somTP_somf_TSet_somDefaultVAssign(somf_TSet *somSelf, 
  276.         som3AssignCtrl* ctrl, 
  277.         SOMObject* fromObj);
  278. typedef somTP_somf_TSet_somDefaultVAssign *somTD_somf_TSet_somDefaultVAssign;
  279. typedef somf_TSet*   SOMLINK somTP_somf_TSet_somDefaultConstVAssign(somf_TSet *somSelf, 
  280.         som3AssignCtrl* ctrl, 
  281.         SOMObject* fromObj);
  282. typedef somTP_somf_TSet_somDefaultConstVAssign *somTD_somf_TSet_somDefaultConstVAssign;
  283. typedef void   SOMLINK somTP_somf_TSet_somInit(somf_TSet *somSelf);
  284. typedef somTP_somf_TSet_somInit *somTD_somf_TSet_somInit;
  285. typedef void   SOMLINK somTP_somf_TSet_somFree(somf_TSet *somSelf);
  286. typedef somTP_somf_TSet_somFree *somTD_somf_TSet_somFree;
  287. typedef void   SOMLINK somTP_somf_TSet_somUninit(somf_TSet *somSelf);
  288. typedef somTP_somf_TSet_somUninit *somTD_somf_TSet_somUninit;
  289. typedef SOMClass*   SOMLINK somTP_somf_TSet_somGetClass(somf_TSet *somSelf);
  290. typedef somTP_somf_TSet_somGetClass *somTD_somf_TSet_somGetClass;
  291. typedef string   SOMLINK somTP_somf_TSet_somGetClassName(somf_TSet *somSelf);
  292. typedef somTP_somf_TSet_somGetClassName *somTD_somf_TSet_somGetClassName;
  293. typedef long   SOMLINK somTP_somf_TSet_somGetSize(somf_TSet *somSelf);
  294. typedef somTP_somf_TSet_somGetSize *somTD_somf_TSet_somGetSize;
  295. typedef boolean   SOMLINK somTP_somf_TSet_somIsA(somf_TSet *somSelf, 
  296.         SOMClass* aClassObj);
  297. typedef somTP_somf_TSet_somIsA *somTD_somf_TSet_somIsA;
  298. typedef boolean   SOMLINK somTP_somf_TSet_somIsInstanceOf(somf_TSet *somSelf, 
  299.         SOMClass* aClassObj);
  300. typedef somTP_somf_TSet_somIsInstanceOf *somTD_somf_TSet_somIsInstanceOf;
  301. typedef boolean   SOMLINK somTP_somf_TSet_somRespondsTo(somf_TSet *somSelf, 
  302.         somId mId);
  303. typedef somTP_somf_TSet_somRespondsTo *somTD_somf_TSet_somRespondsTo;
  304. typedef boolean   SOMLINK somTP_somf_TSet_somDispatch(somf_TSet *somSelf, 
  305.         somToken* retValue, 
  306.         somId methodId, 
  307.         va_list ap);
  308. typedef somTP_somf_TSet_somDispatch *somTD_somf_TSet_somDispatch;
  309. typedef boolean   SOMLINK somTP_somf_TSet_somClassDispatch(somf_TSet *somSelf, 
  310.         SOMClass* clsObj, 
  311.         somToken* retValue, 
  312.         somId methodId, 
  313.         va_list ap);
  314. typedef somTP_somf_TSet_somClassDispatch *somTD_somf_TSet_somClassDispatch;
  315. typedef boolean   SOMLINK somTP_somf_TSet_somCastObj(somf_TSet *somSelf, 
  316.         SOMClass* cls);
  317. typedef somTP_somf_TSet_somCastObj *somTD_somf_TSet_somCastObj;
  318. typedef boolean   SOMLINK somTP_somf_TSet_somResetObj(somf_TSet *somSelf);
  319. typedef somTP_somf_TSet_somResetObj *somTD_somf_TSet_somResetObj;
  320. typedef void   SOMLINK somTP_somf_TSet_somDispatchV(somf_TSet *somSelf, 
  321.         somId methodId, 
  322.         somId descriptor, 
  323.         va_list ap);
  324. typedef somTP_somf_TSet_somDispatchV *somTD_somf_TSet_somDispatchV;
  325. typedef long   SOMLINK somTP_somf_TSet_somDispatchL(somf_TSet *somSelf, 
  326.         somId methodId, 
  327.         somId descriptor, 
  328.         va_list ap);
  329. typedef somTP_somf_TSet_somDispatchL *somTD_somf_TSet_somDispatchL;
  330. typedef void*   SOMLINK somTP_somf_TSet_somDispatchA(somf_TSet *somSelf, 
  331.         somId methodId, 
  332.         somId descriptor, 
  333.         va_list ap);
  334. typedef somTP_somf_TSet_somDispatchA *somTD_somf_TSet_somDispatchA;
  335. typedef double   SOMLINK somTP_somf_TSet_somDispatchD(somf_TSet *somSelf, 
  336.         somId methodId, 
  337.         somId descriptor, 
  338.         va_list ap);
  339. typedef somTP_somf_TSet_somDispatchD *somTD_somf_TSet_somDispatchD;
  340. typedef SOMObject*   SOMLINK somTP_somf_TSet_somPrintSelf(somf_TSet *somSelf);
  341. typedef somTP_somf_TSet_somPrintSelf *somTD_somf_TSet_somPrintSelf;
  342. typedef void   SOMLINK somTP_somf_TSet_somDumpSelf(somf_TSet *somSelf, 
  343.         long level);
  344. typedef somTP_somf_TSet_somDumpSelf *somTD_somf_TSet_somDumpSelf;
  345. typedef void   SOMLINK somTP_somf_TSet_somDumpSelfInt(somf_TSet *somSelf, 
  346.         long level);
  347. typedef somTP_somf_TSet_somDumpSelfInt *somTD_somf_TSet_somDumpSelfInt;
  348. }
  349.  
  350. #endif /* somf_TSet_API */
  351.  
  352.  
  353. /*
  354.  * -- This emitter treats Method Tokens as Thunks by default.
  355.  * -- Use the sc modifier "nothunks" to change this default
  356.  */
  357. #undef somresolve_
  358. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  359.  
  360. /*
  361.  * -- The C++ Wrapper Class for somf_TSet
  362.  */
  363. class somf_TSet : public somf_TCollection
  364. {
  365. public:
  366.  
  367. // somf_TSet::new creates the class object if necessary, and then uses somNewNoInit
  368. // to allocate memory and create the object. Initialization is in ctors.
  369. void *operator new(size_t)
  370. {
  371.    if (!_somf_TSet) somf_TSetNewClass(somf_TSet_MajorVersion,somf_TSet_MinorVersion);
  372.    return (void*)
  373.       SOM_Resolve(_somf_TSet,SOMClass,somNewNoInit)
  374.          ((SOMClass *)((void*)_somf_TSet));
  375. }
  376.  
  377. // somf_TSet::delete uses somDestruct.
  378. void operator delete(void * obj)
  379. {
  380.    if (obj && *(void**)obj) {
  381.       SOM_Resolve(obj,SOMObject,somFree)
  382.          ((SOMObject*)obj);
  383.    }
  384. }
  385.  
  386. somf_TSet& operator=(somf_TSet& fromObj)
  387. {
  388.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  389.    return *this;
  390. }
  391.  
  392. somf_TSet()
  393. {
  394.    if (*(void**)this != 
  395.        ((somParentMtabStructPtr)
  396.         (somf_TSetCClassData.parentMtab))->mtab)
  397.       return;
  398.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  399. }
  400.  
  401. somf_TSet(somf_TSet* fromObj)
  402. {
  403.    if (*(void**)this != 
  404.        ((somParentMtabStructPtr)
  405.         (somf_TSetCClassData.parentMtab))->mtab)
  406.       return;
  407.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  408. }
  409.  
  410. #ifdef __IBMCPP__
  411. #pragma info(nocnv,nopar)
  412. #endif
  413. somf_TSet(const somf_TSet* fromObj)
  414. {
  415.    if (*(void**)this != 
  416.        ((somParentMtabStructPtr)
  417.         (somf_TSetCClassData.parentMtab))->mtab)
  418.       return;
  419.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  420. }
  421. #ifdef __IBMCPP__
  422. #pragma info(restore)
  423. #endif
  424.  
  425.  
  426. /* method: somfTSetInitFL */
  427. somf_TSet*   somfTSetInitFL(Environment *ev, 
  428.         somf_MCollectible_somf_MCollectibleCompareFn testfn, 
  429.         long setSizeHint)
  430. {
  431. /*
  432.  *  Initializes the new set.
  433.  */
  434.    return SOM_ResolveD(this,somf_TSet,somf_TSet,somfTSetInitFL)
  435.     (this, ev,testfn,setSizeHint);
  436. }
  437.  
  438.  
  439. /* method: somfTSetInitF */
  440. somf_TSet*   somfTSetInitF(Environment *ev, 
  441.         somf_MCollectible_somf_MCollectibleCompareFn testfn)
  442. {
  443. /*
  444.  *  Initializes the new set.
  445.  */
  446.    return SOM_ResolveD(this,somf_TSet,somf_TSet,somfTSetInitF)
  447.     (this, ev,testfn);
  448. }
  449.  
  450.  
  451. /* method: somfTSetInitLF */
  452. somf_TSet*   somfTSetInitLF(Environment *ev, 
  453.         long setSizeHint, 
  454.         somf_MCollectible_somf_MCollectibleCompareFn testfn)
  455. {
  456. /*
  457.  *  Initializes the new set.
  458.  */
  459.    return SOM_ResolveD(this,somf_TSet,somf_TSet,somfTSetInitLF)
  460.     (this, ev,setSizeHint,testfn);
  461. }
  462.  
  463.  
  464. /* method: somfTSetInitL */
  465. somf_TSet*   somfTSetInitL(Environment *ev, 
  466.         long setSizeHint)
  467. {
  468. /*
  469.  *  Initializes the new set.
  470.  */
  471.    return SOM_ResolveD(this,somf_TSet,somf_TSet,somfTSetInitL)
  472.     (this, ev,setSizeHint);
  473. }
  474.  
  475.  
  476. /* method: somfTSetInitS */
  477. somf_TSet*   somfTSetInitS(Environment *ev, 
  478.         somf_TSet* s)
  479. {
  480. /*
  481.  *  Initializes the new set.
  482.  */
  483.    return SOM_ResolveD(this,somf_TSet,somf_TSet,somfTSetInitS)
  484.     (this, ev,s);
  485. }
  486.  
  487.  
  488. /* method: somfAssign */
  489. void   somfAssign(Environment *ev, 
  490.         somf_TSet* source)
  491. {
  492. /*
  493.  *  Assign the instance of this equal to the instance of source.
  494.  */
  495.    SOM_ResolveD(this,somf_TSet,somf_TSet,somfAssign)
  496.     (this, ev,source);
  497. }
  498.  
  499.  
  500. /* method: somfDifferenceS */
  501. void   somfDifferenceS(Environment *ev, 
  502.         somf_TSet* set1)
  503. {
  504. /*
  505.  *  Destructively modify this to contain a set of elements of this that do not
  506.  *  appear in set1
  507.  */
  508.    SOM_ResolveD(this,somf_TSet,somf_TSet,somfDifferenceS)
  509.     (this, ev,set1);
  510. }
  511.  
  512.  
  513. /* method: somfDifferenceSS */
  514. void   somfDifferenceSS(Environment *ev, 
  515.         somf_TSet* set1, 
  516.         somf_TSet* resultSet)
  517. {
  518. /*
  519.  *  After this function is called, resultSet will contain a set of elements of
  520.  *  this that do not appear in set1
  521.  */
  522.    SOM_ResolveD(this,somf_TSet,somf_TSet,somfDifferenceSS)
  523.     (this, ev,set1,resultSet);
  524. }
  525.  
  526.  
  527. /* method: somfIntersectionS */
  528. void   somfIntersectionS(Environment *ev, 
  529.         somf_TSet* set1)
  530. {
  531. /*
  532.  *  Destructively modify this to contain everything that is an element of set1
  533.  *  and this.
  534.  */
  535.    SOM_ResolveD(this,somf_TSet,somf_TSet,somfIntersectionS)
  536.     (this, ev,set1);
  537. }
  538.  
  539.  
  540. /* method: somfIntersectionSS */
  541. void   somfIntersectionSS(Environment *ev, 
  542.         somf_TSet* set1, 
  543.         somf_TSet* resultSet)
  544. {
  545. /*
  546.  *  After this function is called, resultSet will contain everything that is an
  547.  *  element of set1 and this.
  548.  */
  549.    SOM_ResolveD(this,somf_TSet,somf_TSet,somfIntersectionSS)
  550.     (this, ev,set1,resultSet);
  551. }
  552.  
  553.  
  554. /* method: somfUnionS */
  555. void   somfUnionS(Environment *ev, 
  556.         somf_TSet* set1)
  557. {
  558. /*
  559.  *  Destructively modify this to contain everything that is an element of either
  560.  *  set1 or this.
  561.  */
  562.    SOM_ResolveD(this,somf_TSet,somf_TSet,somfUnionS)
  563.     (this, ev,set1);
  564. }
  565.  
  566.  
  567. /* method: somfUnionSS */
  568. void   somfUnionSS(Environment *ev, 
  569.         somf_TSet* set1, 
  570.         somf_TSet* resultSet)
  571. {
  572. /*
  573.  *  After this function is called, resultSet will contain everything that is an
  574.  *  element of either set1 or this.
  575.  */
  576.    SOM_ResolveD(this,somf_TSet,somf_TSet,somfUnionSS)
  577.     (this, ev,set1,resultSet);
  578. }
  579.  
  580.  
  581. /* method: somfXorS */
  582. void   somfXorS(Environment *ev, 
  583.         somf_TSet* set1)
  584. {
  585. /*
  586.  *  Destructively modify this to contain everything that is an element of either
  587.  *  set1 or this, but not both.
  588.  */
  589.    SOM_ResolveD(this,somf_TSet,somf_TSet,somfXorS)
  590.     (this, ev,set1);
  591. }
  592.  
  593.  
  594. /* method: somfXorSS */
  595. void   somfXorSS(Environment *ev, 
  596.         somf_TSet* set1, 
  597.         somf_TSet* resultSet)
  598. {
  599. /*
  600.  *  After this function is called, resultSet will contain everything that is an
  601.  *  element of either set1 or this, but not both.
  602.  */
  603.    SOM_ResolveD(this,somf_TSet,somf_TSet,somfXorSS)
  604.     (this, ev,set1,resultSet);
  605. }
  606.  
  607.  
  608. /* method: somfSetHashFunction */
  609. void   somfSetHashFunction(Environment *ev, 
  610.         somf_MCollectible_somf_MCollectibleHashFn fn)
  611. {
  612. /*
  613.  *  Set the hash function to fn.
  614.  */
  615.    SOM_ResolveD(this,somf_TSet,somf_TSet,somfSetHashFunction)
  616.     (this, ev,fn);
  617. }
  618.  
  619.  
  620. /* method: somfGetHashFunction */
  621. somf_MCollectible_somf_MCollectibleHashFn   somfGetHashFunction(Environment *ev)
  622. {
  623. /*
  624.  *  Return the hash function.
  625.  */
  626.    return SOM_ResolveD(this,somf_TSet,somf_TSet,somfGetHashFunction)
  627.     (this, ev);
  628. }
  629.  
  630.  
  631. /* method: somfRehash */
  632. void   somfRehash(Environment *ev)
  633. {
  634. /*
  635.  *  Rehash the set, cleaning up for any entries marked for deletion.
  636.  */
  637.    SOM_ResolveD(this,somf_TSet,somf_TSet,somfRehash)
  638.     (this, ev);
  639. }
  640.  
  641.  
  642. /*
  643.  * Reintroduce inherited methods
  644.  */
  645.  
  646. /* method: somfAdd */
  647. somf_MCollectible*   somfAdd(Environment *ev, 
  648.         somf_MCollectible* obj)
  649. {
  650. /*
  651.  *  Add obj to this.
  652.  */
  653.    return SOM_ResolveD(this,somf_TSet,somf_TCollection,somfAdd)
  654.     (this, ev,obj);
  655. }
  656.  
  657.  
  658. /* method: somfAddAll */
  659. void   somfAddAll(Environment *ev, 
  660.         somf_TCollection* col)
  661. {
  662. /*
  663.  *  Add all of the objects in collection to this.  Essentially this is
  664.  *  equivalent to getting an iterator for the collection passed in and adding
  665.  *  each element in the collection to this.
  666.  */
  667.    SOM_ResolveD(this,somf_TSet,somf_TCollection,somfAddAll)
  668.     (this, ev,col);
  669. }
  670.  
  671.  
  672. /* method: somfRemove */
  673. somf_MCollectible*   somfRemove(Environment *ev, 
  674.         somf_MCollectible* obj)
  675. {
  676. /*
  677.  *  Remove obj from this.  Return the object which was actually removed
  678.  *  (which if you are using an IsEqual test function may not be the same as the
  679.  *  object passed in only "equal")
  680.  */
  681.    return SOM_ResolveD(this,somf_TSet,somf_TCollection,somfRemove)
  682.     (this, ev,obj);
  683. }
  684.  
  685.  
  686. /* method: somfRemoveAll */
  687. void   somfRemoveAll(Environment *ev)
  688. {
  689. /*
  690.  *  Remove all of the objects from this.
  691.  */
  692.    SOM_ResolveD(this,somf_TSet,somf_TCollection,somfRemoveAll)
  693.     (this, ev);
  694. }
  695.  
  696.  
  697. /* method: somfDeleteAll */
  698. void   somfDeleteAll(Environment *ev)
  699. {
  700. /*
  701.  *  Remove all of the objects from this and deallocate the storage that these
  702.  *  objects might have owned (that is, the destructor function is called
  703.  *  for each object in the collection).
  704.  */
  705.    SOM_ResolveD(this,somf_TSet,somf_TCollection,somfDeleteAll)
  706.     (this, ev);
  707. }
  708.  
  709.  
  710. /* method: somfCount */
  711. long   somfCount(Environment *ev)
  712. {
  713. /*
  714.  *  Return the number of objects in this.
  715.  */
  716.    return SOM_ResolveD(this,somf_TSet,somf_TCollection,somfCount)
  717.     (this, ev);
  718. }
  719.  
  720.  
  721. /* method: somfMember */
  722. somf_MCollectible*   somfMember(Environment *ev, 
  723.         somf_MCollectible* obj)
  724. {
  725. /*
  726.  *  Each object in this is compared to obj using the function testFn.  Return the
  727.  *  object for which testFn returned TRUE.  Return SOMF_NIL if not object was found.
  728.  */
  729.    return SOM_ResolveD(this,somf_TSet,somf_TCollection,somfMember)
  730.     (this, ev,obj);
  731. }
  732.  
  733.  
  734. /* method: somfCreateIterator */
  735. somf_TIterator*   somfCreateIterator(Environment *ev)
  736. {
  737. /*
  738.  *  This method returns a new iterator which is suitable for use in iterating
  739.  *  over the objects in this collection.
  740.  */
  741.    return SOM_ResolveD(this,somf_TSet,somf_TCollection,somfCreateIterator)
  742.     (this, ev);
  743. }
  744.  
  745.  
  746. /* method: somfTestFunction */
  747. somf_MCollectible_somf_MCollectibleCompareFn   somfTestFunction(Environment *ev)
  748. {
  749. /*
  750.  *  Return the test function.  This is usually either IsSame or IsEqual.
  751.  */
  752.    return SOM_ResolveD(this,somf_TSet,somf_TCollection,somfTestFunction)
  753.     (this, ev);
  754. }
  755.  
  756.  
  757. /* method: somfSetTestFunction */
  758. void   somfSetTestFunction(Environment *ev, 
  759.         somf_MCollectible_somf_MCollectibleCompareFn testfn)
  760. {
  761. /*
  762.  *  Set the test function.
  763.  */
  764.    SOM_ResolveD(this,somf_TSet,somf_TCollection,somfSetTestFunction)
  765.     (this, ev,testfn);
  766. }
  767.  
  768.  
  769. /* method: somfTCollectionInit */
  770. somf_TCollection*   somfTCollectionInit(Environment *ev, 
  771.         somf_MCollectible_somf_MCollectibleCompareFn testfn)
  772. {
  773. /*
  774.  *  Initialize the somf_TCollection test function to testfn.
  775.  */
  776.    return SOM_ResolveD(this,somf_TSet,somf_TCollection,somfTCollectionInit)
  777.     (this, ev,testfn);
  778. }
  779.  
  780.  
  781. /* method: somfIsEqual */
  782. boolean   somfIsEqual(Environment *ev, 
  783.         somf_MCollectible* obj)
  784. {
  785.    return SOM_ResolveD(this,somf_TSet,somf_MCollectible,somfIsEqual)
  786.     (this, ev,obj);
  787. }
  788.  
  789.  
  790. /* method: somfClone */
  791. somf_MCollectible*   somfClone(Environment *ev)
  792. {
  793. /*
  794.  *  somfClone provides a general function for creating a new instance of this.
  795.  */
  796.    return SOM_ResolveD(this,somf_TSet,somf_MCollectible,somfClone)
  797.     (this, ev);
  798. }
  799.  
  800.  
  801. /* method: somfClonePointer */
  802. somf_MCollectible*   somfClonePointer(Environment *ev, 
  803.         somf_MCollectible* clonee)
  804. {
  805. /*
  806.  *  somfClonePointer returns a pointer to a Clone
  807.  */
  808.    return SOM_ResolveD(this,somf_TSet,somf_MCollectible,somfClonePointer)
  809.     (this, ev,clonee);
  810. }
  811.  
  812.  
  813. /* method: somfHash */
  814. long   somfHash(Environment *ev)
  815. {
  816. /*
  817.  *  somfHash returns a value suitable for use as a hashing probe for this.
  818.  *  The default function will simply return the address of the object.
  819.  *  The default function is almost certainly not adequate if you are overriding
  820.  *  somfIsEqual because you need to make sure that all objects that "are equal"
  821.  *  to each other return the same hash value.  For example, a TText object would
  822.  *  return a hash value computed using the characters in the string instead of
  823.  *  the address of the string.
  824.  */
  825.    return SOM_ResolveD(this,somf_TSet,somf_MCollectible,somfHash)
  826.     (this, ev);
  827. }
  828.  
  829.  
  830. /* method: somfIsSame */
  831. boolean   somfIsSame(Environment *ev, 
  832.         somf_MCollectible* obj)
  833. {
  834. /*
  835.  *  The default function for somfIsSame is a pointer comparison
  836.  */
  837.    return SOM_ResolveD(this,somf_TSet,somf_MCollectible,somfIsSame)
  838.     (this, ev,obj);
  839. }
  840.  
  841.  
  842. /* method: somfIsNotEqual */
  843. boolean   somfIsNotEqual(Environment *ev, 
  844.         somf_MCollectible* obj)
  845. {
  846. /*
  847.  *  somfIsNotEqual returns TRUE if obj is NOT isomorphic to this.  It uses
  848.  *  somfIsEqual, so overriding somfIsEqual will handle the logic of somfIsNotEqual too.
  849.  */
  850.    return SOM_ResolveD(this,somf_TSet,somf_MCollectible,somfIsNotEqual)
  851.     (this, ev,obj);
  852. }
  853.  
  854.  
  855. /* initializer method: somDefaultInit */
  856. void   somDefaultInit(som3InitCtrl* ctrl)
  857. {
  858. /*
  859.  *  A default initializer for a SOM object. Passing a null ctrl
  860.  *  indicates to the receiver that its class is the class of the
  861.  *  object being initialized, whereby the initializer will determine
  862.  *  an appropriate control structure.
  863.  */
  864.    SOM_ResolveD(this,somf_TSet,SOMObject,somDefaultInit)
  865.     (this,ctrl);
  866. }
  867.  
  868.  
  869. /* method: somDestruct */
  870. void   somDestruct(octet doFree, 
  871.         som3DestructCtrl* ctrl)
  872. {
  873. /*
  874.  *  The default destructor for a SOM object. A nonzero <doFree>
  875.  *  indicates that the object storage should be freed by the
  876.  *  object's class (via somDeallocate) after uninitialization.
  877.  *  As with somDefaultInit, a null ctrl can be passed.
  878.  */
  879.    SOM_ResolveD(this,somf_TSet,SOMObject,somDestruct)
  880.     (this,doFree,ctrl);
  881. }
  882.  
  883.  
  884. /* initializer method: somDefaultCopyInit */
  885. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  886.         SOMObject* fromObj)
  887. {
  888. /*
  889.  *  A default copy constructor. Use this to make copies of objects for
  890.  *  calling methods with "by-value" argument semantics.
  891.  */
  892.    SOM_ResolveD(this,somf_TSet,SOMObject,somDefaultCopyInit)
  893.     (this,ctrl,fromObj);
  894. }
  895.  
  896.  
  897. /* method: somDefaultAssign */
  898. somf_TSet*  somDefaultAssign(som3AssignCtrl* ctrl, 
  899.         SOMObject* fromObj)
  900. {
  901. /*
  902.  *  A default assignment operator. Use this to "assign" the state of one
  903.  *  object to another.
  904.  */
  905.    return SOM_ResolveD(this,somf_TSet,SOMObject,somDefaultAssign)
  906.     (this,ctrl,fromObj);
  907. }
  908.  
  909.  
  910. /* initializer method: somDefaultConstCopyInit */
  911. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  912.         SOMObject* fromObj)
  913. {
  914. /*
  915.  *  A default copy constructor that uses a const fromObj.
  916.  */
  917.    SOM_ResolveD(this,somf_TSet,SOMObject,somDefaultConstCopyInit)
  918.     (this,ctrl,fromObj);
  919. }
  920.  
  921.  
  922. /* initializer method: somDefaultVCopyInit */
  923. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  924.         SOMObject* fromObj)
  925. {
  926. /*
  927.  *  A default copy constructor that uses a volatile fromObj.
  928.  */
  929.    SOM_ResolveD(this,somf_TSet,SOMObject,somDefaultVCopyInit)
  930.     (this,ctrl,fromObj);
  931. }
  932.  
  933.  
  934. /* initializer method: somDefaultConstVCopyInit */
  935. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  936.         SOMObject* fromObj)
  937. {
  938. /*
  939.  *  A default copy constructor that uses a const volatile fromObj.
  940.  */
  941.    SOM_ResolveD(this,somf_TSet,SOMObject,somDefaultConstVCopyInit)
  942.     (this,ctrl,fromObj);
  943. }
  944.  
  945.  
  946. /* method: somDefaultConstAssign */
  947. somf_TSet*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  948.         SOMObject* fromObj)
  949. {
  950. /*
  951.  *  A default assignment operator that uses a const fromObj.
  952.  */
  953.    return SOM_ResolveD(this,somf_TSet,SOMObject,somDefaultConstAssign)
  954.     (this,ctrl,fromObj);
  955. }
  956.  
  957.  
  958. /* method: somDefaultVAssign */
  959. somf_TSet*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  960.         SOMObject* fromObj)
  961. {
  962. /*
  963.  *  A default assignment operator that uses a volatile fromObj.
  964.  */
  965.    return SOM_ResolveD(this,somf_TSet,SOMObject,somDefaultVAssign)
  966.     (this,ctrl,fromObj);
  967. }
  968.  
  969.  
  970. /* method: somDefaultConstVAssign */
  971. somf_TSet*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  972.         SOMObject* fromObj)
  973. {
  974. /*
  975.  *  A default assignment operator that uses a const volatile fromObj.
  976.  */
  977.    return SOM_ResolveD(this,somf_TSet,SOMObject,somDefaultConstVAssign)
  978.     (this,ctrl,fromObj);
  979. }
  980.  
  981.  
  982. /* method: somInit */
  983. void   somInit()
  984. {
  985. /*
  986.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  987.  */
  988.    SOM_ResolveD(this,somf_TSet,SOMObject,somInit)
  989.     (this);
  990. }
  991.  
  992.  
  993. /* method: somFree */
  994. void   somFree()
  995. {
  996. /*
  997.  *  Use as directed by framework implementations.
  998.  */
  999.    SOM_ResolveD(this,somf_TSet,SOMObject,somFree)
  1000.     (this);
  1001. }
  1002.  
  1003.  
  1004. /* method: somUninit */
  1005. void   somUninit()
  1006. {
  1007. /*
  1008.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  1009.  */
  1010.    SOM_ResolveD(this,somf_TSet,SOMObject,somUninit)
  1011.     (this);
  1012. }
  1013.  
  1014.  
  1015. /* method: somGetClass */
  1016. SOMClass*   somGetClass()
  1017. {
  1018. /*
  1019.  *  Return the receiver's class.
  1020.  */
  1021.    return SOM_ResolveD(this,somf_TSet,SOMObject,somGetClass)
  1022.     (this);
  1023. }
  1024.  
  1025.  
  1026. /* method: somGetClassName */
  1027. string   somGetClassName()
  1028. {
  1029. /*
  1030.  *  Return the name of the receiver's class.
  1031.  */
  1032.    return SOM_ResolveD(this,somf_TSet,SOMObject,somGetClassName)
  1033.     (this);
  1034. }
  1035.  
  1036.  
  1037. /* method: somGetSize */
  1038. long   somGetSize()
  1039. {
  1040. /*
  1041.  *  Return the size of the receiver.
  1042.  */
  1043.    return SOM_ResolveD(this,somf_TSet,SOMObject,somGetSize)
  1044.     (this);
  1045. }
  1046.  
  1047.  
  1048. /* method: somIsA */
  1049. boolean   somIsA(SOMClass* aClassObj)
  1050. {
  1051. /*
  1052.  *  Returns 1 (true) if the receiver responds to methods
  1053.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  1054.  */
  1055.    return SOM_ResolveD(this,somf_TSet,SOMObject,somIsA)
  1056.     (this,aClassObj);
  1057. }
  1058.  
  1059.  
  1060. /* method: somIsInstanceOf */
  1061. boolean   somIsInstanceOf(SOMClass* aClassObj)
  1062. {
  1063. /*
  1064.  *  Returns 1 (true) if the receiver is an instance of
  1065.  *  <aClassObj> and 0 (false) otherwise.
  1066.  */
  1067.    return SOM_ResolveD(this,somf_TSet,SOMObject,somIsInstanceOf)
  1068.     (this,aClassObj);
  1069. }
  1070.  
  1071.  
  1072. /* method: somRespondsTo */
  1073. boolean   somRespondsTo(somId mId)
  1074. {
  1075. /*
  1076.  *  Returns 1 (true) if the indicated method can be invoked
  1077.  *  on the receiver and 0 (false) otherwise.
  1078.  */
  1079.    return SOM_ResolveD(this,somf_TSet,SOMObject,somRespondsTo)
  1080.     (this,mId);
  1081. }
  1082.  
  1083.  
  1084. /* va_list method: somDispatch */
  1085.  
  1086. /*
  1087.  *  This method provides a generic, class-specific dispatch mechanism.
  1088.  *  It accepts as input <retValue> a pointer to the memory area to be
  1089.  *  loaded with the result of dispatching the method indicated by
  1090.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  1091.  *  on which the method is to be invoked as the first argument.
  1092.  */
  1093. /* the va_list invocation form */
  1094. boolean   somf_TSet_somDispatch(somToken* retValue, 
  1095.         somId methodId, 
  1096.         va_list ap)
  1097. {return SOM_ResolveD(this,somf_TSet,SOMObject,somDispatch)
  1098.     (this,retValue,methodId,ap);
  1099. }
  1100.  
  1101. /* the varargs invocation form */
  1102. boolean   somDispatch(somToken* retValue, 
  1103.         somId methodId, 
  1104.         ...)
  1105. {
  1106. /*
  1107.  *  This method provides a generic, class-specific dispatch mechanism.
  1108.  *  It accepts as input <retValue> a pointer to the memory area to be
  1109.  *  loaded with the result of dispatching the method indicated by
  1110.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  1111.  *  on which the method is to be invoked as the first argument.
  1112.  */
  1113.    va_list ap;
  1114.    va_start(ap, methodId);
  1115.    boolean __somResult = 
  1116.       SOM_ResolveD(this,somf_TSet,SOMObject,somDispatch)
  1117.     (this,retValue,methodId,ap);
  1118.    va_end(ap);
  1119.    return __somResult;
  1120. }
  1121.  
  1122.  
  1123. /* va_list method: somClassDispatch */
  1124.  
  1125. /*
  1126.  *  Like somDispatch, but method resolution for static methods is done
  1127.  *  according to the clsObj instance method table.
  1128.  */
  1129. /* the va_list invocation form */
  1130. boolean   somf_TSet_somClassDispatch(SOMClass* clsObj, 
  1131.         somToken* retValue, 
  1132.         somId methodId, 
  1133.         va_list ap)
  1134. {return SOM_ResolveD(this,somf_TSet,SOMObject,somClassDispatch)
  1135.     (this,clsObj,retValue,methodId,ap);
  1136. }
  1137.  
  1138. /* the varargs invocation form */
  1139. boolean   somClassDispatch(SOMClass* clsObj, 
  1140.         somToken* retValue, 
  1141.         somId methodId, 
  1142.         ...)
  1143. {
  1144. /*
  1145.  *  Like somDispatch, but method resolution for static methods is done
  1146.  *  according to the clsObj instance method table.
  1147.  */
  1148.    va_list ap;
  1149.    va_start(ap, methodId);
  1150.    boolean __somResult = 
  1151.       SOM_ResolveD(this,somf_TSet,SOMObject,somClassDispatch)
  1152.     (this,clsObj,retValue,methodId,ap);
  1153.    va_end(ap);
  1154.    return __somResult;
  1155. }
  1156.  
  1157.  
  1158. /* method: somCastObj */
  1159. boolean   somCastObj(SOMClass* cls)
  1160. {
  1161. /*
  1162.  *  cast the receiving object to cls (which must be an ancestor of the
  1163.  *  objects true class. Returns true on success.
  1164.  */
  1165.    return SOM_ResolveD(this,somf_TSet,SOMObject,somCastObj)
  1166.     (this,cls);
  1167. }
  1168.  
  1169.  
  1170. /* method: somResetObj */
  1171. boolean   somResetObj()
  1172. {
  1173. /*
  1174.  *  reset an object to its true class. Returns true always.
  1175.  */
  1176.    return SOM_ResolveD(this,somf_TSet,SOMObject,somResetObj)
  1177.     (this);
  1178. }
  1179.  
  1180.  
  1181. /* va_list method: somDispatchV */
  1182.  
  1183. /*
  1184.  *  Obsolete. Use somDispatch instead.
  1185.  */
  1186. /* the va_list invocation form */
  1187. void   somf_TSet_somDispatchV(somId methodId, 
  1188.         somId descriptor, 
  1189.         va_list ap)
  1190. {   SOM_ResolveD(this,somf_TSet,SOMObject,somDispatchV)
  1191.     (this,methodId,descriptor,ap);
  1192. }
  1193.  
  1194. /* the varargs invocation form */
  1195. void   somDispatchV(somId methodId, 
  1196.         somId descriptor, 
  1197.         ...)
  1198. {
  1199. /*
  1200.  *  Obsolete. Use somDispatch instead.
  1201.  */
  1202.    va_list ap;
  1203.    va_start(ap, descriptor);
  1204.    SOM_ResolveD(this,somf_TSet,SOMObject,somDispatchV)
  1205.     (this,methodId,descriptor,ap);
  1206.    va_end(ap);
  1207. }
  1208.  
  1209.  
  1210. /* va_list method: somDispatchL */
  1211.  
  1212. /*
  1213.  *  Obsolete. Use somDispatch instead.
  1214.  */
  1215. /* the va_list invocation form */
  1216. long   somf_TSet_somDispatchL(somId methodId, 
  1217.         somId descriptor, 
  1218.         va_list ap)
  1219. {return SOM_ResolveD(this,somf_TSet,SOMObject,somDispatchL)
  1220.     (this,methodId,descriptor,ap);
  1221. }
  1222.  
  1223. /* the varargs invocation form */
  1224. long   somDispatchL(somId methodId, 
  1225.         somId descriptor, 
  1226.         ...)
  1227. {
  1228. /*
  1229.  *  Obsolete. Use somDispatch instead.
  1230.  */
  1231.    va_list ap;
  1232.    va_start(ap, descriptor);
  1233.    long __somResult = 
  1234.       SOM_ResolveD(this,somf_TSet,SOMObject,somDispatchL)
  1235.     (this,methodId,descriptor,ap);
  1236.    va_end(ap);
  1237.    return __somResult;
  1238. }
  1239.  
  1240.  
  1241. /* va_list method: somDispatchA */
  1242.  
  1243. /*
  1244.  *  Obsolete. Use somDispatch instead.
  1245.  */
  1246. /* the va_list invocation form */
  1247. void*   somf_TSet_somDispatchA(somId methodId, 
  1248.         somId descriptor, 
  1249.         va_list ap)
  1250. {return SOM_ResolveD(this,somf_TSet,SOMObject,somDispatchA)
  1251.     (this,methodId,descriptor,ap);
  1252. }
  1253.  
  1254. /* the varargs invocation form */
  1255. void*   somDispatchA(somId methodId, 
  1256.         somId descriptor, 
  1257.         ...)
  1258. {
  1259. /*
  1260.  *  Obsolete. Use somDispatch instead.
  1261.  */
  1262.    va_list ap;
  1263.    va_start(ap, descriptor);
  1264.    void* __somResult = 
  1265.       SOM_ResolveD(this,somf_TSet,SOMObject,somDispatchA)
  1266.     (this,methodId,descriptor,ap);
  1267.    va_end(ap);
  1268.    return __somResult;
  1269. }
  1270.  
  1271.  
  1272. /* va_list method: somDispatchD */
  1273.  
  1274. /*
  1275.  *  Obsolete. Use somDispatch instead.
  1276.  */
  1277. /* the va_list invocation form */
  1278. double   somf_TSet_somDispatchD(somId methodId, 
  1279.         somId descriptor, 
  1280.         va_list ap)
  1281. {return SOM_ResolveD(this,somf_TSet,SOMObject,somDispatchD)
  1282.     (this,methodId,descriptor,ap);
  1283. }
  1284.  
  1285. /* the varargs invocation form */
  1286. double   somDispatchD(somId methodId, 
  1287.         somId descriptor, 
  1288.         ...)
  1289. {
  1290. /*
  1291.  *  Obsolete. Use somDispatch instead.
  1292.  */
  1293.    va_list ap;
  1294.    va_start(ap, descriptor);
  1295.    double __somResult = 
  1296.       SOM_ResolveD(this,somf_TSet,SOMObject,somDispatchD)
  1297.     (this,methodId,descriptor,ap);
  1298.    va_end(ap);
  1299.    return __somResult;
  1300. }
  1301.  
  1302.  
  1303. /* method: somPrintSelf */
  1304. SOMObject*   somPrintSelf()
  1305. {
  1306. /*
  1307.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  1308.  *  information about this object.  The default implementation just gives
  1309.  *  the object's class name and its address in memory.
  1310.  *  <self> is returned.
  1311.  */
  1312.    return SOM_ResolveD(this,somf_TSet,SOMObject,somPrintSelf)
  1313.     (this);
  1314. }
  1315.  
  1316.  
  1317. /* method: somDumpSelf */
  1318. void   somDumpSelf(long level)
  1319. {
  1320. /*
  1321.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  1322.  *  and its current state.
  1323.  * 
  1324.  *  <level> indicates the nesting level for describing compound objects
  1325.  *  it must be greater than or equal to zero.  All lines in the
  1326.  *  description will be preceeded by <2*level> spaces.
  1327.  * 
  1328.  *  This routine only actually writes the data that concerns the object
  1329.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  1330.  *  the object's current state.  This approach allows readable
  1331.  *  descriptions of compound objects to be constructed.
  1332.  * 
  1333.  *  Generally it is not necessary to override this method, if it is
  1334.  *  overriden it generally must be completely replaced.
  1335.  */
  1336.    SOM_ResolveD(this,somf_TSet,SOMObject,somDumpSelf)
  1337.     (this,level);
  1338. }
  1339.  
  1340.  
  1341. /* method: somDumpSelfInt */
  1342. void   somDumpSelfInt(long level)
  1343. {
  1344. /*
  1345.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  1346.  *  Generally this method will need to be overridden.  When overriding
  1347.  *  it, begin by calling the parent class form of this method and then
  1348.  *  write in a description of your class's instance data. This will
  1349.  *  result in a description of all the object's instance data going
  1350.  *  from its root ancestor class to its specific class.
  1351.  */
  1352.    SOM_ResolveD(this,somf_TSet,SOMObject,somDumpSelfInt)
  1353.     (this,level);
  1354. }
  1355.  
  1356.  
  1357.  
  1358. };   /* somf_TSet */
  1359.  
  1360.  
  1361.  
  1362. #endif       /* SOM_somf_TSet_xh */
  1363.