grid.hpp

/*
 * grid.h
 *
 * Created on: 23 Jan 2007
 * Author: Holger Schmitz
 * Email: holger@notjustphysics.com
 *
 * Copyright 2012 Holger Schmitz
 *
 * This file is part of Schnek.
 *
 * Schnek 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 3 of the License, or
 * (at your option) any later version.
 *
 * Schnek 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 Schnek.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef SCHNEK_GRID_H_
#define SCHNEK_GRID_H_

#include "array.hpp"
#include "range.hpp"
#include "gridcheck.hpp"
#include "gridstorage.hpp"
#include "../typetools.hpp"

namespace schnek {

template<class GridType, typename TList>
class IndexedGrid;

template<class IndexType>
struct IndexCast;

template<class Operator, int Length>
class ArrayExpression;

template<
  typename T, 
  int rank,
  class CheckingPolicy,
  class StoragePolicy
>
class GridBase : public StoragePolicy, public CheckingPolicy
{
  public:
    typedef T value_type;
    typedef CheckingPolicy CheckingPolicyType;
    typedef StoragePolicy StoragePolicyType;
    typedef typename CheckingPolicy::IndexType IndexType;
    typedef GridBase<T,rank,CheckingPolicy,StoragePolicy> GridBaseType;
    enum {Rank = rank};

    GridBase();

    template<template<int> class ArrayCheckingPolicy>
    GridBase(const Array<int,rank,ArrayCheckingPolicy> &size);

    template<template<int> class ArrayCheckingPolicy>
    GridBase(const Array<int,rank,ArrayCheckingPolicy> &low, const Array<int,rank,ArrayCheckingPolicy> &high);

    template<template<int> class ArrayCheckingPolicy>
    T& operator[](const Array<int,rank,ArrayCheckingPolicy>& pos); // write
    template<template<int> class ArrayCheckingPolicy>
    T  operator[](const Array<int,rank,ArrayCheckingPolicy>& pos) const; // read

    template<class Operator, int Length>
    T& operator[](const ArrayExpression<Operator, Length>& pos); // write
    template<class Operator, int Length>
    T  operator[](const ArrayExpression<Operator, Length>& pos) const; // read

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

    T& operator()(int i);
    T  operator()(int i) const;
    T& operator()(int i, int j);
    T  operator()(int i, int j) const;
    T& operator()(int i, int j, int k);
    T  operator()(int i, int j, int k) const;
    T& operator()(int i, int j, int k, int l);
    T  operator()(int i, int j, int k, int l) const;
    T& operator()(int i, int j, int k, int l, int m);
    T  operator()(int i, int j, int k, int l, int m) const;
    T& operator()(int i, int j, int k, int l, int m, int o);
    T  operator()(int i, int j, int k, int l, int m, int o) const;
    T& operator()(int i, int j, int k, int l, int m, int o, int p);
    T  operator()(int i, int j, int k, int l, int m, int o, int p) const;
    T& operator()(int i, int j, int k, int l, int m, int o, int p, int q);
    T  operator()(int i, int j, int k, int l, int m, int o, int p, int q) const;
    T& operator()(int i, int j, int k, int l, int m, int o, int p, int q, int r);
    T  operator()(int i, int j, int k, int l, int m, int o, int p, int q, int r) const;
    T& operator()(int i, int j, int k, int l, int m, int o, int p, int q, int r, int s);
    T  operator()(int i, int j, int k, int l, int m, int o, int p, int q, int r, int s) const;

    GridBase<T, rank, CheckingPolicy, StoragePolicy>&
      operator=(const GridBase<T, rank, CheckingPolicy, StoragePolicy>&);

    template<
      typename T2,
      class CheckingPolicy2,
      class StoragePolicy2
    >
    GridBase<T, rank, CheckingPolicy, StoragePolicy>&
      operator=(const GridBase<T2, rank, CheckingPolicy2, StoragePolicy2>&);

    GridBase<T, rank, CheckingPolicy, StoragePolicy>&
      operator=(const T &val);

    template<
      typename T2,
      class CheckingPolicy2
    >
    GridBase<T, rank, CheckingPolicy, StoragePolicy>&
      operator-=(GridBase<T2, rank, CheckingPolicy2, StoragePolicy>&);

    template<
      typename T2,
      class CheckingPolicy2,
      class StoragePolicy2
    >
    GridBase<T, rank, CheckingPolicy, StoragePolicy>&
      operator-=(GridBase<T2, rank, CheckingPolicy2, StoragePolicy2>&);

    template<
      typename T2,
      class CheckingPolicy2
    >
    GridBase<T, rank, CheckingPolicy, StoragePolicy>&
      operator+=(GridBase<T2, rank, CheckingPolicy2, StoragePolicy>&);


    template<
      typename T2,
      class CheckingPolicy2,
      class StoragePolicy2
    >
    GridBase<T, rank, CheckingPolicy, StoragePolicy>&
      operator+=(GridBase<T2, rank, CheckingPolicy2, StoragePolicy2>&);

    void resize(const IndexType &size);

    void resize(const IndexType &low, const IndexType &high);

    template<
      typename T2,
      class CheckingPolicy2,
      class StoragePolicy2
    >
    void resize(const GridBase<T2, rank, CheckingPolicy2, StoragePolicy2>& grid);

  protected:
    // assumes that the sizes are already set properly
    template<typename T2, class CheckingPolicy2>
    void copyFromGrid(const GridBase<T2, rank, CheckingPolicy2, StoragePolicy>& grid);

};



template<
  typename T,
  int rank,
  template<int> class CheckingPolicy = GridNoArgCheck,
  template<typename, int> class StoragePolicy = SingleArrayGridStorage
>
class Grid : public GridBase<T, rank, CheckingPolicy<rank>,  StoragePolicy<T,rank> >
{

  public:
    typedef T value_type;
    typedef Array<int,rank> IndexType;
    typedef Range<int,rank> RangeType;
    typedef Grid<T,rank,CheckingPolicy,StoragePolicy> GridType;
    typedef GridBase<T, rank, CheckingPolicy<rank>, StoragePolicy<T,rank> > BaseType;
    enum {Rank = rank};
  
    Grid();

    Grid(const IndexType &size);

    Grid(const IndexType &low, const IndexType &high);

    Grid(const RangeType &range);

    Grid(const Grid<T, rank, CheckingPolicy, StoragePolicy>&);

//
//    template<typename Arg0>
//    IndexedGrid<GridType, TYPELIST_1(Arg0) > operator()(
//      const Arg0 &i0
//    );
//
//    template<typename Arg0, typename Arg1>
//    IndexedGrid<GridType, TYPELIST_2(Arg0, Arg1) > operator()(
//      const Arg0 &i0, const Arg1 &i1
//    );


    GridType& operator=(const T &val)
    {
      BaseType::operator=(val);
      return *this;
    }

    GridType& operator=(const GridType &grid)
    {
      BaseType::operator=(grid);
      return *this;
    }

    template<
      typename T2,
      class CheckingPolicy2,
      class StoragePolicy2
    >
    GridType& operator=(const GridBase<T2, rank, CheckingPolicy2, StoragePolicy2> &grid)
    {
      BaseType::operator=(grid);
      return *this;
    }
};

} // namespace schnek

#include "grid.t"

#endif // SCHNEK_GRID_H_