array.h

Go to the documentation of this file.

/*
 * array.h
 *
 * Linear Array Container classes.
 *
 * Portable Windows Library
 *
 * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
 * All Rights Reserved.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 19008 $
 * $Author: rjongbloed $
 * $Date: 2007-11-29 09:17:41 +0000 (Thu, 29 Nov 2007) $
 */

#ifndef _ARRAY_H_
#define _ARRAY_H_

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <ptlib/contain.h>

// The abstract array class

class PAbstractArray : public PContainer
{
  PCONTAINERINFO(PAbstractArray, PContainer);

  public:
    PAbstractArray(
      PINDEX elementSizeInBytes,  

      PINDEX initialSize = 0      
    );

    PAbstractArray(
      PINDEX elementSizeInBytes,   

      const void *buffer,          
      PINDEX bufferSizeInElements, 
      PBoolean dynamicAllocation       
    );

    virtual void PrintOn(
      ostream &strm   // Stream to print the object into.
    ) const;

    virtual void ReadFrom(
      istream &strm   // Stream to read the objects contents from.
    );

    virtual Comparison Compare(
      const PObject & obj   
    ) const;

    virtual PBoolean SetSize(
      PINDEX newSize  
    );

    void Attach(
      const void *buffer, 
      PINDEX bufferSize   
    );

    void * GetPointer(
      PINDEX minSize = 1  
    );

    PBoolean Concatenate(
      const PAbstractArray & array  
    );

  protected:
    PBoolean InternalSetSize(PINDEX newSize, PBoolean force);

    virtual void PrintElementOn(
      ostream & stream,
      PINDEX index
    ) const;
    virtual void ReadElementFrom(
      istream & stream,
      PINDEX index
    );

    PINDEX elementSize;

    char * theArray;

    PBoolean allocatedDynamically;

  friend class PArrayObjects;
};


// An array of some base type

#ifdef PHAS_TEMPLATES

template <class T> class PBaseArray : public PAbstractArray
{
  PCLASSINFO(PBaseArray, PAbstractArray);

  public:
    PBaseArray(
      PINDEX initialSize = 0  
    ) : PAbstractArray(sizeof(T), initialSize) { }
    
    PBaseArray(
      T const * buffer,   
      PINDEX length,      
      PBoolean dynamic = PTrue 
    ) : PAbstractArray(sizeof(T), buffer, length, dynamic) { }

    virtual PObject * Clone() const
    { 
      return PNEW PBaseArray<T>(*this, GetSize());
    }

    PBoolean SetAt(
      PINDEX index,   
      T val           
    ) {
      return SetMinSize(index+1) && val==(((T *)theArray)[index] = val);
    }

    T GetAt(
      PINDEX index  
    ) const {
      PASSERTINDEX(index);
      return index < GetSize() ? ((T *)theArray)[index] : (T)0;
    }

    void Attach(
      const T * buffer,   
      PINDEX bufferSize   
    ) {
      PAbstractArray::Attach(buffer, bufferSize);
    }

    T * GetPointer(
      PINDEX minSize = 0    
    ) {
      return (T *)PAbstractArray::GetPointer(minSize);
    }

    T operator[](
      PINDEX index  
    ) const {
      return GetAt(index);
    }

    T & operator[](
      PINDEX index  
    ) {
      PASSERTINDEX(index);
      PAssert(SetMinSize(index+1), POutOfMemory);
      return ((T *)theArray)[index];
    }

    operator T const *() const {
      return (T const *)theArray;
    }

    PBoolean Concatenate(
      const PBaseArray & array  
    ) {
      return PAbstractArray::Concatenate(array);
    }

  protected:
    virtual void PrintElementOn(
      ostream & stream,
      PINDEX index
    ) const {
      stream << GetAt(index);
    }
};

/*Declare a dynamic array base type.
   This macro is used to declare a descendent of PAbstractArray class,
   customised for a particular element type {\bf 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 #PBaseArray# template class.
 */
#define PBASEARRAY(cls, T) typedef PBaseArray<T> cls

#define PDECLARE_BASEARRAY(cls, T) \
  PDECLARE_CLASS(cls, PBaseArray<T>) \
    cls(PINDEX initialSize = 0) \
      : PBaseArray<T>(initialSize) { } \
    cls(T const * buffer, PINDEX length, PBoolean dynamic = PTrue) \
      : PBaseArray<T>(buffer, length, dynamic) { } \
    virtual PObject * Clone() const \
      { return PNEW cls(*this, GetSize()); } \


template <class T> class PScalarArray : public PBaseArray<T>
{
  public:
    PScalarArray(
      PINDEX initialSize = 0  
    ) : PBaseArray<T>(initialSize) { }
    
    PScalarArray(
      T const * buffer,   
      PINDEX length,      
      PBoolean dynamic = PTrue 
    ) : PBaseArray<T>(buffer, length, dynamic) { }

  protected:
    virtual void ReadElementFrom(
      istream & stream,
      PINDEX index
    ) {
      T t;
      stream >> t;
      if (!stream.fail())
        SetAt(index, t);
    }
};


/*Declare a dynamic array base type.
   This macro is used to declare a descendent of PAbstractArray class,
   customised for a particular element type {\bf 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 #PBaseArray# template class.
 */
#define PSCALAR_ARRAY(cls, T) typedef PScalarArray<T> cls

#else // PHAS_TEMPLATES

#define PBASEARRAY(cls, T) \
  typedef T P_##cls##_Base_Type; \
  class cls : public PAbstractArray { \
    PCLASSINFO(cls, PAbstractArray) \
  public: \
    inline cls(PINDEX initialSize = 0) \
      : PAbstractArray(sizeof(P_##cls##_Base_Type), initialSize) { } \
    inline cls(P_##cls##_Base_Type const * buffer, PINDEX length, PBoolean dynamic = PTrue) \
      : PAbstractArray(sizeof(P_##cls##_Base_Type), buffer, length, dynamic) { } \
    virtual PObject * Clone() const \
      { return PNEW cls(*this, GetSize()); } \
    inline PBoolean SetAt(PINDEX index, P_##cls##_Base_Type val) \
      { return SetMinSize(index+1) && \
                     val==(((P_##cls##_Base_Type *)theArray)[index] = val); } \
    inline P_##cls##_Base_Type GetAt(PINDEX index) const \
      { PASSERTINDEX(index); return index < GetSize() ? \
          ((P_##cls##_Base_Type*)theArray)[index] : (P_##cls##_Base_Type)0; } \
    inline P_##cls##_Base_Type operator[](PINDEX index) const \
      { PASSERTINDEX(index); return GetAt(index); } \
    inline P_##cls##_Base_Type & operator[](PINDEX index) \
      { PASSERTINDEX(index); PAssert(SetMinSize(index+1), POutOfMemory); \
        return ((P_##cls##_Base_Type *)theArray)[index]; } \
    inline void Attach(const P_##cls##_Base_Type * buffer, PINDEX bufferSize) \
      { PAbstractArray::Attach(buffer, bufferSize); } \
    inline P_##cls##_Base_Type * GetPointer(PINDEX minSize = 0) \
      { return (P_##cls##_Base_Type *)PAbstractArray::GetPointer(minSize); } \
    inline operator P_##cls##_Base_Type const *() const \
      { return (P_##cls##_Base_Type const *)theArray; } \
    inline PBoolean Concatenate(cls const & array) \
      { return PAbstractArray::Concatenate(array); } \
  }

#define PDECLARE_BASEARRAY(cls, T) \
  PBASEARRAY(cls##_PTemplate, T); \
  PDECLARE_CLASS(cls, cls##_PTemplate) \
    cls(PINDEX initialSize = 0) \
      : cls##_PTemplate(initialSize) { } \
    cls(T const * buffer, PINDEX length, PBoolean dynamic = PTrue) \
      : cls##_PTemplate(buffer, length, dynamic) { } \
    virtual PObject * Clone() const \
      { return PNEW cls(*this, GetSize()); } \

#define PSCALAR_ARRAY(cls, T) PBASEARRAY(cls, T)

#endif // PHAS_TEMPLATES


#ifdef DOC_PLUS_PLUS
class PCharArray : public PBaseArray {
  public:
    PCharArray(
      PINDEX initialSize = 0  
    );

    PCharArray(
      char const * buffer,   
      PINDEX length,      
      PBoolean dynamic = PTrue 
    );
#endif
PDECLARE_BASEARRAY(PCharArray, char);
  public:

    virtual void PrintOn(
      ostream & strm 
    ) const;
    virtual void ReadFrom(
      istream &strm   // Stream to read the objects contents from.
    );
};

#ifdef DOC_PLUS_PLUS
class PShortArray : public PBaseArray {
  public:
    PShortArray(
      PINDEX initialSize = 0  
    );

    PShortArray(
      short const * buffer,   
      PINDEX length,      
      PBoolean dynamic = PTrue 
    );
};
#endif
PSCALAR_ARRAY(PShortArray, short);


#ifdef DOC_PLUS_PLUS
class PIntArray : public PBaseArray {
  public:
    PIntArray(
      PINDEX initialSize = 0  
    );

    PIntArray(
      int const * buffer,   
      PINDEX length,      
      PBoolean dynamic = PTrue 
    );
};
#endif
PSCALAR_ARRAY(PIntArray, int);


#ifdef DOC_PLUS_PLUS
class PLongArray : public PBaseArray {
  public:
    PLongArray(
      PINDEX initialSize = 0  
    );

    PLongArray(
      long const * buffer,   
      PINDEX length,      
      PBoolean dynamic = PTrue 
    );
};
#endif
PSCALAR_ARRAY(PLongArray, long);


#ifdef DOC_PLUS_PLUS
class PBYTEArray : public PBaseArray {
  public:
    PBYTEArray(
      PINDEX initialSize = 0  
    );

    PBYTEArray(
      BYTE const * buffer,   
      PINDEX length,      
      PBoolean dynamic = PTrue 
    );
};
#endif
PDECLARE_BASEARRAY(PBYTEArray, BYTE);
  public:

    virtual void PrintOn(
      ostream & strm 
    ) const;
    virtual void ReadFrom(
      istream &strm   
    );
};


#ifdef DOC_PLUS_PLUS
class PWORDArray : public PBaseArray {
  public:
    PWORDArray(
      PINDEX initialSize = 0  
    );

    PWORDArray(
      WORD const * buffer,   
      PINDEX length,      
      PBoolean dynamic = PTrue 
    );
};
#endif
PSCALAR_ARRAY(PWORDArray, WORD);


#ifdef DOC_PLUS_PLUS
class PUnsignedArray : public PBaseArray {
  public:
    PUnsignedArray(
      PINDEX initialSize = 0  
    );

    PUnsignedArray(
      unsigned const * buffer,   
      PINDEX length,      
      PBoolean dynamic = PTrue 
    );
};
#endif
PSCALAR_ARRAY(PUnsignedArray, unsigned);


#ifdef DOC_PLUS_PLUS
class PDWORDArray : public PBaseArray {
  public:
    PDWORDArray(
      PINDEX initialSize = 0  
    );

    PDWORDArray(
      DWORD const * buffer,   
      PINDEX length,      
      PBoolean dynamic = PTrue 
    );
#endif
PSCALAR_ARRAY(PDWORDArray, DWORD);


// Linear array of objects

class PArrayObjects : public PCollection
{
  PCONTAINERINFO(PArrayObjects, PCollection);

  public:
    PINLINE PArrayObjects(
      PINDEX initialSize = 0  
    );

    virtual Comparison Compare(
      const PObject & obj   
    ) const;


    virtual PINDEX GetSize() const;

    virtual PBoolean SetSize(
      PINDEX newSize  
    );

    virtual PINDEX Append(
      PObject * obj   
    );

    virtual PINDEX Insert(
      const PObject & before,   
      PObject * obj             
    );

    virtual PINDEX InsertAt(
      PINDEX index,   
      PObject * obj   
    );

    virtual PBoolean Remove(
      const PObject * obj   
    );

    virtual PObject * RemoveAt(
      PINDEX index   
    );

    virtual PBoolean SetAt(
      PINDEX index,   
      PObject * val   
    );

    virtual PObject * GetAt(
      PINDEX index  
    ) const;

    virtual PINDEX GetObjectsIndex(
      const PObject * obj  
    ) const;

    virtual PINDEX GetValuesIndex(
      const PObject & obj   // Object to find equal of.
    ) const;

    virtual void RemoveAll();

  protected:
    PBASEARRAY(ObjPtrArray, PObject *);
    // The type below cannot be nested as DevStudio 2005 AUTOEXP.DAT doesn't like it
    PBaseArray<PObject *> * theArray;
};


#ifdef PHAS_TEMPLATES

template <class T> class PArray : public PArrayObjects
{
  PCLASSINFO(PArray, PArrayObjects);

  public:
    PArray( 
      PINDEX initialSize = 0  
    ) : PArrayObjects(initialSize) { }

    virtual PObject * Clone() const
      { return PNEW PArray(0, this); }

    T & operator[](
      PINDEX index  
    ) const {
      PObject * obj = GetAt(index);
      PAssert(obj != NULL, PInvalidArrayElement);
      return (T &)*obj;
    }

  protected:
    PArray(int dummy, const PArray * c) : PArrayObjects(dummy, c) { }
};


#define PARRAY(cls, T) typedef PArray<T> cls


#define PDECLARE_ARRAY(cls, T) \
  PARRAY(cls##_PTemplate, T); \
  PDECLARE_CLASS(cls, cls##_PTemplate) \
  protected: \
    inline cls(int dummy, const cls * c) \
      : cls##_PTemplate(dummy, c) { } \
  public: \
    inline cls(PINDEX initialSize = 0) \
      : cls##_PTemplate(initialSize) { } \
    virtual PObject * Clone() const \
      { return PNEW cls(0, this); } \

#else // PHAS_TEMPLATES


#define PARRAY(cls, T) \
  class cls : public PArrayObjects { \
  PCLASSINFO(cls, PArrayObjects); \
  protected: \
    inline cls(int dummy, const cls * c) \
      : PArrayObjects(dummy, c) { } \
  public: \
    inline cls(PINDEX initialSize = 0) \
      : PArrayObjects(initialSize) { } \
    virtual PObject * Clone() const \
      { return PNEW cls(0, this); } \
    inline T & operator[](PINDEX index) const\
      { PObject * obj = GetAt(index); \
        PAssert(obj != NULL, PInvalidArrayElement); \
        /* want to do to this, but gcc 3.0 complains --> return *(T *)obj; } */ \
        return (T &)*obj; } \
  }

#define PDECLARE_ARRAY(cls, T) \
  PARRAY(cls##_PTemplate, T); \
  PDECLARE_CLASS(cls, cls##_PTemplate) \
  protected: \
    inline cls(int dummy, const cls * c) \
      : cls##_PTemplate(dummy, c) { } \
  public: \
    inline cls(PINDEX initialSize = 0) \
      : cls##_PTemplate(initialSize) { } \
    virtual PObject * Clone() const \
      { return PNEW cls(0, this); } \

#endif // PHAS_TEMPLATES


class PBitArray : public PBYTEArray
{
  PCLASSINFO(PBitArray, PBYTEArray);

  public:
    PBitArray(
      PINDEX initialSize = 0  
    );
    
    PBitArray(
      const void * buffer,   
      PINDEX length,         
      PBoolean dynamic = PTrue    
    );

    virtual PObject * Clone() const;

    virtual PINDEX GetSize() const;

    virtual PBoolean SetSize(
      PINDEX newSize  
    );

    PBoolean SetAt(
      PINDEX index,   
      PBoolean val           
    );

    PBoolean GetAt(
      PINDEX index  
    ) const;

    void Attach(
      const void * buffer,   
      PINDEX bufferSize      
    );

    BYTE * GetPointer(
      PINDEX minSize = 0    
    );

    PBoolean operator[](
      PINDEX index  
    ) const { return GetAt(index); }

    PBitArray & operator+=(
      PINDEX index  
    ) { SetAt(index, PTrue); return *this; }

    PBitArray & operator-=(
      PINDEX index  
    ) { SetAt(index, PFalse); return *this; }

    PBoolean Concatenate(
      const PBitArray & array  
    );
};


#endif
// End Of File ///////////////////////////////////////////////////////////////

---