home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional Developers Kit 1992 November / Disc01 / Disc01.mdf / cppbeta / bbxxk / istdops.h__ / ISTDOPS.H
Encoding:
C/C++ Source or Header  |  1992-10-26  |  5.7 KB  |  241 lines
  1. /* Copyright (c) IBM Corp. 1992 */
  2. #ifndef _ISTDOPS_H
  3. #define _ISTDOPS_H
  4.  
  5. #include <iglobals.h>
  6. #include <string.h>
  7.  
  8. // indirection for function/operator application
  9.  
  10. template < class Element >
  11. inline Element& elementForOps (Element& e)
  12. { return e; }
  13.  
  14. template < class Element >
  15. inline Element const& elementForOps (Element const& e)
  16. { return e; }
  17.  
  18. // memory management
  19.  
  20. class IStdMemOps {
  21. public:
  22.   void*          allocate   (size_t s) const;
  23.   void           deallocate (void* p) const;
  24. };
  25.  
  26. inline void* IStdMemOps::
  27. allocate (size_t s) const {
  28.   return ::operator new (s);
  29. }
  30.  
  31. inline void IStdMemOps::
  32. deallocate (void* p) const {
  33.   ::operator delete (p);
  34. }
  35.  
  36. // assignment
  37.  
  38. template < class Element >
  39. inline void assign (Element& e1, Element const& e2) {
  40.   e1 = e2;
  41. }
  42.  
  43. template < class Element >
  44. class IStdAsOps {
  45. public:
  46.   void           assign (Element& e1, Element const& e2) const;
  47. };
  48.  
  49. template < class Element >
  50. inline void IStdAsOps < Element >::
  51. assign (Element& e1, Element const& e2) const {
  52.   ::assign (elementForOps (e1), elementForOps (e2));
  53. }
  54.  
  55. // equality
  56.  
  57. template < class Element >
  58. inline Boolean equal (Element const& e1, Element const& e2) {
  59.   return e1 == e2;
  60. }
  61.  
  62. inline Boolean equal (char const* e1, char const* e2) {
  63.   return strcmp (e1, e2) == 0;
  64. }
  65.  
  66. template < class Element >
  67. class IStdEqOps {
  68. public:
  69.   Boolean        equal (Element const& e1, Element const& e2) const;
  70. };
  71.  
  72. template < class Element >
  73. inline Boolean IStdEqOps < Element >::
  74. equal (Element const& e1, Element const& e2) const {
  75.   return ::equal (elementForOps (e1), elementForOps (e2));
  76. }
  77.  
  78. // ordering relation
  79.  
  80. template < class Element >
  81. inline long compare (Element const& e1, Element const& e2) {
  82.   if      (e1 < e2) return -1;
  83.   else if (e2 < e1) return 1;
  84.   else              return 0;
  85. }
  86.  
  87. inline long compare (int e1, int e2) {
  88.   return e1 - e2;
  89. }
  90.  
  91. inline long compare (char* e1, char* e2) {
  92.   return strcmp (e1, e2);
  93. }
  94.  
  95. template < class Element >
  96. class IStdCmpOps {
  97. public:
  98.   long           compare (Element const& e1, Element const& e2) const;
  99. };
  100.  
  101. template < class Element >
  102. inline long IStdCmpOps < Element >::
  103. compare (Element const& e1, Element const& e2) const {
  104.   return ::compare (elementForOps (e1), elementForOps (e2));
  105. }
  106.  
  107. // hash function
  108.  
  109. inline unsigned long hash (int e, unsigned long n) {
  110.   return e % n;
  111. }
  112.  
  113. inline unsigned long hash (char* e, unsigned long n) {
  114.   unsigned int len = strlen (e);
  115.   if (len == 0)
  116.     return 0;
  117.   else
  118.     return (e [0] + e [len-1] + e [len/2]) % n;
  119. }
  120.  
  121. template < class Element >
  122. class IStdHshOps {
  123. public:
  124.   unsigned long  hash (Element const& e, unsigned long n) const;
  125. };
  126.  
  127. template < class Element >
  128. inline unsigned long IStdHshOps < Element >::
  129. hash (Element const& e, unsigned long n) const {
  130.   return ::hash (elementForOps (e), n);
  131. }
  132.  
  133. // key selection
  134.  
  135. template < class Element, class Key >
  136. class IStdKeyOps {
  137. public:
  138.   Key const& key (Element const& e) const;
  139. };
  140.  
  141. template < class Element, class Key >
  142. inline Key const& IStdKeyOps < Element, Key >::
  143. key (Element const& e) const {
  144.   return ::key (elementForOps (e));
  145. }
  146.  
  147. // standard operation combinations
  148.  
  149. template < class Element >
  150. class IStdOps : public IStdMemOps,
  151.             public IStdAsOps < Element > {
  152. };
  153.  
  154. template < class Element >
  155. class IEOps : public IStdOps < Element >,
  156.           public IStdEqOps < Element > {
  157. };
  158.  
  159. template < class Element >
  160. class IECOps : public IEOps < Element >,
  161.            public IStdCmpOps < Element > {
  162. };
  163.  
  164. template < class Element >
  165. class IEHOps : public IEOps < Element >,
  166.            public IStdHshOps < Element > {
  167. };
  168.  
  169. template < class Element, class Key >
  170. class IKCOps : public IStdOps < Element >,
  171.            public IStdKeyOps < Element, Key > {
  172. public:
  173.   class KeyOps : public IStdCmpOps < Key > {
  174.   } keyOps;
  175. };
  176.  
  177. template < class Element, class Key >
  178. class IKEHOps : public IStdOps < Element >,
  179.         public IStdKeyOps < Element, Key > {
  180. public:
  181.   class KeyOps : public IStdEqOps < Key >,
  182.          public IStdHshOps < Key > {
  183.   } keyOps;
  184. };
  185.  
  186. template < class Element, class Key >
  187. class IEKCOps : public IEOps < Element >,
  188.         public IStdKeyOps < Element, Key > {
  189. public:
  190.   class KeyOps : public IStdCmpOps < Key > {
  191.   } keyOps;
  192. };
  193.  
  194. template < class Element, class Key >
  195. class IEKEHOps : public IEOps < Element >,
  196.          public IStdKeyOps < Element, Key > {
  197. public:
  198.   class KeyOps : public IStdEqOps < Key >,
  199.          public IStdHshOps < Key > {
  200.   } keyOps;
  201. };
  202.  
  203. // definition macor for templates with given operation class
  204.  
  205. #define IDefineCollectionWithOps(IGCollection, Ops, ICollection) \
  206. template < class Element > \
  207. class ICollection : \
  208.   public IGCollection < Element, Ops < Element > > { \
  209. public: \
  210.   ICollection (INumber n = 100, IBoundIndicator b = IUnbounded) : \
  211.     IGCollection < Element, Ops < Element > > (n, b) {} \
  212. };
  213.  
  214. #define IDefineKeyCollectionWithOps(IGCollection, Ops, ICollection) \
  215. template < class Element, class Key > \
  216. class ICollection : \
  217.   public IGCollection < Element, Key, Ops < Element, Key > > { \
  218. public: \
  219.   ICollection (INumber n = 100, IBoundIndicator b = IUnbounded) : \
  220.     IGCollection < Element, Key, Ops < Element, Key > > (n, b) {} \
  221. };
  222.  
  223. #define IDefineStdCollectionWithOps(Collection) IDefineCollectionWithOps \
  224.   (IG ## Collection, I ## Collection ## Ops, I ## Collection)
  225.  
  226. #define IDefineStdKeyCollectionWithOps(Collection) IDefineKeyCollectionWithOps \
  227.   (IG ## Collection, I ## Collection ## Ops, I ## Collection)
  228.  
  229. // key extension
  230.  
  231. template < class Element, class ElementOps >
  232. class IOpsWithKey : public ElementOps {
  233. public:
  234.   Element const& key (Element const& e) const {
  235.     return e;
  236.   }
  237.   ElementOps keyOps;
  238. };
  239.  
  240. #endif
  241.