contain.h File Reference
`#include <ptlib/critsec.h>`
`#include <ptlib/object.h>`
`#include <ptlib/array.h>`
`#include <ptlib/lists.h>`
`#include <ptlib/dict.h>`
`#include <ptlib/pstring.h>`

Go to the source code of this file.

## Classes

class | PContainerReference
class | PContainer
| Abstract class to embody the base functionality of a `container`. More...
class | PCollection
| A collection is a container that collects together descendents of the `PObject` class. More...

## Macros

#define | PCONTAINERINFO(cls, par)
| Macro to declare funtions required in a container. More...

## Macro Definition Documentation

#define PCONTAINERINFO | ( |  | cls,
|  |  | par
| ) |  |

Value:
PCLASSINFO(cls, par) \
public: \
cls(const cls & c) : par(c) { CopyContents(c); } \
cls & operator=(const cls & c) \
{ AssignContents(c); return *this; } \
virtual ~cls() { Destruct(); } \
virtual PBoolean MakeUnique() \
{ if(par::MakeUnique())return true; CloneContents(this);return false; } \
protected: \
cls(int dummy, const cls * c) : par(dummy, c) { CloneContents(c); } \
virtual void DestroyContents(); \
void CloneContents(const cls * c); \
void CopyContents(const cls & c); \
virtual void AssignContents(const PContainer & c) \
{ par::AssignContents(c); CopyContents((const cls &)c); }
PCLASSINFO
#define PCLASSINFO(cls, par)
Declare all the standard PTLib class information.
Definition: object.h:1049
PBoolean
BOOL PBoolean
Definition: object.h:102
PContainer
Abstract class to embody the base functionality of a container.
Definition: contain.h:104

Macro to declare funtions required in a container.

This macro is used to declare all the functions that should be implemented for a working container class. It will also define some inline code for some standard function behaviour.

This may be used when multiple inheritance requires a special class declaration. Normally, the `PCONTAINERINFO` macro would be used, which includes this macro in it.

The default implementation for contructors, destructor, the assignment operator and the MakeUnique() function is as follows:

            cls(const cls & c)
              : par(c)
            {
              CopyContents(c);
            }

            cls & operator=(const cls & c)
            {
              par::operator=(c);
              return *this;
            }

            cls(int dummy, const cls * c)
              : par(dummy, c)
            {
              CloneContents(c);
            }

            virtual ~cls()
            {
              Destruct();
            }

            PBoolean MakeUnique()
            {
              if (par::MakeUnique())
                return true;
              CloneContents(c);
              return false;
            }

Then the `DestroyContents()`, `CloneContents()` and `CopyContents()` functions are declared and must be implemented by the programmer. See the `PContainer` class for more information on these functions.