00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150 #ifdef P_USE_PRAGMA
00151 #pragma interface
00152 #endif
00153
00154
00156
00157
00161 class POrdinalKey : public PObject
00162 {
00163 PCLASSINFO(POrdinalKey, PObject);
00164
00165 public:
00170 PINLINE POrdinalKey(
00171 PINDEX newKey = 0
00172 );
00173
00176 PINLINE POrdinalKey & operator=(PINDEX);
00178
00181
00182 virtual PObject * Clone() const;
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193 virtual Comparison Compare(const PObject & obj) const;
00194
00201 virtual PINDEX HashFunction() const;
00202
00209 virtual void PrintOn(ostream & strm) const;
00211
00216 PINLINE operator PINDEX() const;
00217
00220 PINLINE PINDEX operator++();
00221
00224 PINLINE PINDEX operator++(int);
00225
00228 PINLINE PINDEX operator--();
00229
00232 PINLINE PINDEX operator--(int);
00233
00236 PINLINE POrdinalKey & operator+=(PINDEX);
00237
00240 PINLINE POrdinalKey & operator-=(PINDEX );
00242
00243 private:
00244 PINDEX theKey;
00245 };
00246
00247
00249
00260 class PHashTable : public PCollection
00261 {
00262 PCONTAINERINFO(PHashTable, PCollection);
00263
00264 public:
00267
00268 PHashTable();
00270
00282 virtual Comparison Compare(
00283 const PObject & obj
00284 ) const;
00286
00287
00288 protected:
00298 virtual BOOL SetSize(
00299 PINDEX newSize
00300 );
00302
00303
00314 PINLINE BOOL AbstractContains(
00315 const PObject & key
00316 ) const;
00317
00332 virtual const PObject & AbstractGetKeyAt(
00333 PINDEX index
00334 ) const;
00335
00350 virtual PObject & AbstractGetDataAt(
00351 PINDEX index
00352 ) const;
00354
00355
00356
00357 class Element {
00358 public:
00359 friend class Table;
00360 PObject * key;
00361 PObject * data;
00362 Element * next;
00363 Element * prev;
00364 };
00365
00366 PDECLARE_BASEARRAY(Table, Element *)
00367 #ifdef DOC_PLUS_PLUS
00368 {
00369 #endif
00370 public:
00371 virtual ~Table() { Destruct(); }
00372 virtual void DestroyContents();
00373
00374 PINDEX AppendElement(PObject * key, PObject * data);
00375 PObject * RemoveElement(const PObject & key);
00376 BOOL SetLastElementAt(PINDEX index);
00377 Element * GetElementAt(const PObject & key);
00378 PINDEX GetElementsIndex(const PObject*obj,BOOL byVal,BOOL keys) const;
00379
00380 PINDEX lastIndex;
00381 PINDEX lastBucket;
00382 Element * lastElement;
00383
00384 BOOL deleteKeys;
00385
00386 friend class PHashTable;
00387 friend class PAbstractSet;
00388 };
00389 friend class Table;
00390
00391
00392 Table * hashTable;
00393 };
00394
00395
00397
00400 class PAbstractSet : public PHashTable
00401 {
00402 PCONTAINERINFO(PAbstractSet, PHashTable);
00403 public:
00411 PINLINE PAbstractSet();
00413
00424 virtual PINDEX Append(
00425 PObject * obj
00426 );
00427
00440 virtual PINDEX Insert(
00441 const PObject & before,
00442 PObject * obj
00443 );
00444
00457 virtual PINDEX InsertAt(
00458 PINDEX index,
00459 PObject * obj
00460 );
00461
00472 virtual BOOL Remove(
00473 const PObject * obj
00474 );
00475
00482 virtual PObject * RemoveAt(
00483 PINDEX index
00484 );
00485
00491 virtual PObject * GetAt(
00492 PINDEX index
00493 ) const;
00494
00507 virtual BOOL SetAt(
00508 PINDEX index,
00509 PObject * val
00510 );
00511
00523 virtual PINDEX GetObjectsIndex(
00524 const PObject * obj
00525 ) const;
00526
00535 virtual PINDEX GetValuesIndex(
00536 const PObject & obj
00537 ) const;
00539 };
00540
00541
00542 #ifdef PHAS_TEMPLATES
00543
00554 template <class T> class PSet : public PAbstractSet
00555 {
00556 PCLASSINFO(PSet, PAbstractSet);
00557
00558 public:
00568 inline PSet(BOOL initialDeleteObjects = FALSE)
00569 : PAbstractSet() { AllowDeleteObjects(initialDeleteObjects); }
00571
00577 virtual PObject * Clone() const
00578 { return PNEW PSet(0, this); }
00580
00592 void Include(
00593 const T * obj
00594 ) { Append((PObject *)obj); }
00595
00603 PSet & operator+=(
00604 const T & obj
00605 ) { Append(obj.Clone()); return *this; }
00606
00614 void Exclude(
00615 const T * obj
00616 ) { Remove(obj); }
00617
00625 PSet & operator-=(
00626 const T & obj
00627 ) { RemoveAt(GetValuesIndex(obj)); return *this; }
00628
00637 BOOL Contains(
00638 const T & key
00639 ) const { return AbstractContains(key); }
00640
00649 BOOL operator[](
00650 const T & key
00651 ) const { return AbstractContains(key); }
00652
00664 virtual const T & GetKeyAt(
00665 PINDEX index
00666 ) const
00667 { return (const T &)AbstractGetKeyAt(index); }
00669
00670
00671 protected:
00672 PSet(int dummy, const PSet * c)
00673 : PAbstractSet(dummy, c)
00674 { reference->deleteObjects = c->reference->deleteObjects; }
00675 };
00676
00677
00689 #define PSET(cls, T) typedef PSet<T> cls
00690
00691
00703 #define PDECLARE_SET(cls, T, initDelObj) \
00704 PSET(cls##_PTemplate, T); \
00705 PDECLARE_CLASS(cls, cls##_PTemplate) \
00706 protected: \
00707 cls(int dummy, const cls * c) \
00708 : cls##_PTemplate(dummy, c) { } \
00709 public: \
00710 cls(BOOL initialDeleteObjects = initDelObj) \
00711 : cls##_PTemplate(initialDeleteObjects) { } \
00712 virtual PObject * Clone() const \
00713 { return PNEW cls(0, this); } \
00714
00715
00716 #else // PHAS_TEMPLATES
00717
00718
00719 #define PSET(cls, K) \
00720 class cls : public PAbstractSet { \
00721 PCLASSINFO(cls, PAbstractSet); \
00722 protected: \
00723 inline cls(int dummy, const cls * c) \
00724 : PAbstractSet(dummy, c) \
00725 { reference->deleteObjects = c->reference->deleteObjects; } \
00726 public: \
00727 inline cls(BOOL initialDeleteObjects = FALSE) \
00728 : PAbstractSet() { AllowDeleteObjects(initialDeleteObjects); } \
00729 virtual PObject * Clone() const \
00730 { return PNEW cls(0, this); } \
00731 inline void Include(const PObject * key) \
00732 { Append((PObject *)key); } \
00733 inline void Exclude(const PObject * key) \
00734 { Remove(key); } \
00735 inline BOOL operator[](const K & key) const \
00736 { return AbstractContains(key); } \
00737 inline BOOL Contains(const K & key) const \
00738 { return AbstractContains(key); } \
00739 virtual const K & GetKeyAt(PINDEX index) const \
00740 { return (const K &)AbstractGetKeyAt(index); } \
00741 }
00742
00743 #define PDECLARE_SET(cls, K, initDelObj) \
00744 PSET(cls##_PTemplate, K); \
00745 PDECLARE_CLASS(cls, cls##_PTemplate) \
00746 protected: \
00747 inline cls(int dummy, const cls * c) \
00748 : cls##_PTemplate(dummy, c) { } \
00749 public: \
00750 inline cls(BOOL initialDeleteObjects = initDelObj) \
00751 : cls##_PTemplate() { AllowDeleteObjects(initialDeleteObjects); } \
00752 virtual PObject * Clone() const \
00753 { return PNEW cls(0, this); } \
00754
00755
00756 #endif // PHAS_TEMPLATES
00757
00758
00759 PSET(POrdinalSet, POrdinalKey);
00760
00761
00763
00766 class PAbstractDictionary : public PHashTable
00767 {
00768 PCLASSINFO(PAbstractDictionary, PHashTable);
00769 public:
00777 PINLINE PAbstractDictionary();
00779
00788 virtual void PrintOn(
00789 ostream &strm
00790 ) const;
00792
00803 virtual PINDEX Insert(
00804 const PObject & key,
00805 PObject * obj
00806 );
00807
00814 virtual PINDEX InsertAt(
00815 PINDEX index,
00816 PObject * obj
00817 );
00818
00828 virtual PObject * RemoveAt(
00829 PINDEX index
00830 );
00831
00840 virtual BOOL SetAt(
00841 PINDEX index,
00842 PObject * val
00843 );
00844
00852 virtual PObject * GetAt(
00853 PINDEX index
00854 ) const;
00855
00867 virtual PINDEX GetObjectsIndex(
00868 const PObject * obj
00869 ) const;
00870
00879 virtual PINDEX GetValuesIndex(
00880 const PObject & obj
00881 ) const;
00883
00884
00895 virtual BOOL SetDataAt(
00896 PINDEX index,
00897 PObject * obj
00898 );
00899
00911 virtual BOOL AbstractSetAt(
00912 const PObject & key,
00913 PObject * obj
00914 );
00915
00925 virtual PObject & GetRefAt(
00926 const PObject & key
00927 ) const;
00928
00935 virtual PObject * AbstractGetAt(
00936 const PObject & key
00937 ) const;
00939
00940 protected:
00941 PINLINE PAbstractDictionary(int dummy, const PAbstractDictionary * c);
00942
00943 private:
00944 virtual PINDEX Append(
00945 PObject * obj
00946 );
00947
00948
00949
00950
00951
00952
00953 virtual BOOL Remove(
00954 const PObject * obj
00955 );
00956
00957
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967 };
00968
00969
00970 #ifdef PHAS_TEMPLATES
00971
00979 template <class K, class D> class PDictionary : public PAbstractDictionary
00980 {
00981 PCLASSINFO(PDictionary, PAbstractDictionary);
00982
00983 public:
00992 PDictionary()
00993 : PAbstractDictionary() { }
00995
01002 virtual PObject * Clone() const
01003 { return PNEW PDictionary(0, this); }
01005
01018 D & operator[](
01019 const K & key
01020 ) const
01021 { return (D &)GetRefAt(key); }
01022
01031 BOOL Contains(
01032 const K & key
01033 ) const { return AbstractContains(key); }
01034
01046 virtual D * RemoveAt(
01047 const K & key
01048 ) {
01049 D * obj = GetAt(key); AbstractSetAt(key, NULL);
01050 return reference->deleteObjects ? (obj ? (D *)-1 : NULL) : obj;
01051 }
01052
01064 virtual BOOL SetAt(
01065 const K & key,
01066 D * obj
01067 ) { return AbstractSetAt(key, obj); }
01068
01075 virtual D * GetAt(
01076 const K & key
01077 ) const { return (D *)AbstractGetAt(key); }
01078
01090 const K & GetKeyAt(
01091 PINDEX index
01092 ) const
01093 { return (const K &)AbstractGetKeyAt(index); }
01094
01106 D & GetDataAt(
01107 PINDEX index
01108 ) const
01109 { return (D &)AbstractGetDataAt(index); }
01111
01112 protected:
01113 PDictionary(int dummy, const PDictionary * c)
01114 : PAbstractDictionary(dummy, c) { }
01115 };
01116
01117
01130 #define PDICTIONARY(cls, K, D) typedef PDictionary<K, D> cls
01131
01132
01145 #define PDECLARE_DICTIONARY(cls, K, D) \
01146 PDICTIONARY(cls##_PTemplate, K, D); \
01147 PDECLARE_CLASS(cls, cls##_PTemplate) \
01148 protected: \
01149 cls(int dummy, const cls * c) \
01150 : cls##_PTemplate(dummy, c) { } \
01151 public: \
01152 cls() \
01153 : cls##_PTemplate() { } \
01154 virtual PObject * Clone() const \
01155 { return PNEW cls(0, this); } \
01156
01157
01165 template <class K> class POrdinalDictionary : public PAbstractDictionary
01166 {
01167 PCLASSINFO(POrdinalDictionary, PAbstractDictionary);
01168
01169 public:
01178 POrdinalDictionary()
01179 : PAbstractDictionary() { }
01181
01188 virtual PObject * Clone() const
01189 { return PNEW POrdinalDictionary(0, this); }
01191
01204 PINDEX operator[](
01205 const K & key
01206 ) const
01207 { return (POrdinalKey &)GetRefAt(key); }
01208
01217 BOOL Contains(
01218 const K & key
01219 ) const { return AbstractContains(key); }
01220
01221 virtual POrdinalKey * GetAt(
01222 const K & key
01223 ) const { return (POrdinalKey *)AbstractGetAt(key); }
01224
01225
01226
01227
01228
01229
01230
01239 virtual BOOL SetDataAt(
01240 PINDEX index,
01241 PINDEX ordinal
01242 ) { return PAbstractDictionary::SetDataAt(index, PNEW POrdinalKey(ordinal)); }
01243
01255 virtual BOOL SetAt(
01256 const K & key,
01257 PINDEX ordinal
01258 ) { return AbstractSetAt(key, PNEW POrdinalKey(ordinal)); }
01259
01268 virtual PINDEX RemoveAt(
01269 const K & key
01270 ) { PINDEX ord = *GetAt(key); AbstractSetAt(key, NULL); return ord; }
01271
01283 const K & GetKeyAt(
01284 PINDEX index
01285 ) const
01286 { return (const K &)AbstractGetKeyAt(index); }
01287
01299 PINDEX GetDataAt(
01300 PINDEX index
01301 ) const
01302 { return (POrdinalKey &)AbstractGetDataAt(index); }
01304
01305 protected:
01306 POrdinalDictionary(int dummy, const POrdinalDictionary * c)
01307 : PAbstractDictionary(dummy, c) { }
01308 };
01309
01310
01323 #define PORDINAL_DICTIONARY(cls, K) typedef POrdinalDictionary<K> cls
01324
01325
01340 #define PDECLARE_ORDINAL_DICTIONARY(cls, K) \
01341 PORDINAL_DICTIONARY(cls##_PTemplate, K); \
01342 PDECLARE_CLASS(cls, POrdinalDictionary<K>) \
01343 protected: \
01344 cls(int dummy, const cls * c) \
01345 : cls##_PTemplate(dummy, c) { } \
01346 public: \
01347 cls() \
01348 : cls##_PTemplate() { } \
01349 virtual PObject * Clone() const \
01350 { return PNEW cls(0, this); } \
01351
01352
01353 #else // PHAS_TEMPLATES
01354
01355
01356 #define PDICTIONARY(cls, K, D) \
01357 class cls : public PAbstractDictionary { \
01358 PCLASSINFO(cls, PAbstractDictionary); \
01359 protected: \
01360 inline cls(int dummy, const cls * c) \
01361 : PAbstractDictionary(dummy, c) { } \
01362 public: \
01363 cls() \
01364 : PAbstractDictionary() { } \
01365 virtual PObject * Clone() const \
01366 { return PNEW cls(0, this); } \
01367 D & operator[](const K & key) const \
01368 { return (D &)GetRefAt(key); } \
01369 virtual BOOL Contains(const K & key) const \
01370 { return AbstractContains(key); } \
01371 virtual D * RemoveAt(const K & key) \
01372 { D * obj = GetAt(key); AbstractSetAt(key, NULL); return obj; } \
01373 virtual BOOL SetAt(const K & key, D * obj) \
01374 { return AbstractSetAt(key, obj); } \
01375 virtual D * GetAt(const K & key) const \
01376 { return (D *)AbstractGetAt(key); } \
01377 const K & GetKeyAt(PINDEX index) const \
01378 { return (const K &)AbstractGetKeyAt(index); } \
01379 D & GetDataAt(PINDEX index) const \
01380 { return (D &)AbstractGetDataAt(index); } \
01381 }
01382
01383 #define PDECLARE_DICTIONARY(cls, K, D) \
01384 PDICTIONARY(cls##_PTemplate, K, D); \
01385 PDECLARE_CLASS(cls, cls##_PTemplate) \
01386 protected: \
01387 cls(int dummy, const cls * c) \
01388 : cls##_PTemplate(dummy, c) { } \
01389 public: \
01390 cls() \
01391 : cls##_PTemplate() { } \
01392 virtual PObject * Clone() const \
01393 { return PNEW cls(0, this); } \
01394
01395
01396 #define PORDINAL_DICTIONARY(cls, K) \
01397 class cls : public PAbstractDictionary { \
01398 PCLASSINFO(cls, PAbstractDictionary); \
01399 protected: \
01400 inline cls(int dummy, const cls * c) \
01401 : PAbstractDictionary(dummy, c) { } \
01402 public: \
01403 inline cls() \
01404 : PAbstractDictionary() { } \
01405 virtual PObject * Clone() const \
01406 { return PNEW cls(0, this); } \
01407 inline PINDEX operator[](const K & key) const \
01408 { return (POrdinalKey &)GetRefAt(key); } \
01409 virtual BOOL Contains(const K & key) const \
01410 { return AbstractContains(key); } \
01411 virtual POrdinalKey * GetAt(const K & key) const \
01412 { return (POrdinalKey *)AbstractGetAt(key); } \
01413 virtual BOOL SetDataAt(PINDEX index, PINDEX ordinal) \
01414 { return PAbstractDictionary::SetDataAt(index, PNEW POrdinalKey(ordinal)); } \
01415 virtual BOOL SetAt(const K & key, PINDEX ordinal) \
01416 { return AbstractSetAt(key, PNEW POrdinalKey(ordinal)); } \
01417 virtual PINDEX RemoveAt(const K & key) \
01418 { PINDEX ord = *GetAt(key); AbstractSetAt(key, NULL); return ord; } \
01419 inline const K & GetKeyAt(PINDEX index) const \
01420 { return (const K &)AbstractGetKeyAt(index); } \
01421 inline PINDEX GetDataAt(PINDEX index) const \
01422 { return (POrdinalKey &)AbstractGetDataAt(index); } \
01423 }
01424
01425 #define PDECLARE_ORDINAL_DICTIONARY(cls, K) \
01426 PORDINAL_DICTIONARY(cls##_PTemplate, K); \
01427 PDECLARE_CLASS(cls, cls##_PTemplate) \
01428 protected: \
01429 cls(int dummy, const cls * c) \
01430 : cls##_PTemplate(dummy, c) { } \
01431 public: \
01432 cls() \
01433 : cls##_PTemplate() { } \
01434 virtual PObject * Clone() const \
01435 { return PNEW cls(0, this); } \
01436
01437
01438 #endif // PHAS_TEMPLATES
01439
01440