DynamicArray.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2012  Mark A Lindner

   This file is part of commonc++.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   ---------------------------------------------------------------------------
*/

#ifndef __ccxx_DynamicArray_hxx
#define __ccxx_DynamicArray_hxx

#include <commonc++/Common.h++>
#include <commonc++/OutOfBoundsException.h++>

namespace ccxx {

template <typename T> class DynamicArray
{
  public:

  typedef T value_type;
  typedef T* iterator;
  typedef const T* const_iterator;
  typedef T& reference;
  typedef const T& const_reference;

  DynamicArray(size_t size)
    : _size(0),
      _data(NULL)
  {
    resize(size, false);
  }

  ~DynamicArray() throw()
  {
    delete[] _data;
  }

  void resize(size_t size, bool copy = false)
  {
    if(size != _size)
    {
      T *old = _data;
      _size = size;
      _data = (_size > 0) ? new T[_size] : NULL;

      if(old)
      {
        if(copy)
          std::memcpy(reinterpret_cast<void *>(_data),
                      reinterpret_cast<void *>(old),
                      _size * sizeof(T));
        delete[] old;
      }
    }
  }

  T *release() throw()
  {
    T *data = _data;
    _data = NULL;
    _size = 0;

    return(data);
  }

  bool isNull() const throw()
  { return(_data == NULL); }

  T *data() throw()
  { return(_data); }

  const T *data() const throw()
  { return(_data); }

  size_t size() const throw()
  { return(_size); }

  T& operator[](int index) throw(OutOfBoundsException)
  {
    if((index < 0) || (index >= static_cast<int>(_size)))
      throw OutOfBoundsException();

    return(_data[index]);
  }

  T operator[](int index) const throw(OutOfBoundsException)
  {
    if((index < 0) || (index >= static_cast<int>(_size)))
      throw OutOfBoundsException();

    return(_data[index]);
  }

  operator T*() throw()
  { return(_data); }

  operator const T*() const throw()
  { return(_data); }

  bool operator!() const throw()
  { return(isNull()); }

  iterator begin() throw()
  { return(_data); }

  const_iterator begin() const throw()
  { return(_data); }

  iterator end() throw()
  { return(_data + _size); }

  const_iterator end() const throw()
  { return(_data + _size); }

  private:

  size_t _size;
  T *_data;
};

}; // namespace ccxx

#endif // __ccxx_DynamicArray_hxx

/* end of header file */