filter_chain.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/lafem/meta_element.hpp>
 
namespace FEAT
{
  namespace LAFEM
  {
    template<
      typename First_,
      typename... Rest_>
    class FilterChain
    {
      template<typename,typename...>
      friend class FilterChain;
 
      typedef FilterChain<Rest_...> RestClass;
 
    public:
      static constexpr int num_blocks = FilterChain<Rest_...>::num_blocks + 1;
 
      typedef typename First_::DataType DataType;
      typedef typename First_::IndexType IndexType;
 
      typedef typename First_::VectorType VectorType;
 
      template <typename DT2_ = DataType, typename IT2_ = IndexType>
      using FilterType = FilterChain<
        typename First_::template FilterType<DT2_, IT2_>,
        typename Rest_::template FilterType<DT2_, IT2_>...>;
 
      template <typename DT2_ = DataType, typename IT2_ = IndexType>
      using FilterTypeByDI = FilterType<DT2_, IT2_>;
 
      // ensure that all sub-vector have the same and data-type
      static_assert(std::is_same<DataType, typename RestClass::DataType>::value,
                    "sub-filters have different data-types");
      static_assert(std::is_same<IndexType, typename RestClass::IndexType>::value,
                    "sub-filters have different index-types");
 
    protected:
      First_ _first;
      RestClass _rest;
 
      explicit FilterChain(First_&& the_first, RestClass&& the_rest) :
        _first(std::move(the_first)),
        _rest(std::move(the_rest))
      {
      }
 
    public:
      FilterChain()
      {
      }
 
      explicit FilterChain(First_&& the_first, Rest_&&... the_rest) :
        _first(std::move(the_first)),
        _rest(std::move(the_rest...))
      {
      }
 
      FilterChain(FilterChain&& other) :
        _first(std::move(other._first)),
        _rest(std::move(other._rest))
      {
      }
 
      FilterChain& operator=(FilterChain&& other)
      {
        if(this != &other)
        {
          _first = std::move(other._first);
          _rest = std::move(other._rest);
        }
        return *this;
      }
 
      FilterChain clone(CloneMode clone_mode = CloneMode::Deep) const
      {
        return FilterChain(_first.clone(clone_mode), _rest.clone(clone_mode));
      }
 
      void clone(const FilterChain & other, CloneMode clone_mode = CloneMode::Deep)
      {
        _first.clone(other._first.get_filter_vector(), clone_mode);
        _rest.clone(other._rest, clone_mode);
      }
 
      template<typename... SubFilter2_>
      void convert(const FilterChain<SubFilter2_...>& other)
      {
        _first.convert(other._first);
        _rest.convert(other._rest);
      }
 
      std::size_t bytes() const
      {
        return _first.bytes() + _rest.bytes();
      }
 
      First_& first()
      {
        return _first;
      }
 
      const First_& first() const
      {
        return _first;
      }
 
      RestClass& rest()
      {
        return _rest;
      }
 
      const RestClass& rest() const
      {
        return _rest;
      }
 
      template<int i_>
      typename TupleElement<i_, First_, Rest_...>::Type& at()
      {
        static_assert((0 <= i_) && (i_ < num_blocks), "invalid sub-filter index");
        return TupleElement<i_, First_, Rest_...>::get(*this);
      }
 
      template<int i_>
      typename TupleElement<i_, First_, Rest_...>::Type const& at() const
      {
        static_assert((0 <= i_) && (i_ < num_blocks), "invalid sub-filter index");
        return TupleElement<i_, First_, Rest_...>::get(*this);
      }
 
      template<typename Vector_>
      void filter_rhs(Vector_& vector) const
      {
        first().filter_rhs(vector);
        rest().filter_rhs(vector);
      }
 
      template<typename Vector_>
      void filter_sol(Vector_& vector) const
      {
        first().filter_sol(vector);
        rest().filter_sol(vector);
      }
 
      template<typename Vector_>
      void filter_def(Vector_& vector) const
      {
        first().filter_def(vector);
        rest().filter_def(vector);
      }
 
      template<typename Vector_>
      void filter_cor(Vector_& vector) const
      {
        first().filter_cor(vector);
        rest().filter_cor(vector);
      }
 
      template<typename Matrix_>
      void filter_mat(Matrix_& matrix) const
      {
        first().filter_mat(matrix);
        rest().filter_mat(matrix);
      }
    }; // class FilterChain
 
    template<typename First_>
    class FilterChain<First_>
    {
      template<typename,typename...>
      friend class FilterChain;
 
    public:
      static constexpr int num_blocks = 1;
 
      typedef typename First_::DataType DataType;
      typedef typename First_::IndexType IndexType;
 
      template <typename DT2_ = DataType, typename IT2_ = IndexType>
      using FilterType = FilterChain<typename First_::template FilterType<DT2_, IT2_> >;
 
    protected:
      First_ _first;
 
    public:
      FilterChain()
      {
      }
 
      explicit FilterChain(First_&& the_first) :
        _first(std::move(the_first))
      {
      }
 
      FilterChain(FilterChain&& other) :
        _first(std::move(other._first))
      {
      }
 
      FilterChain& operator=(FilterChain&& other)
      {
        if(this != &other)
        {
          _first = std::move(other._first);
        }
        return *this;
      }
 
      FilterChain clone(CloneMode clone_mode = CloneMode::Deep) const
      {
        return FilterChain(_first.clone(clone_mode));
      }
 
      void clone(const FilterChain & other, CloneMode clone_mode = CloneMode::Deep)
      {
        _first.clone(other._first.get_filter_vector(), clone_mode);
      }
 
      template<typename SubFilter2_>
      void convert(const FilterChain<SubFilter2_>& other)
      {
        _first.convert(other._first);
      }
 
      std::size_t bytes() const
      {
        return _first.bytes();
      }
 
      First_& first()
      {
        return _first;
      }
 
      const First_& first() const
      {
        return _first;
      }
 
      template<int i_>
      typename TupleElement<i_, First_>::Type& at()
      {
        static_assert(i_ == 0, "invalid sub-filter index");
        return first();
      }
 
      template<int i_>
      typename TupleElement<i_, First_>::Type const& at() const
      {
        static_assert(i_ == 0, "invalid sub-filter index");
        return first();
      }
 
      template<typename Vector_>
      void filter_rhs(Vector_& vector) const
      {
        first().filter_rhs(vector);
      }
 
      template<typename Vector_>
      void filter_sol(Vector_& vector) const
      {
        first().filter_sol(vector);
      }
 
      template<typename Vector_>
      void filter_def(Vector_& vector) const
      {
        first().filter_def(vector);
      }
 
      template<typename Vector_>
      void filter_cor(Vector_& vector) const
      {
        first().filter_cor(vector);
      }
 
      template<typename Matrix_>
      void filter_mat(Matrix_& matrix) const
      {
        first().filter_mat(matrix);
      }
    }; // class FilterChain
  } // namespace LAFEM
} // namespace FEAT