array.h

/*
 *  Copyright (c) 2002-2004    National Research Council
 *
 *  All rights reserved.
 *
 *  This material is confidential and proprietary information of
 *  National Research Council Canada ("Confidential Information").
 *  This Confidential Information may only be used and reproduced
 *  in accordance with the terms of the license agreement.
 *
 */

#ifndef __INCLUDED_SCOPIRA_TOOL_ARRAY_H__
#define __INCLUDED_SCOPIRA_TOOL_ARRAY_H__

#include <assert.h>
#include <stddef.h>    //for size_t
#include <string.h>    //for memset

// THIS FILE HAS BEEN FULLY DOCUMENTED

namespace scopira
{
  namespace tool
  {
    template <class T> class array_view;
    template <class T> class const_array_view;

    template <class T> class basic_array;
    template <class T> class basic_matrix;
    template <class T, size_t N> class fixed_array;
    template <class T, size_t N> class hybrid_array;
  }
}

template <class T> class scopira::tool::array_view
{
  public:
    typedef T data_type;
    typedef T* iterator;
    typedef const T* const_iterator;
  protected:
    T *dm_ary, *dm_end;

  public:
    array_view(basic_array<T> &rhs) : dm_ary(rhs.begin()), dm_end(rhs.end()) { }
    array_view(T *b, T *e) : dm_ary(b), dm_end(e) { }
    template <size_t N>
      array_view(fixed_array<T, N> &rhs) : dm_ary(rhs.begin()), dm_end(rhs.end()) { }
    template <size_t N>
      array_view(hybrid_array<T, N> &rhs) : dm_ary(rhs.begin()), dm_end(rhs.end()) { }
    T * array(void) { return dm_ary; }
    const T * array(void) const { return dm_ary; }
    T * c_array(void) { return dm_ary; }
    const T * c_array(void) const { return dm_ary; }
    iterator begin(void) { return dm_ary; }
    iterator end(void) { return dm_end; }
    const_iterator begin(void) const { return dm_ary; }
    const_iterator end(void) const { return dm_end; }

    void clear_zero(void) { ::memset(dm_ary, 0, sizeof(T)*(size())); }

    size_t size(void) const { return dm_end - dm_ary; }
    bool empty(void) const { return dm_ary == dm_end; }

    void set(size_t idx, const T &v) {
      assert("[array_view element access was out of bounds]" && (dm_ary+idx)<dm_end);
      dm_ary[idx] = v;
    }
    const T & get(size_t idx) const {
      assert("[array_view element access was out of bounds]" && (dm_ary+idx)<dm_end);
      return dm_ary[idx];
    }
    T & get(size_t idx) {
      assert("[array_view element access was out of bounds]" && (dm_ary+idx)<dm_end);
      return dm_ary[idx];
    }
    const T & operator[](size_t idx) const {
      assert("[array_view element access was out of bounds]" && (dm_ary+idx)<dm_end);
      return dm_ary[idx];
    }
    T & operator[](size_t idx) {
      assert("[array_view element access was out of bounds]" && (dm_ary+idx)<dm_end);
      return dm_ary[idx];
    }
};

template <class T> class scopira::tool::const_array_view
{
  public:
    typedef T data_type;
    typedef const T* const_iterator;
  protected:
    const T *dm_ary, *dm_end;

  public:
    const_array_view(array_view<T> rhs) : dm_ary(rhs.begin()), dm_end(rhs.end()) { }
    const_array_view(const basic_array<T> &rhs) : dm_ary(rhs.begin()), dm_end(rhs.end()) { }
    const_array_view(const T *b, const T *e) : dm_ary(b), dm_end(e) { }
    template <size_t N>
      const_array_view(const fixed_array<T, N> &rhs) : dm_ary(rhs.begin()), dm_end(rhs.end()) { }
    template <size_t N>
      const_array_view(const hybrid_array<T, N> &rhs) : dm_ary(rhs.begin()), dm_end(rhs.end()) { }
    const T * array(void) const { return dm_ary; }
    const T * c_array(void) const { return dm_ary; }
    const_iterator begin(void) const { return dm_ary; }
    const_iterator end(void) const { return dm_end; }

    size_t size(void) const { return dm_end - dm_ary; }
    bool empty(void) const { return dm_ary == dm_end; }

    const T & get(size_t idx) const {
      assert("[const_array_view element access was out of bounds]" && (dm_ary+idx)<dm_end);
      return dm_ary[idx];
    }
    const T & operator[](size_t idx) const {
      assert("[const_array_view element access was out of bounds]" && (dm_ary+idx)<dm_end);
      return dm_ary[idx];
    }
};

template <class T> class scopira::tool::basic_array
{
  public:
    typedef T data_type;
    typedef T* iterator;
    typedef const T* const_iterator;
  protected:
    T *dm_ary;
    size_t dm_len;
  public:
    basic_array(void) : dm_ary(0), dm_len(0) { }
    explicit basic_array(size_t len) : dm_ary(0), dm_len(0) { resize(len); }
    basic_array(const basic_array &rhs);
    ~basic_array() { resize(0); }

    void resize(size_t newlen);

    void array_swap(basic_array<T> &other) {
      T *ary = dm_ary;
      size_t len = dm_len;
      dm_ary = other.dm_ary;
      dm_len = other.dm_len;
      other.dm_ary = ary;
      other.dm_len = len;
    }
    T * array(void) { return dm_ary; }
    const T * array(void) const { return dm_ary; }
    T * c_array(void) { return dm_ary; }
    const T * c_array(void) const { return dm_ary; }
    iterator begin(void) { return dm_ary; }
    iterator end(void) { return dm_ary+dm_len; }
    const_iterator begin(void) const { return dm_ary; }
    const_iterator end(void) const { return dm_ary+dm_len; }

    basic_array & operator=(const basic_array &rhs);
    void clear(void) { resize(0); }
    void clear_zero(void) { ::memset(dm_ary, 0, sizeof(T)*dm_len); }

    size_t size(void) const { return dm_len; }
    bool empty(void) const { return dm_len == 0; }

    void set(size_t idx, const T &v) {
      assert("[basic_array element access was out of bounds]" && idx<dm_len);
      dm_ary[idx] = v;
    }
    const T & get(size_t idx) const {
      assert("[basic_array element access was out of bounds]" && idx<dm_len);
      return dm_ary[idx];
    }
    T & get(size_t idx) {
      assert("[basic_array element access was out of bounds]" && idx<dm_len);
      return dm_ary[idx];
    }
    const T & operator[](size_t idx) const {
      assert("[basic_array element access was out of bounds]" && idx<dm_len);
      return dm_ary[idx];
    }
    T & operator[](size_t idx) {
      assert("[basic_array element access was out of bounds]" && idx<dm_len);
      return dm_ary[idx];
    }
};

template <class T>
  scopira::tool::basic_array<T>::basic_array(const basic_array &rhs)
  : dm_ary(0), dm_len(0)
{
  if (rhs.dm_len>0) {
    resize(rhs.dm_len);
    iterator ii, endii = end();
    const_iterator jj;
    // copy
    for (ii=begin(), jj=rhs.begin(); ii != endii; ++ii, ++jj)
      *ii = *jj;
  }
}

template <class T>
  void scopira::tool::basic_array<T>::resize(size_t newlen)
{
  if (dm_len == newlen)
    return; // no need to change anything
  if (dm_len > 0)
    delete []dm_ary;
  dm_len = newlen;
  if (dm_len == 0)
    dm_ary = 0;
  else
    dm_ary = new T[dm_len];
}

template <class T>
  scopira::tool::basic_array<T> & scopira::tool::basic_array<T>::operator=(const basic_array &rhs)
{
  resize(rhs.dm_len);

  iterator ii, endii = end();
  const_iterator jj;
  // copy
  for (ii=begin(), jj=rhs.begin(); ii != endii; ++ii, ++jj)
    *ii = *jj;

  return *this;
}

template <class T> class scopira::tool::basic_matrix : public scopira::tool::basic_array<T>
{
  private:
    typedef scopira::tool::basic_array<T> parent_type;
  protected:
    size_t dm_w, dm_h;
  public:
    basic_matrix(void) {
      dm_w = dm_h = 0;
    }
    basic_matrix(size_t w, size_t h) {
      dm_w = w;
      dm_h = h;
      resize(dm_w*dm_h);
    }
    void resize(size_t w, size_t h) {
      dm_w = w;
      dm_h = h;
      resize(dm_w*dm_h);
    }

    size_t width(void) const { return dm_w; }
    size_t height(void) const { return dm_h; }

    void set(size_t x, size_t y, const T &v) {
      assert("[basic_matrix x axis out of bounds]" && x<dm_w);
      assert("[basic_matrix y axis out of bounds]" && y<dm_h);
      basic_array<T>::dm_ary[y*dm_w+x] = v;
    }
    const T & get(size_t x, size_t y) const {
      assert("[basic_matrix x axis out of bounds]" && x<dm_w);
      assert("[basic_matrix y axis out of bounds]" && y<dm_h);
      return basic_array<T>::dm_ary[y*dm_w+x];
    }
    T & get(size_t x, size_t y) {
      assert("[basic_matrix x axis out of bounds]" && x<dm_w);
      assert("[basic_matrix y axis out of bounds]" && y<dm_h);
      return basic_array<T>::dm_ary[y*dm_w+x];
    }
    const T & operator()(size_t x, size_t y) const {
      assert("[basic_matrix x axis out of bounds]" && x<dm_w);
      assert("[basic_matrix y axis out of bounds]" && y<dm_h);
      return basic_array<T>::dm_ary[y*dm_w+x];
    }
    T & operator()(size_t x, size_t y) {
      assert("[basic_matrix x axis out of bounds]" && x<dm_w);
      assert("[basic_matrix y axis out of bounds]" && y<dm_h);
      return basic_array<T>::dm_ary[y*dm_w+x];
    }

  protected:
    // lets hide this from the 2D users
    void resize(size_t newlen) {
      parent_type::resize(newlen);
    }
};

template <class T, size_t N> class scopira::tool::fixed_array
{
  public:
    typedef T data_type;
    typedef T* iterator;
    enum { size_c = N };
    typedef const T* const_iterator;
  protected:
    T dm_ary[N];

  public:
    T * array(void) { return dm_ary; }
    const T * array(void) const { return dm_ary; }
    T * c_array(void) { return dm_ary; }
    const T * c_array(void) const { return dm_ary; }
    iterator begin(void) { return dm_ary; }
    iterator end(void) { return dm_ary+N; }
    const_iterator begin(void) const { return dm_ary; }
    const_iterator end(void) const { return dm_ary+N; }
    void clear_zero(void) { ::memset(dm_ary, 0, sizeof(T)*N); }
    size_t size(void) const { return N; }
    bool empty(void) const { return false; }

    void set(size_t idx, const T &v) {
      assert("[fixed_array element access out of bounds]" && idx<N);
      dm_ary[idx] = v;
    }
    const T & get(size_t idx) const {
      assert("[fixed_array element access out of bounds]" && idx<N);
      return dm_ary[idx];
    }
    T & get(size_t idx) {
      assert("[fixed_array element access out of bounds]" && idx<N);
      return dm_ary[idx];
    }
    const T & operator[](size_t idx) const {
      assert("[fixed_array element access out of bounds]" && idx<N);
      return dm_ary[idx];
    }
    T & operator[](size_t idx) {
      assert("[fixed_array element access out of bounds]" && idx<N);
      return dm_ary[idx];
    }
};

template <class T, size_t RES> class scopira::tool::hybrid_array
{
  public:
    typedef T data_type;
    typedef T* iterator;
    typedef const T* const_iterator;
  protected:
    fixed_array<T, RES> dm_fixed;
    basic_array<T> dm_basic;

    T *dm_ary;
    size_t dm_len;

  public:
    hybrid_array(void);
    explicit hybrid_array(size_t len);
    hybrid_array(const hybrid_array &rhs);
    hybrid_array(const_array_view<T> rhs);
    ~hybrid_array() { }

    void resize(size_t newlen);
    T * array(void) { return dm_ary; }
    const T * array(void) const { return dm_ary; }
    T * c_array(void) { return dm_ary; }
    const T * c_array(void) const { return dm_ary; }
    iterator begin(void) { return dm_ary; }
    iterator end(void) { return dm_ary+dm_len; }
    const_iterator begin(void) const { return dm_ary; }
    const_iterator end(void) const { return dm_ary+dm_len; }

    hybrid_array & operator=(const hybrid_array &rhs);
    hybrid_array & operator=(const_array_view<T> rhs);
    void clear(void) { resize(0); }
    void clear_zero(void) { ::memset(dm_ary, 0, sizeof(T)*dm_len); }

    size_t size(void) const { return dm_len; }
    bool empty(void) const { return dm_len == 0; }

    void set(size_t idx, const T &v) {
      assert("[hybrid_array element access was out of bounds]" && idx<dm_len);
      dm_ary[idx] = v;
    }
    const T & get(size_t idx) const {
      assert("[hybrid_array element access was out of bounds]" && idx<dm_len);
      return dm_ary[idx];
    }
    T & get(size_t idx) {
      assert("[hybrid_array element access was out of bounds]" && idx<dm_len);
      return dm_ary[idx];
    }
    const T & operator[](size_t idx) const {
      assert("[hybrid_array element access was out of bounds]" && idx<dm_len);
      return dm_ary[idx];
    }
    T & operator[](size_t idx) {
      assert("[hybrid_array element access was out of bounds]" && idx<dm_len);
      return dm_ary[idx];
    }
};

template <class T, size_t RES>
  scopira::tool::hybrid_array<T,RES>::hybrid_array(void)
  : dm_ary(0), dm_len(0)
{
}

template <class T, size_t RES>
  scopira::tool::hybrid_array<T,RES>::hybrid_array(size_t len)
  : dm_ary(0), dm_len(0)
{
  resize(len);
}

template <class T, size_t RES>
  scopira::tool::hybrid_array<T,RES>::hybrid_array(const hybrid_array &rhs)
  : dm_ary(0), dm_len(0)
{
  resize(rhs.size());
  if (!empty()) {
    iterator ii, endii = end();
    const_iterator jj;
    // copy
    for (ii=begin(), jj=rhs.begin(); ii != endii; ++ii, ++jj)
      *ii = *jj;
  }
}

template <class T, size_t RES>
  scopira::tool::hybrid_array<T,RES>::hybrid_array(const_array_view<T> rhs)
  : dm_ary(0), dm_len(0)
{
  resize(rhs.size());
  if (!empty()) {
    iterator ii, endii = end();
    const_iterator jj;
    // copy
    for (ii=begin(), jj=rhs.begin(); ii != endii; ++ii, ++jj)
      *ii = *jj;
  }
}

template <class T, size_t RES>
  void scopira::tool::hybrid_array<T,RES>::resize(size_t newlen)
{
  if (dm_len == newlen)
    return; // no need to change anything
  if (dm_len > RES)
    dm_basic.resize(0);
  dm_len = newlen;
  if (dm_len == 0)
    dm_ary = 0;
  else if (dm_len <= RES)
    dm_ary = dm_fixed.c_array();
  else {
    dm_basic.resize(dm_len);
    dm_ary = dm_basic.c_array();
  }
}

template <class T, size_t RES>
  scopira::tool::hybrid_array<T,RES> & scopira::tool::hybrid_array<T,RES>::operator=(const hybrid_array &rhs)
{
  resize(rhs.dm_len);

  iterator ii, endii = end();
  const_iterator jj;
  // copy
  for (ii=begin(), jj=rhs.begin(); ii != endii; ++ii, ++jj)
    *ii = *jj;

  return *this;
}

template <class T, size_t RES>
  scopira::tool::hybrid_array<T,RES> & scopira::tool::hybrid_array<T,RES>::operator=(const_array_view<T> rhs)
{
  resize(rhs.size());

  iterator ii, endii = end();
  const_iterator jj;
  // copy
  for (ii=begin(), jj=rhs.begin(); ii != endii; ++ii, ++jj)
    *ii = *jj;

  return *this;
}

#endif