tuple_filter.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/tuple_vector.hpp>
#include <kernel/lafem/meta_element.hpp>
 
namespace FEAT
{
  namespace LAFEM
  {
    template<
      typename First_,
      typename... Rest_>
    class TupleFilter
    {
      template<typename,typename...>
      friend class TupleFilter;
 
      typedef TupleFilter<Rest_...> RestClass;
 
    public:
      static constexpr int num_blocks = TupleFilter<Rest_...>::num_blocks + 1;
 
      typedef typename First_::DataType DataType;
      typedef typename First_::IndexType IndexType;
 
      // ensure that all sub-vector have the same 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");
 
      typedef TupleVector<typename First_::VectorType, typename Rest_::VectorType...> VectorType;
 
      template <typename DT2_ = DataType, typename IT2_ = IndexType>
      using FilterType = TupleFilter<
        typename First_::template FilterType<DT2_, IT2_>,
        typename Rest_::template FilterType<DT2_, IT2_>...>;
 
      template <typename DataType2_, typename IndexType2_>
      using FilterTypeByDI = FilterType<DataType2_, IndexType2_>;
 
    protected:
      First_ _first;
      RestClass _rest;
 
      explicit TupleFilter(First_&& the_first, RestClass&& the_rest) :
        _first(std::forward<First_>(the_first)),
        _rest(std::forward<RestClass>(the_rest))
      {
      }
 
    public:
      TupleFilter()
      {
      }
 
      explicit TupleFilter(First_&& the_first, Rest_&&... the_rest) :
        _first(std::forward<First_>(the_first)),
        _rest(std::forward<Rest_>(the_rest)...)
      {
      }
 
      TupleFilter(TupleFilter&& other) :
        _first(std::forward<First_>(other._first)),
        _rest(std::forward<RestClass>(other._rest))
      {
      }
 
      TupleFilter& operator=(TupleFilter&& other)
      {
        if(this != &other)
        {
          _first = std::forward<First_>(other._first);
          _rest = std::forward<RestClass>(other._rest);
        }
        return *this;
      }
 
      TupleFilter clone(CloneMode clone_mode = CloneMode::Deep) const
      {
        return TupleFilter(_first.clone(clone_mode), _rest.clone(clone_mode));
      }
 
      void clone(const TupleFilter & other, CloneMode clone_mode = CloneMode::Deep)
      {
        _first.clone(other._first, clone_mode);
        _rest.clone(other._rest, clone_mode);
      }
 
      template<typename... SubFilter2_>
      void convert(const TupleFilter<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);
      }
 
      void filter_rhs(VectorType& vector) const
      {
        first().filter_rhs(vector.first());
        rest().filter_rhs(vector.rest());
      }
 
      void filter_sol(VectorType& vector) const
      {
        first().filter_sol(vector.first());
        rest().filter_sol(vector.rest());
      }
 
      void filter_def(VectorType& vector) const
      {
        first().filter_def(vector.first());
        rest().filter_def(vector.rest());
      }
 
      void filter_cor(VectorType& vector) const
      {
        first().filter_cor(vector.first());
        rest().filter_cor(vector.rest());
      }
    }; // class TupleFilter
 
    template<typename First_>
    class TupleFilter<First_>
    {
      template<typename,typename...>
      friend class TupleFilter;
 
    public:
      static constexpr int num_blocks = 1;
 
      typedef typename First_::DataType DataType;
      typedef typename First_::IndexType IndexType;
 
      typedef TupleVector<typename First_::VectorType> VectorType;
 
      template <typename DT2_ = DataType, typename IT2_ = IndexType>
      using FilterType = TupleFilter<typename First_::template FilterType<DT2_, IT2_> >;
 
      template <typename DataType2_, typename IndexType2_>
      using FilterTypeByDI = FilterType<DataType2_, IndexType2_>;
 
    protected:
      First_ _first;
 
    public:
      TupleFilter()
      {
      }
 
      explicit TupleFilter(First_&& the_first) :
        _first(std::forward<First_>(the_first))
      {
      }
 
      TupleFilter(TupleFilter&& other) :
        _first(std::forward<First_>(other._first))
      {
      }
 
      TupleFilter& operator=(TupleFilter&& other)
      {
        if(this != &other)
        {
          _first = std::forward<First_>(other._first);
        }
        return *this;
      }
 
      TupleFilter clone(CloneMode clone_mode = CloneMode::Deep) const
      {
        return TupleFilter(_first.clone(clone_mode));
      }
 
      void clone(const TupleFilter & other, CloneMode clone_mode = CloneMode::Deep)
      {
        _first.clone(other._first, clone_mode);
      }
 
      template<typename SubFilter2_>
      void convert(const TupleFilter<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();
      }
 
      void filter_rhs(VectorType& vector) const
      {
        first().filter_rhs(vector.first());
      }
 
      void filter_sol(VectorType& vector) const
      {
        first().filter_sol(vector.first());
      }
 
      void filter_def(VectorType& vector) const
      {
        first().filter_def(vector.first());
      }
 
      void filter_cor(VectorType& vector) const
      {
        first().filter_cor(vector.first());
      }
    }; // class TupleFilter
  } // namespace LAFEM
} // namespace FEAT