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"
#include "../macros.hpp"

namespace schnek {

  template<class GridType, typename TList>
  class IndexedGrid;

  template<class IndexType>
  struct IndexCast;

  template<class Operator, size_t Length>
  class ArrayExpression;


  namespace internal {
    template<
      typename T, 
      size_t 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 typename StoragePolicy::RangeType RangeType;
        typedef GridBase<T,rank,CheckingPolicy,StoragePolicy> GridBaseType;
        enum {Rank = rank};

        GridBase();

        GridBase(const GridBase&) = default;

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

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

        template<template<size_t> class ArrayCheckingPolicy>
        GridBase(const Range<int,rank,ArrayCheckingPolicy> &range);

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

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

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

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

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

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

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

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

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


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

        void resize(const IndexType &size);

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

        void resize(const RangeType &range);

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


  template<
    typename T,
    size_t rank,
    template<size_t> class CheckingPolicy = GridNoArgCheck,
    template<typename, size_t> class StoragePolicy = SingleArrayGridStorage
  >
  class Grid : public internal::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 internal::GridBase<T, rank, CheckingPolicy<rank>, StoragePolicy<T,rank> > BaseType;
      enum {Rank = rank};
    
      Grid();

      Grid(const Grid&) = default;

      Grid(const IndexType &size);

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

      Grid(const RangeType &range);

  //
  //    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 internal::GridBase<T2, rank, CheckingPolicy2, StoragePolicy2> &grid)
      {
        BaseType::operator=(grid);
        return *this;
      }
  };

} // namespace schnek

#include "grid.t"

#endif // SCHNEK_GRID_H_