DynamicArray.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2014  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++>

#include <cstring>

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(uint_t size)
    : _size(0),
      _data(NULL)
  {
    resize(size, false);
  }

  ~DynamicArray()
  {
    delete[] _data;
  }

  void resize(uint_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()
  {
    T* data = _data;
    _data = NULL;
    _size = 0;

    return(data);
  }

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

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

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

  uint_t size() const
  { return(_size); }

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

    return(_data[index]);
  }

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

    return(_data[index]);
  }

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

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

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

  iterator begin()
  { return(_data); }

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

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

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

 private:

  uint_t _size;
  T* _data;
};

} // namespace ccxx

#endif // __ccxx_DynamicArray_hxx