array.h

Go to the documentation of this file.

/*
 * array.h
 *
 * Linear Array Container classes.
 *
 * Portable Tools 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): ______________________________________.
 */

#ifndef PTLIB_ARRAY_H
#define PTLIB_ARRAY_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <vector>

#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  
    );
    const void * GetPointer() const { return theArray; }

    virtual PINDEX GetLength() const;

    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
    );

    PAbstractArray(
      PContainerReference & reference,
      PINDEX elementSizeInBytes
    );

    PINDEX elementSize;

    char * theArray;

    PBoolean allocatedDynamically;

  friend class PArrayObjects;
};


// An array of some base type

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 = true 
    ) : 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() ? (reinterpret_cast<T *>(theArray))[index] : T();
    }

    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);
    }

    PBaseArray(PContainerReference & reference_) : PAbstractArray(reference_, sizeof(T)) { }
};

#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(PContainerReference & reference_) \
      : PBaseArray<T>(reference_) { } \
    cls(T const * buffer, PINDEX length, PBoolean dynamic = true) \
      : 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 = true 
    ) : PBaseArray<T>(buffer, length, dynamic) { }

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


#define PSCALAR_ARRAY(cls, T) typedef PScalarArray<T> cls


class PCharArray : public PBaseArray<char>
{
    typedef PBaseArray<char> ParentClass;
    PCLASSINFO(PCharArray, ParentClass);
  public:
    PCharArray(
      PINDEX initialSize = 0  
    ) : ParentClass(initialSize) { }

    PCharArray(
      char const * buffer,   
      PINDEX length,      
      PBoolean dynamic = true 
    ) : ParentClass(buffer, length, dynamic) { }

    PCharArray(PContainerReference & reference_)
      : ParentClass(reference_) { }

    virtual void PrintOn(
      ostream & strm 
    ) const;
    virtual void ReadFrom(
      istream &strm   // Stream to read the objects contents from.
    );
    virtual PObject * Clone() const
    {
      return PNEW PCharArray(*this, GetSize());
    }
};

typedef PScalarArray<short> PShortArray;

typedef PScalarArray<int> PIntArray;

typedef PScalarArray<long> PLongArray;

class PBYTEArray : public PBaseArray<BYTE>
{
    typedef PBaseArray<BYTE> ParentClass;
    PCLASSINFO(PCharArray, ParentClass);
  public:
    PBYTEArray(
      PINDEX initialSize = 0  
    ) : ParentClass(initialSize) { }

    PBYTEArray(
      BYTE const * buffer,   
      PINDEX length,      
      PBoolean dynamic = true 
    ) : ParentClass(buffer, length, dynamic) { }

    PBYTEArray(PContainerReference & reference_)
      : ParentClass(reference_) { }

    virtual void PrintOn(
      ostream & strm 
    ) const;
    virtual void ReadFrom(
      istream &strm   
    );
    virtual PObject * Clone() const
    {
      return PNEW PBYTEArray(*this, GetSize());
    }

    template <typename T> const T & GetAs(PINDEX offset = 0)
    {
      PAssert(offset+(PINDEX)sizeof(T) <= GetSize(), PInvalidParameter);
      return *(const T *)(theArray+offset);
    }
};


class PHexDump : public PBYTEArray
{
  PCLASSINFO(PHexDump, PBYTEArray)
public:
  PHexDump(const void * data, PINDEX length, bool compact = true)
    : PBYTEArray(static_cast<const BYTE *>(data), length, false)
    , m_compact(compact)
  { }

  explicit PHexDump(const PBYTEArray & data, bool compact = true)
    : PBYTEArray(data, data.GetSize(), false)
    , m_compact(compact)
  { }

  virtual void PrintOn(ostream & strm) const;

protected:
  bool m_compact;
};


typedef PScalarArray<WORD> PWORDArray;

typedef PScalarArray<unsigned> PUnsignedArray;

typedef PScalarArray<DWORD> PDWORDArray;


// 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:
    // The type below cannot be nested as DevStudio 2005 AUTOEXP.DAT doesn't like it
    PBaseArray<PObject *> * theArray;
};


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 = this->GetAt(index);
      PAssert(obj != NULL, PInvalidArrayElement);
      return dynamic_cast<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); } \


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

  public:
    PBitArray(
      PINDEX initialSize = 0  
    );

    PBitArray(
      const void * buffer,   
      PINDEX length,         
      PBoolean dynamic = true    
    );

    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, true); return *this; }

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

    PBoolean Concatenate(
      const PBitArray & array  
    );
};


#endif // PTLIB_ARRAY_H


// End Of File ///////////////////////////////////////////////////////////////