home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / morder.xh < prev    next >
Text File  |  1999-02-22  |  36KB  |  1,032 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: morder.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.17
  7.  *     SOM Emitter emitxh: 2.47
  8.  */
  9.  
  10. /*
  11.  *    COMPONENT_NAME: somuc
  12.  * 
  13.  *    ORIGINS: 82, 81, 27
  14.  * 
  15.  * 
  16.  *     25H7912  (C)  COPYRIGHT International Business Machines Corp. 1992,1996,1996
  17.  *    All Rights Reserved
  18.  *    Licensed Materials - Property of IBM
  19.  *    US Government Users Restricted Rights - Use, duplication or
  20.  *    disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  21.  * 
  22.  *    Copyright ⌐ 1988-92 Apple Computer, Inc.  All rights reserved.
  23.  * 
  24.  * CLASS_NAME: somf_MOrderableCollectible
  25.  * 
  26.  * DESCRIPTION: MOrderableCollectible should be mixed into objects which
  27.  *              might want to be ordered.
  28.  * 
  29.  */
  30.  
  31.  
  32. #ifndef SOM_somf_MOrderableCollectible_xh
  33. #define SOM_somf_MOrderableCollectible_xh
  34.  
  35. class somf_MOrderableCollectible;
  36.  
  37. #define somf_MOrderableCollectible_MajorVersion 2
  38. #define somf_MOrderableCollectible_MinorVersion 1
  39.  
  40. /* C++ SOM defs */
  41. #include <somcls.xh>
  42. #include <somcm.xh>
  43.  
  44. /* C++ parent defs */
  45. #ifndef SOM_somf_MCollectible_xh
  46. #include <mcollect.xh>
  47. #endif
  48.  
  49. #ifndef somf_MOrderableCollectible_API
  50. #define somf_MOrderableCollectible_API
  51. /*
  52.  * -- The Class API
  53.  */
  54.  
  55. /*
  56.  * Start of bindings for IDL types
  57.  */
  58.  
  59. class SOMClass;
  60. class SOMObject;
  61. typedef unsigned long somf_MOrderableCollectible_EComparisonResult;
  62. #define somf_MOrderableCollectible_kLessThan 1UL
  63. #define somf_MOrderableCollectible_kEqual 2UL
  64. #define somf_MOrderableCollectible_kGreaterThan 3UL
  65. typedef
  66. somMToken somf_MOrderableCollectible_somf_MOrderableCompareFn;
  67. typedef
  68. somMToken somf_MOrderableCollectible_somf_MBetterOrderableCompareFn;
  69. typedef
  70. somf_MOrderableCollectible** somf_MOrderableCollectible_somf_MOrderableCollectiblePtr;
  71.  
  72. #ifndef SOM_DONT_USE_SHORT_NAMES
  73. #ifndef SOMTGD_EComparisonResult
  74.     #ifdef EComparisonResult
  75.         #undef EComparisonResult
  76.         #define SOMTGD_EComparisonResult 1
  77.     #else
  78.         #define EComparisonResult somf_MOrderableCollectible_EComparisonResult
  79.     #endif /* EComparisonResult */
  80. #endif /* SOMTGD_EComparisonResult */
  81.  
  82. #ifndef SOM_DONT_USE_SHORT_NAMES
  83. #ifndef SOMTGD_somf_MOrderableCompareFn
  84.     #ifdef somf_MOrderableCompareFn
  85.         #undef somf_MOrderableCompareFn
  86.         #define SOMTGD_somf_MOrderableCompareFn 1
  87.     #else
  88.         #define somf_MOrderableCompareFn somf_MOrderableCollectible_somf_MOrderableCompareFn
  89.     #endif /* somf_MOrderableCompareFn */
  90. #endif /* SOMTGD_somf_MOrderableCompareFn */
  91. #endif /* SOM_DONT_USE_SHORT_NAMES */
  92.  
  93. #ifndef SOM_DONT_USE_SHORT_NAMES
  94. #ifndef SOMTGD_somf_MBetterOrderableCompareFn
  95.     #ifdef somf_MBetterOrderableCompareFn
  96.         #undef somf_MBetterOrderableCompareFn
  97.         #define SOMTGD_somf_MBetterOrderableCompareFn 1
  98.     #else
  99.         #define somf_MBetterOrderableCompareFn somf_MOrderableCollectible_somf_MBetterOrderableCompareFn
  100.     #endif /* somf_MBetterOrderableCompareFn */
  101. #endif /* SOMTGD_somf_MBetterOrderableCompareFn */
  102. #endif /* SOM_DONT_USE_SHORT_NAMES */
  103.  
  104. #ifndef SOM_DONT_USE_SHORT_NAMES
  105. #ifndef SOMTGD_somf_MOrderableCollectiblePtr
  106.     #ifdef somf_MOrderableCollectiblePtr
  107.         #undef somf_MOrderableCollectiblePtr
  108.         #define SOMTGD_somf_MOrderableCollectiblePtr 1
  109.     #else
  110.         #define somf_MOrderableCollectiblePtr somf_MOrderableCollectible_somf_MOrderableCollectiblePtr
  111.     #endif /* somf_MOrderableCollectiblePtr */
  112. #endif /* SOMTGD_somf_MOrderableCollectiblePtr */
  113. #endif /* SOM_DONT_USE_SHORT_NAMES */
  114. #endif /* SOM_DONT_USE_SHORT_NAMES */
  115.  
  116. /*
  117.  * End of bindings for IDL types.
  118.  */
  119.  
  120. /*
  121.  * Passthru lines: File: "C.xh", "after"
  122.  */
  123.  
  124.  
  125. #define SOMF_CALL_ORDERABLE_COMPARE_FN(obj,token,parameter) (((somTD_somf_MOrderableCollectible_somfIsLessThan) somResolve(obj,token))(obj, ev, parameter))
  126.  
  127. #define SOMF_CALL_BETTER_ORDERABLE_COMPARE_FN(obj,token,parameter) (((somTD_somf_MOrderableCollectible_somfCompare) somResolve(obj,token))(obj, ev, parameter))
  128.  
  129.  
  130. /* A procedure to create the somf_MOrderableCollectible Class */
  131. SOMEXTERN SOMClass * SOMLINK somf_MOrderableCollectibleNewClass(
  132.         integer4 majorVersion,
  133.         integer4 minorVersion);
  134.  
  135. /* The API to the somf_MOrderableCollectible class object, and the methods it introduces. */
  136. SOMEXTERN struct somf_MOrderableCollectibleClassDataStructure {
  137.     SOMClass *classObject;
  138.     somMToken somfClone;
  139.     somMToken somfClonePointer;
  140.     somMToken somfHash;
  141.     somMToken somfIsEqual;
  142.     somMToken somfIsSame;
  143.     somMToken somfIsNotEqual;
  144.     somMToken somfIsGreaterThan;
  145.     somMToken somfIsLessThan;
  146.     somMToken somfCompare;
  147.     somMToken somfIsGreaterThanOrEqualTo;
  148.     somMToken somfIsLessThanOrEqualTo;
  149. } SOMDLINK somf_MOrderableCollectibleClassData;
  150. #define _somf_MOrderableCollectible somf_MOrderableCollectibleClassData.classObject
  151.  
  152. /* The API to parentMtabs for somf_MOrderableCollectible, and the instance data it introduces. */
  153. SOMEXTERN struct somf_MOrderableCollectibleCClassDataStructure {
  154.     somMethodTabs parentMtab;
  155.     somDToken              instanceDataToken;
  156. } SOMDLINK somf_MOrderableCollectibleCClassData;
  157.  
  158. /*
  159.  * -- Typedefs for somf_MOrderableCollectible Method Procedures
  160.  */
  161. SOMEXTERN {
  162. typedef boolean   SOMLINK somTP_somf_MOrderableCollectible_somfIsGreaterThan(somf_MOrderableCollectible *somSelf, Environment *ev, 
  163.         somf_MOrderableCollectible* obj);
  164. typedef somTP_somf_MOrderableCollectible_somfIsGreaterThan *somTD_somf_MOrderableCollectible_somfIsGreaterThan;
  165. typedef boolean   SOMLINK somTP_somf_MOrderableCollectible_somfIsLessThan(somf_MOrderableCollectible *somSelf, Environment *ev, 
  166.         somf_MOrderableCollectible* obj);
  167. typedef somTP_somf_MOrderableCollectible_somfIsLessThan *somTD_somf_MOrderableCollectible_somfIsLessThan;
  168. typedef somf_MOrderableCollectible_EComparisonResult   SOMLINK somTP_somf_MOrderableCollectible_somfCompare(somf_MOrderableCollectible *somSelf, Environment *ev, 
  169.         somf_MOrderableCollectible* obj);
  170. typedef somTP_somf_MOrderableCollectible_somfCompare *somTD_somf_MOrderableCollectible_somfCompare;
  171. typedef boolean   SOMLINK somTP_somf_MOrderableCollectible_somfIsGreaterThanOrEqualTo(somf_MOrderableCollectible *somSelf, Environment *ev, 
  172.         somf_MOrderableCollectible* obj);
  173. typedef somTP_somf_MOrderableCollectible_somfIsGreaterThanOrEqualTo *somTD_somf_MOrderableCollectible_somfIsGreaterThanOrEqualTo;
  174. typedef boolean   SOMLINK somTP_somf_MOrderableCollectible_somfIsLessThanOrEqualTo(somf_MOrderableCollectible *somSelf, Environment *ev, 
  175.         somf_MOrderableCollectible* obj);
  176. typedef somTP_somf_MOrderableCollectible_somfIsLessThanOrEqualTo *somTD_somf_MOrderableCollectible_somfIsLessThanOrEqualTo;
  177.  
  178. /*
  179.  * -- Typedefs for Reintroduced Wrapper Methods
  180.  */
  181. typedef somf_MCollectible*   SOMLINK somTP_somf_MOrderableCollectible_somfClone(somf_MOrderableCollectible *somSelf, Environment *ev);
  182. typedef somTP_somf_MOrderableCollectible_somfClone *somTD_somf_MOrderableCollectible_somfClone;
  183. typedef somf_MCollectible*   SOMLINK somTP_somf_MOrderableCollectible_somfClonePointer(somf_MOrderableCollectible *somSelf, Environment *ev, 
  184.         somf_MCollectible* clonee);
  185. typedef somTP_somf_MOrderableCollectible_somfClonePointer *somTD_somf_MOrderableCollectible_somfClonePointer;
  186. typedef long   SOMLINK somTP_somf_MOrderableCollectible_somfHash(somf_MOrderableCollectible *somSelf, Environment *ev);
  187. typedef somTP_somf_MOrderableCollectible_somfHash *somTD_somf_MOrderableCollectible_somfHash;
  188. typedef boolean   SOMLINK somTP_somf_MOrderableCollectible_somfIsEqual(somf_MOrderableCollectible *somSelf, Environment *ev, 
  189.         somf_MCollectible* obj);
  190. typedef somTP_somf_MOrderableCollectible_somfIsEqual *somTD_somf_MOrderableCollectible_somfIsEqual;
  191. typedef boolean   SOMLINK somTP_somf_MOrderableCollectible_somfIsSame(somf_MOrderableCollectible *somSelf, Environment *ev, 
  192.         somf_MCollectible* obj);
  193. typedef somTP_somf_MOrderableCollectible_somfIsSame *somTD_somf_MOrderableCollectible_somfIsSame;
  194. typedef boolean   SOMLINK somTP_somf_MOrderableCollectible_somfIsNotEqual(somf_MOrderableCollectible *somSelf, Environment *ev, 
  195.         somf_MCollectible* obj);
  196. typedef somTP_somf_MOrderableCollectible_somfIsNotEqual *somTD_somf_MOrderableCollectible_somfIsNotEqual;
  197. typedef void   SOMLINK somTP_somf_MOrderableCollectible_somDefaultInit(somf_MOrderableCollectible *somSelf, 
  198.         som3InitCtrl* ctrl);
  199. typedef somTP_somf_MOrderableCollectible_somDefaultInit *somTD_somf_MOrderableCollectible_somDefaultInit;
  200. typedef void   SOMLINK somTP_somf_MOrderableCollectible_somDestruct(somf_MOrderableCollectible *somSelf, 
  201.         octet doFree, 
  202.         som3DestructCtrl* ctrl);
  203. typedef somTP_somf_MOrderableCollectible_somDestruct *somTD_somf_MOrderableCollectible_somDestruct;
  204. typedef void   SOMLINK somTP_somf_MOrderableCollectible_somDefaultCopyInit(somf_MOrderableCollectible *somSelf, 
  205.         som3InitCtrl* ctrl, 
  206.         SOMObject* fromObj);
  207. typedef somTP_somf_MOrderableCollectible_somDefaultCopyInit *somTD_somf_MOrderableCollectible_somDefaultCopyInit;
  208. typedef somf_MOrderableCollectible*   SOMLINK somTP_somf_MOrderableCollectible_somDefaultAssign(somf_MOrderableCollectible *somSelf, 
  209.         som3AssignCtrl* ctrl, 
  210.         SOMObject* fromObj);
  211. typedef somTP_somf_MOrderableCollectible_somDefaultAssign *somTD_somf_MOrderableCollectible_somDefaultAssign;
  212. typedef void   SOMLINK somTP_somf_MOrderableCollectible_somDefaultConstCopyInit(somf_MOrderableCollectible *somSelf, 
  213.         som3InitCtrl* ctrl, 
  214.         SOMObject* fromObj);
  215. typedef somTP_somf_MOrderableCollectible_somDefaultConstCopyInit *somTD_somf_MOrderableCollectible_somDefaultConstCopyInit;
  216. typedef void   SOMLINK somTP_somf_MOrderableCollectible_somDefaultVCopyInit(somf_MOrderableCollectible *somSelf, 
  217.         som3InitCtrl* ctrl, 
  218.         SOMObject* fromObj);
  219. typedef somTP_somf_MOrderableCollectible_somDefaultVCopyInit *somTD_somf_MOrderableCollectible_somDefaultVCopyInit;
  220. typedef void   SOMLINK somTP_somf_MOrderableCollectible_somDefaultConstVCopyInit(somf_MOrderableCollectible *somSelf, 
  221.         som3InitCtrl* ctrl, 
  222.         SOMObject* fromObj);
  223. typedef somTP_somf_MOrderableCollectible_somDefaultConstVCopyInit *somTD_somf_MOrderableCollectible_somDefaultConstVCopyInit;
  224. typedef somf_MOrderableCollectible*   SOMLINK somTP_somf_MOrderableCollectible_somDefaultConstAssign(somf_MOrderableCollectible *somSelf, 
  225.         som3AssignCtrl* ctrl, 
  226.         SOMObject* fromObj);
  227. typedef somTP_somf_MOrderableCollectible_somDefaultConstAssign *somTD_somf_MOrderableCollectible_somDefaultConstAssign;
  228. typedef somf_MOrderableCollectible*   SOMLINK somTP_somf_MOrderableCollectible_somDefaultVAssign(somf_MOrderableCollectible *somSelf, 
  229.         som3AssignCtrl* ctrl, 
  230.         SOMObject* fromObj);
  231. typedef somTP_somf_MOrderableCollectible_somDefaultVAssign *somTD_somf_MOrderableCollectible_somDefaultVAssign;
  232. typedef somf_MOrderableCollectible*   SOMLINK somTP_somf_MOrderableCollectible_somDefaultConstVAssign(somf_MOrderableCollectible *somSelf, 
  233.         som3AssignCtrl* ctrl, 
  234.         SOMObject* fromObj);
  235. typedef somTP_somf_MOrderableCollectible_somDefaultConstVAssign *somTD_somf_MOrderableCollectible_somDefaultConstVAssign;
  236. typedef void   SOMLINK somTP_somf_MOrderableCollectible_somInit(somf_MOrderableCollectible *somSelf);
  237. typedef somTP_somf_MOrderableCollectible_somInit *somTD_somf_MOrderableCollectible_somInit;
  238. typedef void   SOMLINK somTP_somf_MOrderableCollectible_somFree(somf_MOrderableCollectible *somSelf);
  239. typedef somTP_somf_MOrderableCollectible_somFree *somTD_somf_MOrderableCollectible_somFree;
  240. typedef void   SOMLINK somTP_somf_MOrderableCollectible_somUninit(somf_MOrderableCollectible *somSelf);
  241. typedef somTP_somf_MOrderableCollectible_somUninit *somTD_somf_MOrderableCollectible_somUninit;
  242. typedef SOMClass*   SOMLINK somTP_somf_MOrderableCollectible_somGetClass(somf_MOrderableCollectible *somSelf);
  243. typedef somTP_somf_MOrderableCollectible_somGetClass *somTD_somf_MOrderableCollectible_somGetClass;
  244. typedef string   SOMLINK somTP_somf_MOrderableCollectible_somGetClassName(somf_MOrderableCollectible *somSelf);
  245. typedef somTP_somf_MOrderableCollectible_somGetClassName *somTD_somf_MOrderableCollectible_somGetClassName;
  246. typedef long   SOMLINK somTP_somf_MOrderableCollectible_somGetSize(somf_MOrderableCollectible *somSelf);
  247. typedef somTP_somf_MOrderableCollectible_somGetSize *somTD_somf_MOrderableCollectible_somGetSize;
  248. typedef boolean   SOMLINK somTP_somf_MOrderableCollectible_somIsA(somf_MOrderableCollectible *somSelf, 
  249.         SOMClass* aClassObj);
  250. typedef somTP_somf_MOrderableCollectible_somIsA *somTD_somf_MOrderableCollectible_somIsA;
  251. typedef boolean   SOMLINK somTP_somf_MOrderableCollectible_somIsInstanceOf(somf_MOrderableCollectible *somSelf, 
  252.         SOMClass* aClassObj);
  253. typedef somTP_somf_MOrderableCollectible_somIsInstanceOf *somTD_somf_MOrderableCollectible_somIsInstanceOf;
  254. typedef boolean   SOMLINK somTP_somf_MOrderableCollectible_somRespondsTo(somf_MOrderableCollectible *somSelf, 
  255.         somId mId);
  256. typedef somTP_somf_MOrderableCollectible_somRespondsTo *somTD_somf_MOrderableCollectible_somRespondsTo;
  257. typedef boolean   SOMLINK somTP_somf_MOrderableCollectible_somDispatch(somf_MOrderableCollectible *somSelf, 
  258.         somToken* retValue, 
  259.         somId methodId, 
  260.         va_list ap);
  261. typedef somTP_somf_MOrderableCollectible_somDispatch *somTD_somf_MOrderableCollectible_somDispatch;
  262. typedef boolean   SOMLINK somTP_somf_MOrderableCollectible_somClassDispatch(somf_MOrderableCollectible *somSelf, 
  263.         SOMClass* clsObj, 
  264.         somToken* retValue, 
  265.         somId methodId, 
  266.         va_list ap);
  267. typedef somTP_somf_MOrderableCollectible_somClassDispatch *somTD_somf_MOrderableCollectible_somClassDispatch;
  268. typedef boolean   SOMLINK somTP_somf_MOrderableCollectible_somCastObj(somf_MOrderableCollectible *somSelf, 
  269.         SOMClass* cls);
  270. typedef somTP_somf_MOrderableCollectible_somCastObj *somTD_somf_MOrderableCollectible_somCastObj;
  271. typedef boolean   SOMLINK somTP_somf_MOrderableCollectible_somResetObj(somf_MOrderableCollectible *somSelf);
  272. typedef somTP_somf_MOrderableCollectible_somResetObj *somTD_somf_MOrderableCollectible_somResetObj;
  273. typedef void   SOMLINK somTP_somf_MOrderableCollectible_somDispatchV(somf_MOrderableCollectible *somSelf, 
  274.         somId methodId, 
  275.         somId descriptor, 
  276.         va_list ap);
  277. typedef somTP_somf_MOrderableCollectible_somDispatchV *somTD_somf_MOrderableCollectible_somDispatchV;
  278. typedef long   SOMLINK somTP_somf_MOrderableCollectible_somDispatchL(somf_MOrderableCollectible *somSelf, 
  279.         somId methodId, 
  280.         somId descriptor, 
  281.         va_list ap);
  282. typedef somTP_somf_MOrderableCollectible_somDispatchL *somTD_somf_MOrderableCollectible_somDispatchL;
  283. typedef void*   SOMLINK somTP_somf_MOrderableCollectible_somDispatchA(somf_MOrderableCollectible *somSelf, 
  284.         somId methodId, 
  285.         somId descriptor, 
  286.         va_list ap);
  287. typedef somTP_somf_MOrderableCollectible_somDispatchA *somTD_somf_MOrderableCollectible_somDispatchA;
  288. typedef double   SOMLINK somTP_somf_MOrderableCollectible_somDispatchD(somf_MOrderableCollectible *somSelf, 
  289.         somId methodId, 
  290.         somId descriptor, 
  291.         va_list ap);
  292. typedef somTP_somf_MOrderableCollectible_somDispatchD *somTD_somf_MOrderableCollectible_somDispatchD;
  293. typedef SOMObject*   SOMLINK somTP_somf_MOrderableCollectible_somPrintSelf(somf_MOrderableCollectible *somSelf);
  294. typedef somTP_somf_MOrderableCollectible_somPrintSelf *somTD_somf_MOrderableCollectible_somPrintSelf;
  295. typedef void   SOMLINK somTP_somf_MOrderableCollectible_somDumpSelf(somf_MOrderableCollectible *somSelf, 
  296.         long level);
  297. typedef somTP_somf_MOrderableCollectible_somDumpSelf *somTD_somf_MOrderableCollectible_somDumpSelf;
  298. typedef void   SOMLINK somTP_somf_MOrderableCollectible_somDumpSelfInt(somf_MOrderableCollectible *somSelf, 
  299.         long level);
  300. typedef somTP_somf_MOrderableCollectible_somDumpSelfInt *somTD_somf_MOrderableCollectible_somDumpSelfInt;
  301. }
  302.  
  303. #endif /* somf_MOrderableCollectible_API */
  304.  
  305.  
  306. /*
  307.  * -- This emitter treats Method Tokens as Thunks by default.
  308.  * -- Use the sc modifier "nothunks" to change this default
  309.  */
  310. #undef somresolve_
  311. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  312.  
  313. /*
  314.  * -- The C++ Wrapper Class for somf_MOrderableCollectible
  315.  */
  316. class somf_MOrderableCollectible : public somf_MCollectible
  317. {
  318. public:
  319.  
  320. // somf_MOrderableCollectible::new creates the class object if necessary, and then uses somNewNoInit
  321. // to allocate memory and create the object. Initialization is in ctors.
  322. void *operator new(size_t)
  323. {
  324.    if (!_somf_MOrderableCollectible) somf_MOrderableCollectibleNewClass(somf_MOrderableCollectible_MajorVersion,somf_MOrderableCollectible_MinorVersion);
  325.    return (void*)
  326.       SOM_Resolve(_somf_MOrderableCollectible,SOMClass,somNewNoInit)
  327.          ((SOMClass *)((void*)_somf_MOrderableCollectible));
  328. }
  329.  
  330. // somf_MOrderableCollectible::delete uses somDestruct.
  331. void operator delete(void * obj)
  332. {
  333.    if (obj && *(void**)obj) {
  334.       SOM_Resolve(obj,SOMObject,somFree)
  335.          ((SOMObject*)obj);
  336.    }
  337. }
  338.  
  339. somf_MOrderableCollectible& operator=(somf_MOrderableCollectible& fromObj)
  340. {
  341.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  342.    return *this;
  343. }
  344.  
  345. somf_MOrderableCollectible()
  346. {
  347.    if (*(void**)this != 
  348.        ((somParentMtabStructPtr)
  349.         (somf_MOrderableCollectibleCClassData.parentMtab))->mtab)
  350.       return;
  351.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  352. }
  353.  
  354. somf_MOrderableCollectible(somf_MOrderableCollectible* fromObj)
  355. {
  356.    if (*(void**)this != 
  357.        ((somParentMtabStructPtr)
  358.         (somf_MOrderableCollectibleCClassData.parentMtab))->mtab)
  359.       return;
  360.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  361. }
  362.  
  363. #ifdef __IBMCPP__
  364. #pragma info(nocnv,nopar)
  365. #endif
  366. somf_MOrderableCollectible(const somf_MOrderableCollectible* fromObj)
  367. {
  368.    if (*(void**)this != 
  369.        ((somParentMtabStructPtr)
  370.         (somf_MOrderableCollectibleCClassData.parentMtab))->mtab)
  371.       return;
  372.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  373. }
  374. #ifdef __IBMCPP__
  375. #pragma info(restore)
  376. #endif
  377.  
  378.  
  379. /* method: somfIsGreaterThan */
  380. boolean   somfIsGreaterThan(Environment *ev, 
  381.         somf_MOrderableCollectible* obj)
  382. {
  383. /*
  384.  *  Returns TRUE if obj is "greater than" this.
  385.  */
  386.    return SOM_ResolveD(this,somf_MOrderableCollectible,somf_MOrderableCollectible,somfIsGreaterThan)
  387.     (this, ev,obj);
  388. }
  389.  
  390.  
  391. /* method: somfIsLessThan */
  392. boolean   somfIsLessThan(Environment *ev, 
  393.         somf_MOrderableCollectible* obj)
  394. {
  395. /*
  396.  *  Returns TRUE if obj is "less than" this.
  397.  */
  398.    return SOM_ResolveD(this,somf_MOrderableCollectible,somf_MOrderableCollectible,somfIsLessThan)
  399.     (this, ev,obj);
  400. }
  401.  
  402.  
  403. /* method: somfCompare */
  404. somf_MOrderableCollectible_EComparisonResult   somfCompare(Environment *ev, 
  405.         somf_MOrderableCollectible* obj)
  406. {
  407. /*
  408.  *  This method compares obj to this.
  409.  */
  410.    return SOM_ResolveD(this,somf_MOrderableCollectible,somf_MOrderableCollectible,somfCompare)
  411.     (this, ev,obj);
  412. }
  413.  
  414.  
  415. /* method: somfIsGreaterThanOrEqualTo */
  416. boolean   somfIsGreaterThanOrEqualTo(Environment *ev, 
  417.         somf_MOrderableCollectible* obj)
  418. {
  419. /*
  420.  *  Returns TRUE if obj is "greater than" or "equal to" this.
  421.  */
  422.    return SOM_ResolveD(this,somf_MOrderableCollectible,somf_MOrderableCollectible,somfIsGreaterThanOrEqualTo)
  423.     (this, ev,obj);
  424. }
  425.  
  426.  
  427. /* method: somfIsLessThanOrEqualTo */
  428. boolean   somfIsLessThanOrEqualTo(Environment *ev, 
  429.         somf_MOrderableCollectible* obj)
  430. {
  431. /*
  432.  *  Returns TRUE if obj is "less than" or "equal to" this.
  433.  */
  434.    return SOM_ResolveD(this,somf_MOrderableCollectible,somf_MOrderableCollectible,somfIsLessThanOrEqualTo)
  435.     (this, ev,obj);
  436. }
  437.  
  438.  
  439. /*
  440.  * Reintroduce inherited methods
  441.  */
  442.  
  443. /* method: somfClone */
  444. somf_MCollectible*   somfClone(Environment *ev)
  445. {
  446. /*
  447.  *  somfClone provides a general function for creating a new instance of this.
  448.  */
  449.    return SOM_ResolveD(this,somf_MOrderableCollectible,somf_MCollectible,somfClone)
  450.     (this, ev);
  451. }
  452.  
  453.  
  454. /* method: somfClonePointer */
  455. somf_MCollectible*   somfClonePointer(Environment *ev, 
  456.         somf_MCollectible* clonee)
  457. {
  458. /*
  459.  *  somfClonePointer returns a pointer to a Clone
  460.  */
  461.    return SOM_ResolveD(this,somf_MOrderableCollectible,somf_MCollectible,somfClonePointer)
  462.     (this, ev,clonee);
  463. }
  464.  
  465.  
  466. /* method: somfHash */
  467. long   somfHash(Environment *ev)
  468. {
  469. /*
  470.  *  somfHash returns a value suitable for use as a hashing probe for this.
  471.  *  The default function will simply return the address of the object.
  472.  *  The default function is almost certainly not adequate if you are overriding
  473.  *  somfIsEqual because you need to make sure that all objects that "are equal"
  474.  *  to each other return the same hash value.  For example, a TText object would
  475.  *  return a hash value computed using the characters in the string instead of
  476.  *  the address of the string.
  477.  */
  478.    return SOM_ResolveD(this,somf_MOrderableCollectible,somf_MCollectible,somfHash)
  479.     (this, ev);
  480. }
  481.  
  482.  
  483. /* method: somfIsEqual */
  484. boolean   somfIsEqual(Environment *ev, 
  485.         somf_MCollectible* obj)
  486. {
  487. /*
  488.  *  somfIsEqual returns TRUE if obj is isomorphic to this.  The default function
  489.  *  will give you a nasty message.  For example, the somfIsEqual method
  490.  *  for TText objects will do a string comparison.  All of the utility classes
  491.  *  allow you to specify what methods to use when comparing objects for
  492.  *  insertion, deletion, etc.
  493.  */
  494.    return SOM_ResolveD(this,somf_MOrderableCollectible,somf_MCollectible,somfIsEqual)
  495.     (this, ev,obj);
  496. }
  497.  
  498.  
  499. /* method: somfIsSame */
  500. boolean   somfIsSame(Environment *ev, 
  501.         somf_MCollectible* obj)
  502. {
  503. /*
  504.  *  The default function for somfIsSame is a pointer comparison
  505.  */
  506.    return SOM_ResolveD(this,somf_MOrderableCollectible,somf_MCollectible,somfIsSame)
  507.     (this, ev,obj);
  508. }
  509.  
  510.  
  511. /* method: somfIsNotEqual */
  512. boolean   somfIsNotEqual(Environment *ev, 
  513.         somf_MCollectible* obj)
  514. {
  515. /*
  516.  *  somfIsNotEqual returns TRUE if obj is NOT isomorphic to this.  It uses
  517.  *  somfIsEqual, so overriding somfIsEqual will handle the logic of somfIsNotEqual too.
  518.  */
  519.    return SOM_ResolveD(this,somf_MOrderableCollectible,somf_MCollectible,somfIsNotEqual)
  520.     (this, ev,obj);
  521. }
  522.  
  523.  
  524. /* initializer method: somDefaultInit */
  525. void   somDefaultInit(som3InitCtrl* ctrl)
  526. {
  527. /*
  528.  *  A default initializer for a SOM object. Passing a null ctrl
  529.  *  indicates to the receiver that its class is the class of the
  530.  *  object being initialized, whereby the initializer will determine
  531.  *  an appropriate control structure.
  532.  */
  533.    SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDefaultInit)
  534.     (this,ctrl);
  535. }
  536.  
  537.  
  538. /* method: somDestruct */
  539. void   somDestruct(octet doFree, 
  540.         som3DestructCtrl* ctrl)
  541. {
  542. /*
  543.  *  The default destructor for a SOM object. A nonzero <doFree>
  544.  *  indicates that the object storage should be freed by the
  545.  *  object's class (via somDeallocate) after uninitialization.
  546.  *  As with somDefaultInit, a null ctrl can be passed.
  547.  */
  548.    SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDestruct)
  549.     (this,doFree,ctrl);
  550. }
  551.  
  552.  
  553. /* initializer method: somDefaultCopyInit */
  554. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  555.         SOMObject* fromObj)
  556. {
  557. /*
  558.  *  A default copy constructor. Use this to make copies of objects for
  559.  *  calling methods with "by-value" argument semantics.
  560.  */
  561.    SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDefaultCopyInit)
  562.     (this,ctrl,fromObj);
  563. }
  564.  
  565.  
  566. /* method: somDefaultAssign */
  567. somf_MOrderableCollectible*  somDefaultAssign(som3AssignCtrl* ctrl, 
  568.         SOMObject* fromObj)
  569. {
  570. /*
  571.  *  A default assignment operator. Use this to "assign" the state of one
  572.  *  object to another.
  573.  */
  574.    return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDefaultAssign)
  575.     (this,ctrl,fromObj);
  576. }
  577.  
  578.  
  579. /* initializer method: somDefaultConstCopyInit */
  580. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  581.         SOMObject* fromObj)
  582. {
  583. /*
  584.  *  A default copy constructor that uses a const fromObj.
  585.  */
  586.    SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDefaultConstCopyInit)
  587.     (this,ctrl,fromObj);
  588. }
  589.  
  590.  
  591. /* initializer method: somDefaultVCopyInit */
  592. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  593.         SOMObject* fromObj)
  594. {
  595. /*
  596.  *  A default copy constructor that uses a volatile fromObj.
  597.  */
  598.    SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDefaultVCopyInit)
  599.     (this,ctrl,fromObj);
  600. }
  601.  
  602.  
  603. /* initializer method: somDefaultConstVCopyInit */
  604. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  605.         SOMObject* fromObj)
  606. {
  607. /*
  608.  *  A default copy constructor that uses a const volatile fromObj.
  609.  */
  610.    SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDefaultConstVCopyInit)
  611.     (this,ctrl,fromObj);
  612. }
  613.  
  614.  
  615. /* method: somDefaultConstAssign */
  616. somf_MOrderableCollectible*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  617.         SOMObject* fromObj)
  618. {
  619. /*
  620.  *  A default assignment operator that uses a const fromObj.
  621.  */
  622.    return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDefaultConstAssign)
  623.     (this,ctrl,fromObj);
  624. }
  625.  
  626.  
  627. /* method: somDefaultVAssign */
  628. somf_MOrderableCollectible*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  629.         SOMObject* fromObj)
  630. {
  631. /*
  632.  *  A default assignment operator that uses a volatile fromObj.
  633.  */
  634.    return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDefaultVAssign)
  635.     (this,ctrl,fromObj);
  636. }
  637.  
  638.  
  639. /* method: somDefaultConstVAssign */
  640. somf_MOrderableCollectible*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  641.         SOMObject* fromObj)
  642. {
  643. /*
  644.  *  A default assignment operator that uses a const volatile fromObj.
  645.  */
  646.    return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDefaultConstVAssign)
  647.     (this,ctrl,fromObj);
  648. }
  649.  
  650.  
  651. /* method: somInit */
  652. void   somInit()
  653. {
  654. /*
  655.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  656.  */
  657.    SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somInit)
  658.     (this);
  659. }
  660.  
  661.  
  662. /* method: somFree */
  663. void   somFree()
  664. {
  665. /*
  666.  *  Use as directed by framework implementations.
  667.  */
  668.    SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somFree)
  669.     (this);
  670. }
  671.  
  672.  
  673. /* method: somUninit */
  674. void   somUninit()
  675. {
  676. /*
  677.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  678.  */
  679.    SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somUninit)
  680.     (this);
  681. }
  682.  
  683.  
  684. /* method: somGetClass */
  685. SOMClass*   somGetClass()
  686. {
  687. /*
  688.  *  Return the receiver's class.
  689.  */
  690.    return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somGetClass)
  691.     (this);
  692. }
  693.  
  694.  
  695. /* method: somGetClassName */
  696. string   somGetClassName()
  697. {
  698. /*
  699.  *  Return the name of the receiver's class.
  700.  */
  701.    return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somGetClassName)
  702.     (this);
  703. }
  704.  
  705.  
  706. /* method: somGetSize */
  707. long   somGetSize()
  708. {
  709. /*
  710.  *  Return the size of the receiver.
  711.  */
  712.    return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somGetSize)
  713.     (this);
  714. }
  715.  
  716.  
  717. /* method: somIsA */
  718. boolean   somIsA(SOMClass* aClassObj)
  719. {
  720. /*
  721.  *  Returns 1 (true) if the receiver responds to methods
  722.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  723.  */
  724.    return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somIsA)
  725.     (this,aClassObj);
  726. }
  727.  
  728.  
  729. /* method: somIsInstanceOf */
  730. boolean   somIsInstanceOf(SOMClass* aClassObj)
  731. {
  732. /*
  733.  *  Returns 1 (true) if the receiver is an instance of
  734.  *  <aClassObj> and 0 (false) otherwise.
  735.  */
  736.    return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somIsInstanceOf)
  737.     (this,aClassObj);
  738. }
  739.  
  740.  
  741. /* method: somRespondsTo */
  742. boolean   somRespondsTo(somId mId)
  743. {
  744. /*
  745.  *  Returns 1 (true) if the indicated method can be invoked
  746.  *  on the receiver and 0 (false) otherwise.
  747.  */
  748.    return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somRespondsTo)
  749.     (this,mId);
  750. }
  751.  
  752.  
  753. /* va_list method: somDispatch */
  754.  
  755. /*
  756.  *  This method provides a generic, class-specific dispatch mechanism.
  757.  *  It accepts as input <retValue> a pointer to the memory area to be
  758.  *  loaded with the result of dispatching the method indicated by
  759.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  760.  *  on which the method is to be invoked as the first argument.
  761.  */
  762. /* the va_list invocation form */
  763. boolean   somf_MOrderableCollectible_somDispatch(somToken* retValue, 
  764.         somId methodId, 
  765.         va_list ap)
  766. {return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDispatch)
  767.     (this,retValue,methodId,ap);
  768. }
  769.  
  770. /* the varargs invocation form */
  771. boolean   somDispatch(somToken* retValue, 
  772.         somId methodId, 
  773.         ...)
  774. {
  775. /*
  776.  *  This method provides a generic, class-specific dispatch mechanism.
  777.  *  It accepts as input <retValue> a pointer to the memory area to be
  778.  *  loaded with the result of dispatching the method indicated by
  779.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  780.  *  on which the method is to be invoked as the first argument.
  781.  */
  782.    va_list ap;
  783.    va_start(ap, methodId);
  784.    boolean __somResult = 
  785.       SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDispatch)
  786.     (this,retValue,methodId,ap);
  787.    va_end(ap);
  788.    return __somResult;
  789. }
  790.  
  791.  
  792. /* va_list method: somClassDispatch */
  793.  
  794. /*
  795.  *  Like somDispatch, but method resolution for static methods is done
  796.  *  according to the clsObj instance method table.
  797.  */
  798. /* the va_list invocation form */
  799. boolean   somf_MOrderableCollectible_somClassDispatch(SOMClass* clsObj, 
  800.         somToken* retValue, 
  801.         somId methodId, 
  802.         va_list ap)
  803. {return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somClassDispatch)
  804.     (this,clsObj,retValue,methodId,ap);
  805. }
  806.  
  807. /* the varargs invocation form */
  808. boolean   somClassDispatch(SOMClass* clsObj, 
  809.         somToken* retValue, 
  810.         somId methodId, 
  811.         ...)
  812. {
  813. /*
  814.  *  Like somDispatch, but method resolution for static methods is done
  815.  *  according to the clsObj instance method table.
  816.  */
  817.    va_list ap;
  818.    va_start(ap, methodId);
  819.    boolean __somResult = 
  820.       SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somClassDispatch)
  821.     (this,clsObj,retValue,methodId,ap);
  822.    va_end(ap);
  823.    return __somResult;
  824. }
  825.  
  826.  
  827. /* method: somCastObj */
  828. boolean   somCastObj(SOMClass* cls)
  829. {
  830. /*
  831.  *  cast the receiving object to cls (which must be an ancestor of the
  832.  *  objects true class. Returns true on success.
  833.  */
  834.    return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somCastObj)
  835.     (this,cls);
  836. }
  837.  
  838.  
  839. /* method: somResetObj */
  840. boolean   somResetObj()
  841. {
  842. /*
  843.  *  reset an object to its true class. Returns true always.
  844.  */
  845.    return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somResetObj)
  846.     (this);
  847. }
  848.  
  849.  
  850. /* va_list method: somDispatchV */
  851.  
  852. /*
  853.  *  Obsolete. Use somDispatch instead.
  854.  */
  855. /* the va_list invocation form */
  856. void   somf_MOrderableCollectible_somDispatchV(somId methodId, 
  857.         somId descriptor, 
  858.         va_list ap)
  859. {   SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDispatchV)
  860.     (this,methodId,descriptor,ap);
  861. }
  862.  
  863. /* the varargs invocation form */
  864. void   somDispatchV(somId methodId, 
  865.         somId descriptor, 
  866.         ...)
  867. {
  868. /*
  869.  *  Obsolete. Use somDispatch instead.
  870.  */
  871.    va_list ap;
  872.    va_start(ap, descriptor);
  873.    SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDispatchV)
  874.     (this,methodId,descriptor,ap);
  875.    va_end(ap);
  876. }
  877.  
  878.  
  879. /* va_list method: somDispatchL */
  880.  
  881. /*
  882.  *  Obsolete. Use somDispatch instead.
  883.  */
  884. /* the va_list invocation form */
  885. long   somf_MOrderableCollectible_somDispatchL(somId methodId, 
  886.         somId descriptor, 
  887.         va_list ap)
  888. {return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDispatchL)
  889.     (this,methodId,descriptor,ap);
  890. }
  891.  
  892. /* the varargs invocation form */
  893. long   somDispatchL(somId methodId, 
  894.         somId descriptor, 
  895.         ...)
  896. {
  897. /*
  898.  *  Obsolete. Use somDispatch instead.
  899.  */
  900.    va_list ap;
  901.    va_start(ap, descriptor);
  902.    long __somResult = 
  903.       SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDispatchL)
  904.     (this,methodId,descriptor,ap);
  905.    va_end(ap);
  906.    return __somResult;
  907. }
  908.  
  909.  
  910. /* va_list method: somDispatchA */
  911.  
  912. /*
  913.  *  Obsolete. Use somDispatch instead.
  914.  */
  915. /* the va_list invocation form */
  916. void*   somf_MOrderableCollectible_somDispatchA(somId methodId, 
  917.         somId descriptor, 
  918.         va_list ap)
  919. {return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDispatchA)
  920.     (this,methodId,descriptor,ap);
  921. }
  922.  
  923. /* the varargs invocation form */
  924. void*   somDispatchA(somId methodId, 
  925.         somId descriptor, 
  926.         ...)
  927. {
  928. /*
  929.  *  Obsolete. Use somDispatch instead.
  930.  */
  931.    va_list ap;
  932.    va_start(ap, descriptor);
  933.    void* __somResult = 
  934.       SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDispatchA)
  935.     (this,methodId,descriptor,ap);
  936.    va_end(ap);
  937.    return __somResult;
  938. }
  939.  
  940.  
  941. /* va_list method: somDispatchD */
  942.  
  943. /*
  944.  *  Obsolete. Use somDispatch instead.
  945.  */
  946. /* the va_list invocation form */
  947. double   somf_MOrderableCollectible_somDispatchD(somId methodId, 
  948.         somId descriptor, 
  949.         va_list ap)
  950. {return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDispatchD)
  951.     (this,methodId,descriptor,ap);
  952. }
  953.  
  954. /* the varargs invocation form */
  955. double   somDispatchD(somId methodId, 
  956.         somId descriptor, 
  957.         ...)
  958. {
  959. /*
  960.  *  Obsolete. Use somDispatch instead.
  961.  */
  962.    va_list ap;
  963.    va_start(ap, descriptor);
  964.    double __somResult = 
  965.       SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDispatchD)
  966.     (this,methodId,descriptor,ap);
  967.    va_end(ap);
  968.    return __somResult;
  969. }
  970.  
  971.  
  972. /* method: somPrintSelf */
  973. SOMObject*   somPrintSelf()
  974. {
  975. /*
  976.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  977.  *  information about this object.  The default implementation just gives
  978.  *  the object's class name and its address in memory.
  979.  *  <self> is returned.
  980.  */
  981.    return SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somPrintSelf)
  982.     (this);
  983. }
  984.  
  985.  
  986. /* method: somDumpSelf */
  987. void   somDumpSelf(long level)
  988. {
  989. /*
  990.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  991.  *  and its current state.
  992.  * 
  993.  *  <level> indicates the nesting level for describing compound objects
  994.  *  it must be greater than or equal to zero.  All lines in the
  995.  *  description will be preceeded by <2*level> spaces.
  996.  * 
  997.  *  This routine only actually writes the data that concerns the object
  998.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  999.  *  the object's current state.  This approach allows readable
  1000.  *  descriptions of compound objects to be constructed.
  1001.  * 
  1002.  *  Generally it is not necessary to override this method, if it is
  1003.  *  overriden it generally must be completely replaced.
  1004.  */
  1005.    SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDumpSelf)
  1006.     (this,level);
  1007. }
  1008.  
  1009.  
  1010. /* method: somDumpSelfInt */
  1011. void   somDumpSelfInt(long level)
  1012. {
  1013. /*
  1014.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  1015.  *  Generally this method will need to be overridden.  When overriding
  1016.  *  it, begin by calling the parent class form of this method and then
  1017.  *  write in a description of your class's instance data. This will
  1018.  *  result in a description of all the object's instance data going
  1019.  *  from its root ancestor class to its specific class.
  1020.  */
  1021.    SOM_ResolveD(this,somf_MOrderableCollectible,SOMObject,somDumpSelfInt)
  1022.     (this,level);
  1023. }
  1024.  
  1025.  
  1026.  
  1027. };   /* somf_MOrderableCollectible */
  1028.  
  1029.  
  1030.  
  1031. #endif       /* SOM_somf_MOrderableCollectible_xh */
  1032.