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
#ifdef P_USE_PRAGMA
00143
#pragma interface
00144
#endif
00145
00146
00148
00149
00153 class POrdinalKey :
public PObject
00154 {
00155
PCLASSINFO(
POrdinalKey,
PObject);
00156
00157
public:
00162
PINLINE POrdinalKey(
00163 PINDEX newKey = 0
00164 );
00165
00168
PINLINE POrdinalKey &
operator=(PINDEX);
00170
00173
00174
virtual PObject *
Clone()
const;
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
virtual Comparison
Compare(
const PObject & obj)
const;
00186
00193
virtual PINDEX
HashFunction()
const;
00194
00201
virtual void PrintOn(ostream & strm)
const;
00203
00208
PINLINE operator PINDEX()
const;
00209
00212
PINLINE PINDEX
operator++();
00213
00216
PINLINE PINDEX
operator++(
int);
00217
00220
PINLINE PINDEX
operator--();
00221
00224
PINLINE PINDEX
operator--(
int);
00225
00228
PINLINE POrdinalKey &
operator+=(PINDEX);
00229
00232
PINLINE POrdinalKey &
operator-=(PINDEX );
00234
00235
private:
00236 PINDEX theKey;
00237 };
00238
00239
00241
00252 class PHashTable :
public PCollection
00253 {
00254
PCONTAINERINFO(
PHashTable,
PCollection);
00255
00256
public:
00259
00260
PHashTable();
00262
00274
virtual Comparison
Compare(
00275
const PObject & obj
00276 )
const;
00278
00279
00280
protected:
00290
virtual BOOL
SetSize(
00291 PINDEX newSize
00292 );
00294
00295
00306
PINLINE BOOL
AbstractContains(
00307
const PObject & key
00308 )
const;
00309
00324
virtual const PObject &
AbstractGetKeyAt(
00325 PINDEX index
00326 )
const;
00327
00342
virtual PObject &
AbstractGetDataAt(
00343 PINDEX index
00344 )
const;
00346
00347
00348
00349 class Element {
00350
public:
00351
friend class Table;
00352 PObject * key;
00353 PObject *
data;
00354 Element *
next;
00355 Element *
prev;
00356 };
00357
00358
PDECLARE_BASEARRAY(Table,
Element *)
00359 #ifdef DOC_PLUS_PLUS
00360 {
00361
#endif
00362
public:
00363
virtual ~Table() {
Destruct(); }
00364
virtual void DestroyContents();
00365
00366 PINDEX AppendElement(
PObject * key,
PObject * data);
00367
PObject * RemoveElement(
const PObject & key);
00368 BOOL SetLastElementAt(PINDEX index);
00369 Element * GetElementAt(
const PObject & key);
00370 PINDEX GetElementsIndex(
const PObject*obj,BOOL byVal,BOOL keys)
const;
00371
00372 PINDEX lastIndex;
00373 PINDEX lastBucket;
00374 Element * lastElement;
00375
00376 BOOL deleteKeys;
00377
00378
friend class PHashTable;
00379
friend class PAbstractSet;
00380 };
00381
friend class Table;
00382
00383
00384 Table *
hashTable;
00385 };
00386
00387
00389
00392 class PAbstractSet :
public PHashTable
00393 {
00394
PCONTAINERINFO(
PAbstractSet,
PHashTable);
00395
public:
00403
PINLINE PAbstractSet();
00405
00416
virtual PINDEX
Append(
00417
PObject * obj
00418 );
00419
00432
virtual PINDEX
Insert(
00433
const PObject & before,
00434
PObject * obj
00435 );
00436
00449
virtual PINDEX
InsertAt(
00450 PINDEX index,
00451
PObject * obj
00452 );
00453
00464
virtual BOOL
Remove(
00465
const PObject * obj
00466 );
00467
00474
virtual PObject *
RemoveAt(
00475 PINDEX index
00476 );
00477
00483
virtual PObject *
GetAt(
00484 PINDEX index
00485 )
const;
00486
00499
virtual BOOL
SetAt(
00500 PINDEX index,
00501
PObject * val
00502 );
00503
00515
virtual PINDEX
GetObjectsIndex(
00516
const PObject * obj
00517 )
const;
00518
00527
virtual PINDEX
GetValuesIndex(
00528
const PObject & obj
00529 )
const;
00531 };
00532
00533
00534
#ifdef PHAS_TEMPLATES
00535
00546
template <
class T>
class PSet :
public PAbstractSet
00547 {
00548
PCLASSINFO(PSet,
PAbstractSet);
00549
00550
public:
00560
inline PSet(BOOL initialDeleteObjects = FALSE)
00561 :
PAbstractSet() { AllowDeleteObjects(initialDeleteObjects); }
00563
00569
virtual PObject *
Clone()
const
00570
{
return PNEW PSet(0,
this); }
00572
00584
void Include(
00585
const T * obj
00586 ) { Append((
PObject *)obj); }
00587
00595 PSet & operator+=(
00596
const T & obj
00597 ) { Append(obj.Clone());
return *
this; }
00598
00606
void Exclude(
00607
const T * obj
00608 ) { Remove(obj); }
00609
00617 PSet & operator-=(
00618
const T & obj
00619 ) { RemoveAt(GetValuesIndex(obj));
return *
this; }
00620
00629 BOOL Contains(
00630
const T & key
00631 )
const {
return AbstractContains(key); }
00632
00641 BOOL operator[](
00642
const T & key
00643 )
const {
return AbstractContains(key); }
00644
00656
virtual const T & GetKeyAt(
00657 PINDEX index
00658 )
const
00659
{
return (
const T &)AbstractGetKeyAt(index); }
00661
00662
00663
protected:
00664 PSet(
int dummy,
const PSet * c)
00665 :
PAbstractSet(dummy, c)
00666 { reference->deleteObjects = c->reference->deleteObjects; }
00667 };
00668
00669
00681
#define PSET(cls, T) typedef PSet<T> cls
00682
00683
00695
#define PDECLARE_SET(cls, T, initDelObj) \
00696
PSET(cls##_PTemplate, T); \
00697
PDECLARE_CLASS(cls, cls##_PTemplate) \
00698
protected: \
00699
cls(int dummy, const cls * c) \
00700
: cls##_PTemplate(dummy, c) { } \
00701
public: \
00702
cls(BOOL initialDeleteObjects = initDelObj) \
00703
: cls##_PTemplate(initialDeleteObjects) { } \
00704
virtual PObject * Clone() const \
00705
{ return PNEW cls(0, this); } \
00706
00707
00708
#else // PHAS_TEMPLATES
00709
00710
00711 #define PSET(cls, K) \
00712
class cls : public PAbstractSet { \
00713
PCLASSINFO(cls, PAbstractSet); \
00714
protected: \
00715
inline cls(int dummy, const cls * c) \
00716
: PAbstractSet(dummy, c) \
00717
{ reference->deleteObjects = c->reference->deleteObjects; } \
00718
public: \
00719
inline cls(BOOL initialDeleteObjects = FALSE) \
00720
: PAbstractSet() { AllowDeleteObjects(initialDeleteObjects); } \
00721
virtual PObject * Clone() const \
00722
{ return PNEW cls(0, this); } \
00723
inline void Include(const PObject * key) \
00724
{ Append((PObject *)key); } \
00725
inline void Exclude(const PObject * key) \
00726
{ Remove(key); } \
00727
inline BOOL operator[](const K & key) const \
00728
{ return AbstractContains(key); } \
00729
inline BOOL Contains(const K & key) const \
00730
{ return AbstractContains(key); } \
00731
virtual const K & GetKeyAt(PINDEX index) const \
00732
{ return (const K &)AbstractGetKeyAt(index); } \
00733
}
00734
00735 #define PDECLARE_SET(cls, K, initDelObj) \
00736
PSET(cls##_PTemplate, K); \
00737
PDECLARE_CLASS(cls, cls##_PTemplate) \
00738
protected: \
00739
inline cls(int dummy, const cls * c) \
00740
: cls##_PTemplate(dummy, c) { } \
00741
public: \
00742
inline cls(BOOL initialDeleteObjects = initDelObj) \
00743
: cls##_PTemplate() { AllowDeleteObjects(initialDeleteObjects); } \
00744
virtual PObject * Clone() const \
00745
{ return PNEW cls(0, this); } \
00746
00747
00748
#endif // PHAS_TEMPLATES
00749
00750
00751
PSET(POrdinalSet,
POrdinalKey);
00752
00753
00755
00758 class PAbstractDictionary :
public PHashTable
00759 {
00760
PCLASSINFO(
PAbstractDictionary,
PHashTable);
00761
public:
00769
PINLINE PAbstractDictionary();
00771
00780
virtual void PrintOn(
00781 ostream &strm
00782 )
const;
00784
00795
virtual PINDEX
Insert(
00796
const PObject & key,
00797
PObject * obj
00798 );
00799
00806
virtual PINDEX
InsertAt(
00807 PINDEX index,
00808
PObject * obj
00809 );
00810
00820
virtual PObject *
RemoveAt(
00821 PINDEX index
00822 );
00823
00832
virtual BOOL
SetAt(
00833 PINDEX index,
00834
PObject * val
00835 );
00836
00844
virtual PObject *
GetAt(
00845 PINDEX index
00846 )
const;
00847
00859
virtual PINDEX
GetObjectsIndex(
00860
const PObject * obj
00861 )
const;
00862
00871
virtual PINDEX
GetValuesIndex(
00872
const PObject & obj
00873 )
const;
00875
00876
00887
virtual BOOL
SetDataAt(
00888 PINDEX index,
00889
PObject * obj
00890 );
00891
00903
virtual BOOL
AbstractSetAt(
00904
const PObject & key,
00905
PObject * obj
00906 );
00907
00917
virtual PObject &
GetRefAt(
00918
const PObject & key
00919 )
const;
00920
00927
virtual PObject *
AbstractGetAt(
00928
const PObject & key
00929 )
const;
00931
00932
protected:
00933
PINLINE PAbstractDictionary(
int dummy,
const PAbstractDictionary * c);
00934
00935
private:
00936
virtual PINDEX Append(
00937
PObject * obj
00938 );
00939
00940
00941
00942
00943
00944
00945
virtual BOOL Remove(
00946
const PObject * obj
00947 );
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958
00959 };
00960
00961
00962
#ifdef PHAS_TEMPLATES
00963
00971
template <
class K,
class D>
class PDictionary :
public PAbstractDictionary
00972 {
00973
PCLASSINFO(PDictionary,
PAbstractDictionary);
00974
00975
public:
00984 PDictionary()
00985 :
PAbstractDictionary() { }
00987
00994
virtual PObject *
Clone()
const
00995
{
return PNEW PDictionary(0,
this); }
00997
01010 D & operator[](
01011
const K & key
01012 )
const
01013
{
return (D &)GetRefAt(key); }
01014
01023 BOOL Contains(
01024
const K & key
01025 )
const {
return AbstractContains(key); }
01026
01035
virtual D * RemoveAt(
01036
const K & key
01037 ) { D * obj = GetAt(key); AbstractSetAt(key, NULL);
return obj; }
01038
01050
virtual BOOL SetAt(
01051
const K & key,
01052 D * obj
01053 ) {
return AbstractSetAt(key, obj); }
01054
01061
virtual D * GetAt(
01062
const K & key
01063 )
const {
return (D *)AbstractGetAt(key); }
01064
01076
const K & GetKeyAt(
01077 PINDEX index
01078 )
const
01079
{
return (
const K &)AbstractGetKeyAt(index); }
01080
01092 D & GetDataAt(
01093 PINDEX index
01094 )
const
01095
{
return (D &)AbstractGetDataAt(index); }
01097
01098
protected:
01099 PDictionary(
int dummy,
const PDictionary * c)
01100 :
PAbstractDictionary(dummy, c) { }
01101 };
01102
01103
01116
#define PDICTIONARY(cls, K, D) typedef PDictionary<K, D> cls
01117
01118
01131
#define PDECLARE_DICTIONARY(cls, K, D) \
01132
PDICTIONARY(cls##_PTemplate, K, D); \
01133
PDECLARE_CLASS(cls, cls##_PTemplate) \
01134
protected: \
01135
cls(int dummy, const cls * c) \
01136
: cls##_PTemplate(dummy, c) { } \
01137
public: \
01138
cls() \
01139
: cls##_PTemplate() { } \
01140
virtual PObject * Clone() const \
01141
{ return PNEW cls(0, this); } \
01142
01143
01151
template <
class K>
class POrdinalDictionary :
public PAbstractDictionary
01152 {
01153
PCLASSINFO(POrdinalDictionary,
PAbstractDictionary);
01154
01155
public:
01164 POrdinalDictionary()
01165 :
PAbstractDictionary() { }
01167
01174
virtual PObject *
Clone()
const
01175
{
return PNEW POrdinalDictionary(0,
this); }
01177
01190 PINDEX operator[](
01191
const K & key
01192 )
const
01193
{
return (
POrdinalKey &)GetRefAt(key); }
01194
01203 BOOL Contains(
01204
const K & key
01205 )
const {
return AbstractContains(key); }
01206
01207
virtual POrdinalKey * GetAt(
01208
const K & key
01209 )
const {
return (
POrdinalKey *)AbstractGetAt(key); }
01210
01211
01212
01213
01214
01215
01216
01225
virtual BOOL SetDataAt(
01226 PINDEX index,
01227 PINDEX ordinal
01228 ) {
return PAbstractDictionary::SetDataAt(index, PNEW
POrdinalKey(ordinal)); }
01229
01241
virtual BOOL SetAt(
01242
const K & key,
01243 PINDEX ordinal
01244 ) {
return AbstractSetAt(key, PNEW
POrdinalKey(ordinal)); }
01245
01254
virtual PINDEX RemoveAt(
01255
const K & key
01256 ) { PINDEX ord = *GetAt(key); AbstractSetAt(key, NULL);
return ord; }
01257
01269
const K & GetKeyAt(
01270 PINDEX index
01271 )
const
01272
{
return (
const K &)AbstractGetKeyAt(index); }
01273
01285 PINDEX GetDataAt(
01286 PINDEX index
01287 )
const
01288
{
return (
POrdinalKey &)AbstractGetDataAt(index); }
01290
01291
protected:
01292 POrdinalDictionary(
int dummy,
const POrdinalDictionary * c)
01293 :
PAbstractDictionary(dummy, c) { }
01294 };
01295
01296
01309
#define PORDINAL_DICTIONARY(cls, K) typedef POrdinalDictionary<K> cls
01310
01311
01326
#define PDECLARE_ORDINAL_DICTIONARY(cls, K) \
01327
PORDINAL_DICTIONARY(cls##_PTemplate, K); \
01328
PDECLARE_CLASS(cls, POrdinalDictionary<K>) \
01329
protected: \
01330
cls(int dummy, const cls * c) \
01331
: cls##_PTemplate(dummy, c) { } \
01332
public: \
01333
cls() \
01334
: cls##_PTemplate() { } \
01335
virtual PObject * Clone() const \
01336
{ return PNEW cls(0, this); } \
01337
01338
01339
#else // PHAS_TEMPLATES
01340
01341
01342 #define PDICTIONARY(cls, K, D) \
01343
class cls : public PAbstractDictionary { \
01344
PCLASSINFO(cls, PAbstractDictionary); \
01345
protected: \
01346
inline cls(int dummy, const cls * c) \
01347
: PAbstractDictionary(dummy, c) { } \
01348
public: \
01349
cls() \
01350
: PAbstractDictionary() { } \
01351
virtual PObject * Clone() const \
01352
{ return PNEW cls(0, this); } \
01353
D & operator[](const K & key) const \
01354
{ return (D &)GetRefAt(key); } \
01355
virtual BOOL Contains(const K & key) const \
01356
{ return AbstractContains(key); } \
01357
virtual D * RemoveAt(const K & key) \
01358
{ D * obj = GetAt(key); AbstractSetAt(key, NULL); return obj; } \
01359
virtual BOOL SetAt(const K & key, D * obj) \
01360
{ return AbstractSetAt(key, obj); } \
01361
virtual D * GetAt(const K & key) const \
01362
{ return (D *)AbstractGetAt(key); } \
01363
const K & GetKeyAt(PINDEX index) const \
01364
{ return (const K &)AbstractGetKeyAt(index); } \
01365
D & GetDataAt(PINDEX index) const \
01366
{ return (D &)AbstractGetDataAt(index); } \
01367
}
01368
01369 #define PDECLARE_DICTIONARY(cls, K, D) \
01370
PDICTIONARY(cls##_PTemplate, K, D); \
01371
PDECLARE_CLASS(cls, cls##_PTemplate) \
01372
protected: \
01373
cls(int dummy, const cls * c) \
01374
: cls##_PTemplate(dummy, c) { } \
01375
public: \
01376
cls() \
01377
: cls##_PTemplate() { } \
01378
virtual PObject * Clone() const \
01379
{ return PNEW cls(0, this); } \
01380
01381
01382 #define PORDINAL_DICTIONARY(cls, K) \
01383
class cls : public PAbstractDictionary { \
01384
PCLASSINFO(cls, PAbstractDictionary); \
01385
protected: \
01386
inline cls(int dummy, const cls * c) \
01387
: PAbstractDictionary(dummy, c) { } \
01388
public: \
01389
inline cls() \
01390
: PAbstractDictionary() { } \
01391
virtual PObject * Clone() const \
01392
{ return PNEW cls(0, this); } \
01393
inline PINDEX operator[](const K & key) const \
01394
{ return (POrdinalKey &)GetRefAt(key); } \
01395
virtual BOOL Contains(const K & key) const \
01396
{ return AbstractContains(key); } \
01397
virtual POrdinalKey * GetAt(const K & key) const \
01398
{ return (POrdinalKey *)AbstractGetAt(key); } \
01399
virtual BOOL SetDataAt(PINDEX index, PINDEX ordinal) \
01400
{ return PAbstractDictionary::SetDataAt(index, PNEW POrdinalKey(ordinal)); } \
01401
virtual BOOL SetAt(const K & key, PINDEX ordinal) \
01402
{ return AbstractSetAt(key, PNEW POrdinalKey(ordinal)); } \
01403
virtual PINDEX RemoveAt(const K & key) \
01404
{ PINDEX ord = *GetAt(key); AbstractSetAt(key, NULL); return ord; } \
01405
inline const K & GetKeyAt(PINDEX index) const \
01406
{ return (const K &)AbstractGetKeyAt(index); } \
01407
inline PINDEX GetDataAt(PINDEX index) const \
01408
{ return (POrdinalKey &)AbstractGetDataAt(index); } \
01409
}
01410
01411 #define PDECLARE_ORDINAL_DICTIONARY(cls, K) \
01412
PORDINAL_DICTIONARY(cls##_PTemplate, K); \
01413
PDECLARE_CLASS(cls, cls##_PTemplate) \
01414
protected: \
01415
cls(int dummy, const cls * c) \
01416
: cls##_PTemplate(dummy, c) { } \
01417
public: \
01418
cls() \
01419
: cls##_PTemplate() { } \
01420
virtual PObject * Clone() const \
01421
{ return PNEW cls(0, this); } \
01422
01423
01424
#endif // PHAS_TEMPLATES
01425
01426