filter_sequence.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
 
#include <deque>
 
namespace FEAT
{
  namespace LAFEM
  {
    template<typename Filter_>
    class FilterSequence : public std::deque<std::pair<String, Filter_>>
    {
    public:
      typedef std::deque<std::pair<String, Filter_>> BaseClass;
 
      typedef Filter_ InnerFilterType;
      typedef typename Filter_::DataType DataType;
      typedef typename Filter_::IndexType IndexType;
 
      typedef typename Filter_::VectorType VectorType;
 
      typedef typename BaseClass::iterator iterator;
      typedef typename BaseClass::const_iterator const_iterator;
 
      template <typename DT2_, typename IT2_>
      using FilterType = FilterSequence<typename Filter_::template FilterType<DT2_, IT2_> >;
 
      template <typename DT2_, typename IT2_>
      using FilterTypeByDI = FilterType<DT2_, IT2_>;
 
    public:
      FilterSequence()
      {
      }
 
      virtual ~FilterSequence()
      {
      }
 
      explicit FilterSequence(const std::deque<String>& ids_)
      {
        for(auto it = ids_.begin(); it != ids_.end(); ++it)
        {
          String id(*it);
          InnerFilterType new_filter;
          BaseClass::push_back(std::make_pair<String, Filter_>(std::move(id), std::move(new_filter)));
        }
      }
 
      FilterSequence(FilterSequence&& other) :
        BaseClass(std::forward<BaseClass>(other))
      {
      }
 
      FilterSequence& operator=(FilterSequence&& other)
      {
        if(this != &other)
        {
          static_cast<BaseClass&>(*this) = std::forward<BaseClass>(other);
        }
 
        return *this;
      }
 
      FilterSequence clone(CloneMode clone_mode = CloneMode::Deep) const
      {
        FilterSequence result;
        result.resize(this->size());
 
        for(size_t i(0); i < result.size(); ++i)
        {
          result.at(i).first = this->at(i).first;
          result.at(i).second.clone(this->at(i).second, clone_mode);
        }
 
        return result;
      }
 
      void clone(const FilterSequence& other, CloneMode clone_mode = CloneMode::Deep)
      {
        BaseClass::clear();
 
        for(const_iterator it(other.begin()); it != other.end(); ++it)
        {
          BaseClass::push_back(std::make_pair<String, InnerFilterType>(it->first, it->second->clone(clone_mode)));
        }
      }
 
      template<typename OtherFilter_>
      void convert(const FilterSequence<OtherFilter_>& other)
      {
        BaseClass::clear();
 
        BaseClass::resize(other.size());
 
        for(size_t i(0); i < this->size(); ++i)
        {
          this->at(i).first = other.at(i).first;
          this->at(i).second.convert(other.at(i).second);
        }
      }
 
      std::size_t bytes() const
      {
        std::size_t my_bytes(0);
 
        for(size_t i(0); i < this->size(); ++i)
        {
          my_bytes += this->at(i).second.bytes();
        }
 
        return my_bytes;
      }
 
      Filter_& find_or_add(const String& name)
      {
        for(iterator it(BaseClass::begin()); it != BaseClass::end(); ++it)
        {
          if(it->first == name)
            return it->second;
        }
        // if we come out here, we have to add a new sub-filter
        this->push_back(std::make_pair(name, Filter_()));
        return this->back().second;
      }
 
 
      template<typename Vector_>
      void filter_rhs(Vector_& vector) const
      {
        for(const_iterator it(BaseClass::begin()); it != BaseClass::end(); ++it)
          it->second.filter_rhs(vector);
      }
 
      template<typename Vector_>
      void filter_sol(Vector_& vector) const
      {
        for(const_iterator it(BaseClass::begin()); it != BaseClass::end(); ++it)
          it->second.filter_sol(vector);
      }
 
      template<typename Vector_>
      void filter_def(Vector_& vector) const
      {
        for(const_iterator it(BaseClass::begin()); it != BaseClass::end(); ++it)
          it->second.filter_def(vector);
      }
 
      template<typename Vector_>
      void filter_cor(Vector_& vector) const
      {
        for(const_iterator it(BaseClass::begin()); it != BaseClass::end(); ++it)
          it->second.filter_cor(vector);
      }
 
      template<typename Matrix_>
      void filter_mat(Matrix_& matrix) const
      {
        for(const_iterator it(BaseClass::begin()); it != BaseClass::end(); ++it)
          it->second.filter_mat(matrix);
      }
    }; // class FilterSequence
 
  } // namespace LAFEM
} // namespace FEAT