home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / trialva / ibmcppw / include / istdops.inl < prev    next >
Encoding:
Text File  |  1996-02-22  |  7.2 KB  |  312 lines
  1. /**********************************************************************
  2. *                                                                     *
  3. *  IBM(R) VisualAge(TM) for C++ for Windows(R), Version 3.5           *
  4. *                                                                     *
  5. *  PID: 5622-880                                                      *
  6. *  - Licensed Material - Program-Property of IBM                      *
  7. *  (C) Copyright IBM Corp. 1991, 1995 - All Right Reserved.           *
  8. *                                                                     *
  9. *  US Government Users Restricted Rights - Use, duplication or        *
  10. *  disclosure restricted by GSA ADP Schedule Contract with IBM Corp.  *
  11. *                                                                     *
  12. *  VisualAge, and IBM are trademarks or registered trademarks of      *
  13. *  International Business Machines Corporation.                       *
  14. *  Windows is a registered trademark of Microsoft Corporation.        *
  15. *                                                                     *
  16. **********************************************************************/
  17.  
  18. #include <string.h>
  19.  
  20. // -------------
  21. // elementForOps
  22. // -------------
  23.  
  24. template <class Element>
  25. inline Element& elementForOps (Element& e)
  26. { return e;
  27. }
  28.  
  29. template <class Element>
  30. inline Element const& elementForOps (Element const& e)
  31. { return e;
  32. }
  33.  
  34. // ----------
  35. // IStdMemOps
  36. // ----------
  37.  
  38. inline void*
  39. IStdMemOps::
  40. allocate (size_t s
  41. #if defined (__DEBUG_ALLOC__)
  42.           , char const* fn, unsigned long ln
  43. #endif
  44.          ) const
  45. {
  46.     return ::operator new (s
  47. #if defined (__DEBUG_ALLOC__)
  48.                            , fn, ln
  49. #endif
  50.                           );
  51. }
  52.  
  53. inline void
  54. IStdMemOps::
  55. deallocate (void* p
  56. #if defined (__DEBUG_ALLOC__)
  57.             , char const* fn, unsigned long ln
  58. #endif
  59.            ) const
  60. { ::operator delete (p
  61. #if defined (__DEBUG_ALLOC__)
  62.                      , fn, ln
  63. #endif
  64.                     );
  65. }
  66.  
  67. template <class ElementOps>
  68. inline void*
  69. IWStdMemOps <ElementOps>::
  70. Allocate (size_t s
  71. #if defined (__DEBUG_ALLOC__)
  72.           , char const* fn, unsigned long ln
  73. #endif
  74.          ) const
  75. { return ivElementOps.allocate (s
  76. #if defined (__DEBUG_ALLOC__)
  77.                                 , fn, ln
  78. #endif
  79.                                );
  80. }
  81.  
  82. template <class ElementOps>
  83. inline void
  84. IWStdMemOps <ElementOps>::
  85. Deallocate (void* p
  86. #if defined (__DEBUG_ALLOC__)
  87.             , char const* fn, unsigned long ln
  88. #endif
  89.            ) const
  90. { ivElementOps.deallocate (p
  91. #if defined (__DEBUG_ALLOC__)
  92.                            , fn, ln
  93. #endif
  94.                           );
  95. }
  96.  
  97. // ---------
  98. // IStdAsOps
  99. // ---------
  100.  
  101. template <class Element>
  102. inline void
  103. assign (Element& e1, Element const& e2)
  104. { e1 = e2;
  105. }
  106.  
  107. // public members
  108.  
  109. template <class Element>
  110. inline void
  111. IStdAsOps <Element>::
  112. assign (Element& e1, Element const& e2) const
  113. { ::assign (e1, e2);
  114. }
  115.  
  116. template <class Element, class ElementOps>
  117. inline void
  118. IWStdAsOps <Element, ElementOps>::
  119. Assign (Element& e1, Element const& e2) const
  120. { ivElementOps.assign (e1, e2);
  121. }
  122.  
  123. // ---------
  124. // IStdEqOps
  125. // ---------
  126.  
  127. template <class Element>
  128. inline IBoolean
  129. equal (Element const& e1, Element const& e2)
  130. { return (e1 == e2);
  131. }
  132.  
  133. inline IBoolean
  134. equal (char const* e1, char const* e2)
  135. { return (strcmp (e1, e2) == 0);
  136. }
  137.  
  138. // public members
  139.  
  140. template <class Element>
  141. inline IBoolean
  142. IStdEqOps <Element>::
  143. equal (Element const& e1, Element const& e2) const
  144. { return ::equal (elementForOps (e1), elementForOps (e2));
  145. }
  146.  
  147. template <class Element, class ElementOps>
  148. inline IBoolean
  149. IWStdEqOps <Element, ElementOps>::
  150. Equal (Element const& e1, Element const& e2) const
  151. { return ivElementOps.equal (e1, e2);
  152. }
  153.  
  154. template <class Key, class ElementOps>
  155. inline IBoolean
  156. IWStdEqKeyOps <Key, ElementOps>::
  157. Equal (Key const& k1, Key const& k2) const
  158. { return ivElementOps.keyOps.equal (k1, k2);
  159. }
  160.  
  161. // ----------
  162. // IStdCmpOps
  163. // ----------
  164.  
  165. template <class Element>
  166. inline long
  167. compare (Element const& e1, Element const& e2)
  168. { if      (e1 < e2) return -1;
  169.   else if (e2 < e1) return  1;
  170.   else              return  0;
  171. }
  172.  
  173. inline long
  174. compare (int e1, int e2)
  175. { return (e1 - e2);
  176. }
  177.  
  178. inline long
  179. compare (char const* e1, char const* e2)
  180. { return strcmp (e1, e2);
  181. }
  182.  
  183. // public members
  184.  
  185. template <class Element>
  186. inline long
  187. IStdCmpOps <Element>::
  188. compare (Element const& e1, Element const& e2) const
  189. { return ::compare (elementForOps (e1), elementForOps (e2));
  190. }
  191.  
  192. template <class Element, class ElementOps>
  193. inline long
  194. IWStdCmpOps <Element, ElementOps>::
  195. Compare (Element const& e1, Element const& e2) const
  196. { return ivElementOps.compare (e1, e2);
  197. }
  198.  
  199. template <class Key, class ElementOps>
  200. inline long
  201. IWStdCmpKeyOps <Key, ElementOps>::
  202. Compare (Key const& k1, Key const& k2) const
  203. { return ivElementOps.keyOps.compare (k1, k2);
  204. }
  205.  
  206. // ----------
  207. // IStdHshOps
  208. // ----------
  209.  
  210. inline unsigned long
  211. hash (int e, unsigned long h)
  212. { return e % h;
  213. }
  214.  
  215. inline unsigned long
  216. hash (char const* s, unsigned long h)
  217. { unsigned long hashValue = 0, g;
  218.   for (char* p = (char*)s; *p != '\0'; p++) {
  219.     hashValue = (hashValue << 4) + *p;
  220.     if ((g = hashValue & 0xf0000000L) != 0) {
  221.       hashValue ^= (g >> 24);
  222.       hashValue ^= g;
  223.     }
  224.   }
  225.   return hashValue % h;
  226. } // see: Aho, Sethi, Ullman
  227.   //      "Compilers: Principles, Techniques, and Tools"
  228.  
  229. // public members
  230.  
  231. template <class Element>
  232. inline unsigned long
  233. IStdHshOps <Element>::
  234. hash (Element const& e, unsigned long h) const
  235. { return ::hash (elementForOps (e), h);
  236. }
  237.  
  238. template <class Element, class ElementOps>
  239. inline unsigned long
  240. IWStdHshOps <Element, ElementOps>::
  241. Hash (Element const& e, unsigned long h) const
  242. { return ivElementOps.hash (e, h);
  243. }
  244.  
  245. template <class Key, class ElementOps>
  246. inline unsigned long
  247. IWStdHshKeyOps <Key, ElementOps>::
  248. Hash (Key const& k, unsigned long h) const
  249. { return ivElementOps.keyOps.hash (k, h);
  250. }
  251.  
  252. // ----------
  253. // IStdKeyOps
  254. // ----------
  255.  
  256. // public members
  257.  
  258. template <class Element, class Key>
  259. inline Key const&
  260. IStdKeyOps <Element, Key>::
  261. key (Element const& e) const
  262. { return ::key (elementForOps (e));
  263. }
  264.  
  265. template <class Element, class _Key, class ElementOps>
  266. inline _Key const&
  267. IWStdKeyOps <Element, _Key, ElementOps>::
  268. Key (Element const& e) const
  269. { return ivElementOps.key (e);
  270. }
  271.  
  272. // -----------------
  273. // IStdOpsSubstitute
  274. // -----------------
  275.  
  276. // public members
  277.  
  278. template <class Element, class ElementOps>
  279. inline TStream&
  280. IWStdOps <Element, ElementOps>::
  281. operator<<= (TStream& fromWhere)
  282. { return fromWhere;
  283. }
  284.  
  285. template <class Element, class ElementOps>
  286. inline TStream&
  287. IWStdOps <Element, ElementOps>::
  288. operator>>= (TStream& toWhere) const
  289. { return toWhere;
  290. }
  291.  
  292. template <class Element, class ElementOps>
  293. inline void
  294. IWStdOps <Element, ElementOps>::
  295. StreamIn (Element&, TStream&) const
  296. {
  297. }
  298.  
  299. template <class Element, class ElementOps>
  300. inline void
  301. IWStdOps <Element, ElementOps>::
  302. StreamOut (Element const&, TStream&) const
  303. {
  304. }
  305.  
  306. template <class Element, class ElementOps>
  307. inline Element*
  308. IWStdOps <Element, ElementOps>::
  309. GetStreamable ()
  310. { return 0;
  311. }
  312.