# dict.h File Reference

`#include <ptlib/array.h>`

Go to the source code of this file.

## Classes

class | POrdinalKey
| This class is used when an ordinal index value is the key for `PSet` and `PDictionary` classes. More...
struct | PHashTableElement
class | PHashTable
| The hash table class is the basis for implementing the `PSet` and `PDictionary` classes. More...
class | PAbstractSet
| Abstract set of PObjects. More...
class | PSet< T >
| This template class maps the `PAbstractSet` to a specific object type. More...
class | PAbstractDictionary
| An abstract dictionary container. More...
class | PDictionary< K, D >
| This template class maps the `PAbstractDictionary` to a specific key and data types. More...
class | POrdinalDictionary< K >
| This template class maps the `PAbstractDictionary` to a specific key type and a `POrdinalKey` data type. More...

## Defines

#define | PSET(cls, T) typedef PSet<T> cls
| Declare set class.
#define | PDECLARE_SET(cls, T, initDelObj)
| Begin declaration of a set class.
#define | PDICTIONARY(cls, K, D) typedef PDictionary<K, D> cls
| Declare a dictionary class.
#define | PDECLARE_DICTIONARY(cls, K, D)
| Begin declaration of dictionary class.
#define | PORDINAL_DICTIONARY(cls, K) typedef POrdinalDictionary<K> cls
| Declare an ordinal dictionary class.
#define | PDECLARE_ORDINAL_DICTIONARY(cls, K)
| Begin declaration of an ordinal dictionary class.

## Define Documentation

#define PDECLARE_DICTIONARY | ( | cls,
|  | K,
|  | D |  | ) |

Value:

    PDICTIONARY(cls##_PTemplate, K, D); \
      PDECLARE_CLASS(cls, cls##_PTemplate) \
      protected: \
        cls(int dummy, const cls * c) \
          : cls##_PTemplate(dummy, c) { } \
      public: \
        cls() \
          : cls##_PTemplate() { } \
        virtual PObject * Clone() const \
          { return PNEW cls(0, this); } \

Begin declaration of dictionary class.

This macro is used to declare a descendent of PAbstractDictionary class, customised for a particular key type K and data object type D.

If the compilation is using templates then this macro produces a descendent of the `PDictionary` template class. If templates are not being used then the macro defines a set of inline functions to do all casting of types. The resultant classes have an identical set of functions in either case.

See the `PDictionary` and `PAbstractDictionary` classes for more information.

#define PDECLARE_ORDINAL_DICTIONARY | ( | cls,
|  | K |  | ) |

Value:

    PORDINAL_DICTIONARY(cls##_PTemplate, K); \
      PDECLARE_CLASS(cls, POrdinalDictionary<K>) \
      protected: \
        cls(int dummy, const cls * c) \
          : cls##_PTemplate(dummy, c) { } \
      public: \
        cls() \
          : cls##_PTemplate() { } \
        virtual PObject * Clone() const \
          { return PNEW cls(0, this); } \

Begin declaration of an ordinal dictionary class.

This macro is used to declare a descendent of PAbstractList class, customised for a particular key type K and data object type of `POrdinalKey`.

If the compilation is using templates then this macro produces a descendent of the `POrdinalDictionary` template class. If templates are not being used then the macro defines a set of inline functions to do all casting of types. The resultant classes have an identical set of functions in either case.

See the `POrdinalDictionary` and `PAbstractDictionary` classes for more information.

#define PDECLARE_SET | ( | cls,
|  | T,
|  | initDelObj |  | ) |

Value:

    class cls : public PSet<T> { \
        typedef PSet<T> BaseClass; PCLASSINFO(cls, BaseClass) \
      protected: \
        cls(int dummy, const cls * c) \
          : BaseClass(dummy, c) { } \
      public: \
        cls(PBoolean initialDeleteObjects = initDelObj) \
          : BaseClass(initialDeleteObjects) { } \
        virtual PObject * Clone() const \
          { return PNEW cls(0, this); } \

Begin declaration of a set class.

This macro is used to declare a descendent of `PAbstractSet` class, customised for a particular object type T.

If the compilation is using templates then this macro produces a descendent of the `PSet` template class. If templates are not being used then the macro defines a set of inline functions to do all casting of types. The resultant classes have an identical set of functions in either case.

See the `PSet` and `PAbstractSet` classes for more information.

#define PDICTIONARY | ( | cls,
|  | K,
|  | D |  | ) | typedef PDictionary<K, D> cls

Declare a dictionary class.

This macro is used to declare a descendent of PAbstractDictionary class, customised for a particular key type K and data object type D. This macro closes the class declaration off so no additional members can be added.

If the compilation is using templates then this macro produces a typedef of the `PDictionary` template class.

See the `PDictionary` class and `PDECLARE_DICTIONARY` macro for more information.

#define PORDINAL_DICTIONARY | ( | cls,
|  | K |  | ) | typedef POrdinalDictionary<K> cls

Declare an ordinal dictionary class.

This macro is used to declare a descendent of PAbstractDictionary class, customised for a particular key type K and data object type of `POrdinalKey`. This macro closes the class declaration off so no additional members can be added.

If the compilation is using templates then this macro produces a typedef of the `POrdinalDictionary` template class.

See the `POrdinalDictionary` class and `PDECLARE_ORDINAL_DICTIONARY` macro for more information.

#define PSET | ( | cls,
|  | T |  | ) | typedef PSet<T> cls

Declare set class.

This macro is used to declare a descendent of `PAbstractSet` class, customised for a particular object type T. This macro closes the class declaration off so no additional members can be added.

If the compilation is using templates then this macro produces a typedef of the `PSet` template class.

See the `PSet` class and `PDECLARE_SET` macro for more information.