MultiDimensionalVector.h

/*
    Hyperspace Explorer - vizualizing higher-dimensional geometry
    Copyright (C) 2009-2010  Lene Preuss <lene.preuss@gmail.com>

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

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*/

#ifndef MULTIDIMENSIONAL_VECTOR_H
#define MULTIDIMENSIONAL_VECTOR_H

#include <vector>

namespace VecMath {


  template <typename T, unsigned D>
  class MultiDimensionalVector: public MultiDimensionalVector<T, D-1> {

    public:

      typedef typename std::vector<MultiDimensionalVector<T, D-1> >::iterator iterator;

      typedef typename std::vector<MultiDimensionalVector<T, D-1> >::const_iterator const_iterator;

      MultiDimensionalVector();

      MultiDimensionalVector(unsigned n);

      MultiDimensionalVector(typename std::vector<MultiDimensionalVector<T, D-1> >::iterator first,
                             typename std::vector<MultiDimensionalVector<T, D-1> >::iterator last);

      MultiDimensionalVector(const MultiDimensionalVector<T, D> &v);
      
      MultiDimensionalVector(MultiDimensionalVector<T, D> &&other) {
          _data = std::move(other._data);
      }

      MultiDimensionalVector & operator=(const MultiDimensionalVector<T, D> &other) {
          if (this == &other) return *this;
          _data = other._data;
          return *this;
      }

      MultiDimensionalVector & operator=(MultiDimensionalVector<T, D> &&other) {
          if (this == &other) return *this;
          _data = std::move(other._data);
          return *this;
      }
      
      iterator begin();

      iterator end();

      const_iterator begin() const;

      const_iterator end() const;

      void push_back(const MultiDimensionalVector<T, D-1> &x);

      MultiDimensionalVector<T, D-1> &back();
      
      const MultiDimensionalVector<T, D-1> &back() const;
      
      iterator erase(iterator position);

      iterator erase(iterator first, iterator last);

      MultiDimensionalVector<T, D-1> &operator [] (unsigned i);

      const MultiDimensionalVector<T, D-1> &operator [] (unsigned i) const;

      unsigned size() const;

      unsigned empty() const;

      void clear();

      void resize(unsigned new_size);

      void resize(unsigned new_size, MultiDimensionalVector<T, D-1> x);
      
      void reserve(unsigned new_size);

      bool operator == (const MultiDimensionalVector<T, D> &other) const;

      bool operator != (const MultiDimensionalVector<T, D> &other) const;

      template <typename Function> Function for_each(Function f);
      template <typename Function> Function for_each(Function f) const;

      std::string toString() const;

      void print() const;

    protected:

      std::vector<MultiDimensionalVector<T, D-1> > &data();

      const std::vector<MultiDimensionalVector<T, D-1> > &data() const;

    private:

      std::vector<MultiDimensionalVector<T, D-1> > _data;
  };

  template<typename T, unsigned D>
  std::ostream& operator<<(std::ostream& s, MultiDimensionalVector<T, D> const& v);

  template <typename T, unsigned D>
  typename MultiDimensionalVector<T, D>::iterator find(MultiDimensionalVector<T, D-1> const &find_me,
                                                       MultiDimensionalVector<T, D> &v);

  template<typename T1, typename T2, unsigned D, typename Function>
  Function for_each(MultiDimensionalVector<T1, D> &v1,
                    MultiDimensionalVector<T2, D> &v2,
                    Function f);

  template<typename T1, typename T2, unsigned D, typename Function>
  Function for_each(const MultiDimensionalVector<T1, D> &v1,
                    const MultiDimensionalVector<T2, D> &v2,
                    Function f);

  template<typename T1, typename T2, typename T3, unsigned D, typename Function>
  Function for_each(MultiDimensionalVector<T1, D> &v1,
                    MultiDimensionalVector<T2, D> &v2,
                    MultiDimensionalVector<T3, D> &v3,
                    Function f);

  template<typename T1, typename T2, typename T3, unsigned D, typename Function>
  Function for_each(const MultiDimensionalVector<T1, D> &v1,
                    const MultiDimensionalVector<T2, D> &v2,
                    const MultiDimensionalVector<T3, D> &v3,
                    Function f);

  template<typename T>
  class MultiDimensionalVector<T, 1> {

    public:

      typedef typename std::vector<T>::iterator iterator;
      typedef typename std::vector<T>::const_iterator const_iterator;

      MultiDimensionalVector();
      MultiDimensionalVector(unsigned n);
      
      MultiDimensionalVector(std::vector<T> data);

      iterator begin();
      iterator end();
      const_iterator begin() const;
      const_iterator end() const;

      void push_back(const T &x);

      T &back();
      
      const T &back() const;

      iterator erase(iterator position);

      iterator erase(iterator first, iterator last);

      T &operator [] (unsigned i);
      const T &operator [] (unsigned i) const;

      unsigned size() const;
      unsigned empty() const;

      void clear();

      void resize(unsigned new_size);

      void resize(unsigned new_size, T x);

      void reserve(unsigned new_size);

      bool operator == (const MultiDimensionalVector<T, 1> &other) const;

      bool operator != (const MultiDimensionalVector<T, 1> &other) const;

      template <typename Function> Function for_each(Function f);
      template <typename Function> Function for_each(Function f) const;

      std::string toString() const;

      void print() const;

      static bool print_num_elements();
      static unsigned max_dimension();

    protected:
      std::vector<T> &data();
      const std::vector<T> &data() const;

    private:
      std::vector<T> _data;

      static const bool PRINT_NUM_ELEMENTS = false;
      static const unsigned MAX_DIMENSION = 4;

  };

  template<typename T>
  std::ostream& operator<<(std::ostream& s, MultiDimensionalVector<T, 1> const& v);

  template<typename T1, typename T2, typename Function>
  Function for_each(MultiDimensionalVector<T1, 1> &v1,
                    MultiDimensionalVector<T2, 1> &v2,
                    Function f);

  template<typename T1, typename T2, typename Function>
  Function for_each(const MultiDimensionalVector<T1, 1> &v1,
                    const MultiDimensionalVector<T2, 1> &v2,
                    Function f);

  template<typename T1, typename T2, typename T3, typename Function>
  Function for_each(MultiDimensionalVector<T1, 1> &v1,
                    MultiDimensionalVector<T2, 1> &v2,
                    MultiDimensionalVector<T3, 1> &v3,
                    Function f);

  template<typename T1, typename T2, typename T3, typename Function>
  Function for_each(const MultiDimensionalVector<T1, 1> &v1,
                    const MultiDimensionalVector<T2, 1> &v2,
                    const MultiDimensionalVector<T3, 1> &v3,
                    Function f);

}


#endif