src/commons/array.h

#ifndef COMMONS_ARRAY_H
#define COMMONS_ARRAY_H

#include <boost/unique_ptr.hpp>
#include <commons/algo.h>
#include <commons/check.h>
#include <commons/nullptr.h>
#include <commons/utility.h>

namespace commons {

  using namespace boost;

  template<typename T> class array;
  template<typename T> class sized_array;
  template<typename T> void swap(array<T> &a, array<T> &b);
  template<typename T> void swap(sized_array<T> &a, sized_array<T> &b);

  // TODO: rename
  template<typename T>
    class sized_array {
      friend void swap<>(sized_array<T> &a, sized_array<T> &b);
      public:
        explicit sized_array(char *p, size_t n) : p_(p), n_(n) {}
        size_t size() const { return n_; }
        T *get() const { return p_; }
        T *end() const { return p_ + n_; }
        T operator[](size_t i) const { return p_[i]; }
        void reset(T *p, size_t n) { p_ = p; n_ = n; }
      private:
        T *p_;
        size_t n_;
    };

  // TODO: rename
  template<typename T>
    class array {
      EXPAND(unique_ptr<T[]>)
      friend void swap<>(array<T> &a, array<T> &b);
      public:
        explicit array(size_t n) : p_(new T[n]), n_(n) {}
        size_t size() const { return n_; }
        T *get() const { return p_.get(); }
        T *release() { return p_.release(); }
        T *end() const { return this->get() + n_; }
        T operator[](size_t i) const { return p_[i]; }
        void reset(T *p, size_t n) { p_.reset(p); n_ = n; }
      private:
        unique_ptr<T[]> p_;
        size_t n_;
    };

  template<typename T>
  void
  swap(array<T> &a, array<T> &b)
  {
    swap(a.p_, b.p_);
    swap(a.n_, b.n_);
  }

  // TODO: try just specifying a single templated function
  template<typename T>
  void
  swap(sized_array<T> &a, sized_array<T> &b)
  {
    swap(a.p_, b.p_);
    swap(a.n_, b.n_);
  }

  template<typename T>
    class managed_array {
      NONCOPYABLE(managed_array)
      public:
        managed_array(T *p, bool scoped) : p_(p), scoped_(scoped) {}
#ifdef __GXX_EXPERIMENTAL_CXX0X__
        managed_array(managed_array<T> &&a) : p_(a.p_), scoped_(a.scoped_) { a.release(); }
#endif
        ~managed_array() { if (scoped_) delete [] p_; }
        T *release() { T *p = p_; p_ = nullptr; scoped_ = false; return p; }
        T *get() { return p_; }
        const T *get() const { return p_; }
        operator T*() { return p_; }
        operator const T*() const { return p_; }
        bool scoped() const { return scoped_; }
        bool &scoped() { return scoped_; }
      private:
        T *p_;
        bool scoped_;
    };

}

#endif

---