# lists.h File Reference

Go to the source code of this file.

## Classes

struct | PListElement
struct | PListInfo
class | PAbstractList
| This class is a collection of objects which are descendents of the `PObject` class. More...
class | PList< T >
| This template class maps the PAbstractList to a specific object type. More...
class | PList< T >::iterator_base
class | PList< T >::iterator
class | PList< T >::const_iterator
class | PQueue< T >
| This template class maps the PAbstractList to a specific object type, and adds functionality that allows the list to be used as a first in first out queue. More...
class | PStack< T >
| This template class maps the PAbstractList to a specific object type, and adds functionality that allows the list to be used as a last in first out stack. More...
struct | PSortedListElement
struct | PSortedListInfo
class | PAbstractSortedList
| This class is a collection of objects which are descendents of the `PObject` class. More...
class | PSortedList< T >
| This template class maps the PAbstractSortedList to a specific object type. More...

## Defines

#define | PLIST(cls, T) typedef PList<T> cls
| Declare a list class.
#define | PDECLARE_LIST(cls, T)
| Begin declaration of list class.
#define | PQUEUE(cls, T) typedef PQueue<T> cls
| Declare a queue class.
#define | PDECLARE_QUEUE(cls, T)
| Begin declataion of a queue class.
#define | PSTACK(cls, T) typedef PStack<T> cls
| Declare a stack class.
#define | PDECLARE_STACK(cls, T)
| Begin declaration of a stack class.
#define | PSORTED_LIST(cls, T) typedef PSortedList<T> cls
| Declare a sorted list class.
#define | PDECLARE_SORTED_LIST(cls, T)
| Begin declaration of a sorted list class.

## Define Documentation

#define PDECLARE_LIST | ( | cls,
|  | T |  | ) |

Value:

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

Begin declaration of list class.

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

If the compilation is using templates then this macro produces a descendent of the `PList` 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 `PList` and `PAbstractList` classes for more information.

#define PDECLARE_QUEUE | ( | cls,
|  | T |  | ) |

Value:

    PQUEUE(cls##_PTemplate, T); \
      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 declataion of a queue class.

This macro is used to declare a descendent of PAbstractList class, customised for a particular object type T, and adds functionality that allows the list to be used as a first in first out queue.

If the compilation is using templates then this macro produces a descendent of the `PQueue` 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 `PQueue` and `PAbstractList` classes for more information.

#define PDECLARE_SORTED_LIST | ( | cls,
|  | T |  | ) |

Value:

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

Begin declaration of a sorted list class.

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

If the compilation is using templates then this macro produces a descendent of the `PSortedList` 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 `PSortedList` and `PAbstractSortedList` classes for more information.

#define PDECLARE_STACK | ( | cls,
|  | T |  | ) |

Value:

    PSTACK(cls##_PTemplate, T); \
      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 a stack class.

This macro is used to declare a descendent of PAbstractList class, customised for a particular object type T, and adds functionality that allows the list to be used as a last in first out stack.

If the compilation is using templates then this macro produces a descendent of the `PStack` 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 `PStack` and `PAbstractList` classes for more information.

#define PLIST | ( | cls,
|  | T |  | ) | typedef PList<T> cls

Declare a list class.

This macro is used to declare a descendent of PAbstractList 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 `PList` template class.

See the `PList` class and `PDECLARE_LIST` macro for more information.

#define PQUEUE | ( | cls,
|  | T |  | ) | typedef PQueue<T> cls

Declare a queue class.

This macro is used to declare a descendent of PAbstractList class, customised for a particular object type T, and adds functionality that allows the list to be used as a first in first out queue. 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 `PQueue` template class.

See the `PList` class and `PDECLARE_QUEUE` macro for more information.

#define PSORTED_LIST | ( | cls,
|  | T |  | ) | typedef PSortedList<T> cls

Declare a sorted list class.

This macro is used to declare a descendent of PAbstractSortedList 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 `PSortedList` template class.

See the `PSortedList` class and `PDECLARE_SORTED_LIST` macro for more information.

#define PSTACK | ( | cls,
|  | T |  | ) | typedef PStack<T> cls

Declare a stack class.

This macro is used to declare a descendent of PAbstractList class, customised for a particular object type T, and adds functionality that allows the list to be used as a last in first out stack. 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 `PStack` template class.

See the `PStack` class and `PDECLARE_STACK` macro for more information.