mosesdecoder/util/fixed_array.hh

#ifndef UTIL_FIXED_ARRAY_H
#define UTIL_FIXED_ARRAY_H

#include "util/scoped.hh"

#include <cstddef>

#include <cassert>
#include <cstdlib>

namespace util {

/**
 * Defines an array with fixed maximum size.
 *
 * Ever want an array of things but they don't have a default constructor or
 * are non-copyable?  FixedArray allows constructing one at a time.
 */
template <class T> class FixedArray {
  public:
    /** Initialize with a given size bound but do not construct the objects. */
    explicit FixedArray(std::size_t limit) {
      Init(limit);
    }

    /**
     * Constructs an instance, but does not initialize it.
     *
     * Any objects constructed in this manner must be subsequently @ref FixedArray::Init() "initialized" prior to use.
     *
     * @see FixedArray::Init()
     */
    FixedArray()
      : newed_end_(NULL)
#ifndef NDEBUG
      , allocated_end_(NULL)
#endif
    {}

    /**
     * Initialize with a given size bound but do not construct the objects.
     *
     * This method is responsible for allocating memory.
     * Objects stored in this array will be constructed in a location within this allocated memory.
     */
    void Init(std::size_t count) {
      assert(!block_.get());
      block_.reset(malloc(sizeof(T) * count));
      if (!block_.get()) throw std::bad_alloc();
      newed_end_ = begin();
#ifndef NDEBUG
      allocated_end_ = begin() + count;
#endif
    }

    /**
     * Constructs a copy of the provided array.
     *
     * @param from Array whose elements should be copied into this newly-constructed data structure.
     */
    FixedArray(const FixedArray &from) {
      std::size_t size = from.newed_end_ - static_cast<const T*>(from.block_.get());
      Init(size);
      for (std::size_t i = 0; i < size; ++i) {
        push_back(from[i]);
      }
    }

    /**
     * Frees the memory held by this object.
     */
    ~FixedArray() { clear(); }

    /** Gets a pointer to the first object currently stored in this data structure. */
    T *begin() { return static_cast<T*>(block_.get()); }

    /** Gets a const pointer to the last object currently stored in this data structure. */
    const T *begin() const { return static_cast<const T*>(block_.get()); }

    /** Gets a pointer to the last object currently stored in this data structure. */
    T *end() { return newed_end_; }

    /** Gets a const pointer to the last object currently stored in this data structure. */
    const T *end() const { return newed_end_; }

    /** Gets a reference to the last object currently stored in this data structure. */
    T &back() { return *(end() - 1); }

    /** Gets a const reference to the last object currently stored in this data structure. */
    const T &back() const { return *(end() - 1); }

    /** Gets the number of objects currently stored in this data structure. */
    std::size_t size() const { return end() - begin(); }

    /** Returns true if there are no objects currently stored in this data structure. */
    bool empty() const { return begin() == end(); }

    /**
     * Gets a reference to the object with index i currently stored in this data structure.
     *
     * @param i Index of the object to reference
     */
    T &operator[](std::size_t i) {
      assert(i < size());
      return begin()[i];
    }

    /**
     * Gets a const reference to the object with index i currently stored in this data structure.
     *
     * @param i Index of the object to reference
     */
    const T &operator[](std::size_t i) const {
      assert(i < size());
      return begin()[i];
    }

    /**
     * Constructs a new object using the provided parameter,
     * and stores it in this data structure.
     *
     * The memory backing the constructed object is managed by this data structure.
     * I miss C++11 variadic templates.
     */
    void push_back() {
      new (end()) T();
      Constructed();
    }
    template <class C> void push_back(const C &c) {
      new (end()) T(c);
      Constructed();
    }
    template <class C> void push_back(C &c) {
      new (end()) T(c);
      Constructed();
    }
    template <class C, class D> void push_back(const C &c, const D &d) {
      new (end()) T(c, d);
      Constructed();
    }

    void pop_back() {
      back().~T();
      --newed_end_;
    }

    /**
     * Removes all elements from this array.
     */
    void clear() {
      while (newed_end_ != begin())
        pop_back();
    }

  protected:
    // Always call Constructed after successful completion of new.
    void Constructed() {
      ++newed_end_;
#ifndef NDEBUG
      assert(newed_end_ <= allocated_end_);
#endif
    }

  private:
    util::scoped_malloc block_;

    T *newed_end_;

#ifndef NDEBUG
    T *allocated_end_;
#endif
};

} // namespace util

#endif // UTIL_FIXED_ARRAY_H