tags.hh

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=8 sw=2 sts=2:
#ifndef DUNE_PDELAB_BACKEND_ISTL_TAGS_HH
#define DUNE_PDELAB_BACKEND_ISTL_TAGS_HH
 
#include <dune/common/documentation.hh>
#include <dune/pdelab/backend/istl/forwarddeclarations.hh>
#include <cstddef>
 
namespace Dune {
 
  namespace PDELab {
 
    namespace ISTL {
 
      // ********************************************************************************
      // tag definitions
      // ********************************************************************************
 
      namespace tags {
 
        struct block_vector
        {
          typedef block_vector base_tag;
        };
 
        struct dynamic_vector
        {
          typedef dynamic_vector base_tag;
        };
 
 
        struct field_vector
        {
          typedef field_vector base_tag;
        };
 
        struct field_vector_1
          : public field_vector
        {};
 
        struct field_vector_n
          : public field_vector
        {};
 
        struct bcrs_matrix
        {
          typedef bcrs_matrix base_tag;
        };
 
        struct dynamic_matrix
        {
          typedef dynamic_matrix base_tag;
        };
 
 
        struct field_matrix
        {
          typedef field_matrix base_tag;
        };
 
        struct field_matrix_1_any
        {};
 
        struct field_matrix_n_any
        {};
 
        struct field_matrix_any_1
        {};
 
        struct field_matrix_any_m
        {};
 
        struct field_matrix_1_1
          : public field_matrix
          , public field_matrix_1_any
          , public field_matrix_any_1
        {};
 
        struct field_matrix_n_1
          : public field_matrix
          , public field_matrix_n_any
          , public field_matrix_any_1
        {};
 
        struct field_matrix_1_m
          : public field_matrix
          , public field_matrix_1_any
          , public field_matrix_any_m
        {};
 
        struct field_matrix_n_m
          : public field_matrix
          , public field_matrix_n_any
          , public field_matrix_any_m
        {};
 
 
        // ********************************************************************************
        // Tag extraction
        // ********************************************************************************
 
#ifdef DOXYGEN
 
 
        template<typename T>
        struct container
        {
          typedef ImplementationDefined type;
        };
 
#else // DOXYGEN
 
        // There is no standard implementation.
        template<typename T>
        struct container;
 
 
        template<typename Block, typename Alloc>
        struct container<Dune::BlockVector<Block,Alloc> >
        {
          typedef block_vector type;
        };
 
 
        // DynamicVector grew allocator support some time after the 2.3 release,
        // so we have to adjust the forward declaration accordingly
 
        template<typename F, typename Allocator>
        struct container<DynamicVector<F,Allocator> >
        {
          typedef dynamic_vector type;
        };
 
        template<typename F, int n>
        struct container<FieldVector<F,n> >
        {
          typedef field_vector_n type;
        };
 
        template<typename F>
        struct container<FieldVector<F,1> >
        {
          typedef field_vector_1 type;
        };
 
 
        template<typename Block, typename Alloc>
        struct container<Dune::BCRSMatrix<Block,Alloc> >
        {
          typedef bcrs_matrix type;
        };
 
        template<typename F>
        struct container<DynamicMatrix<F> >
        {
          typedef dynamic_matrix type;
        };
 
        template<typename F, int n, int m>
        struct container<FieldMatrix<F,n,m> >
        {
          typedef field_matrix_n_m type;
        };
 
        template<typename F, int n>
        struct container<FieldMatrix<F,n,1> >
        {
          typedef field_matrix_n_1 type;
        };
 
        template<typename F, int m>
        struct container<FieldMatrix<F,1,m> >
        {
          typedef field_matrix_1_m type;
        };
 
        template<typename F>
        struct container<FieldMatrix<F,1,1> >
        {
          typedef field_matrix_1_1 type;
        };
 
#endif // DOXYGEN
 
      } // namespace tags
 
 
      template<typename T>
      typename tags::container<T>::type container_tag(const T&)
      {
        return typename tags::container<T>::type();
      }
 
    } // namespace ISTL
 
  } // namespace PDELab
} // namespace Dune
 
 
 
#endif // DUNE_PDELAB_BACKEND_ISTL_TAGS_HH