driver_factory.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/cubature/scalar/rule.hpp>
 
namespace FEAT
{
  namespace Cubature
  {
    namespace Scalar
    {
      namespace Intern
      {
        template<
          typename Driver_,
          bool variadic_ = Driver_::variadic>
        class DriverFactoryAliasMapper;
      } // namespace Intern
 
      template<
        typename Driver_,
        bool variadic_ = Driver_::variadic>
      class DriverFactory DOXY({});
 
      template<typename Driver_>
      class DriverFactory<Driver_, false>
      {
      public:
        typedef Driver_ DriverType;
 
        static constexpr bool variadic = false;
        static constexpr bool tensorize = DriverType::tensorize;
        static constexpr int num_points = DriverType::num_points;
 
      public:
        DriverFactory()
        {
        }
 
        template<typename Weight_, typename Coord_>
        static bool create(Rule<Weight_, Coord_>& rule)
        {
          // create the rule
          rule = Rule<Weight_, Coord_>(DriverType::num_points, DriverType::name());
          DriverType::fill(rule);
          return true;
        }
 
        template<typename Weight_, typename Coord_>
        static bool create(Rule<Weight_, Coord_>& rule, const String& name)
        {
          // map alias names
          Intern::DriverFactoryAliasMapper<DriverType> mapper(name);
          DriverType::alias(mapper);
          String mapped_name(mapper.name());
 
          // check mapped name
          if(mapped_name.trim().compare_no_case(DriverType::name()) != 0)
            return false;
 
          // create the rule
          return create(rule);
        }
 
        static String name()
        {
          return DriverType::name();
        }
 
        template<typename Functor_>
        static void alias(Functor_& functor)
        {
          DriverType::alias(functor);
        }
      }; // class DriverFactory<...>
 
      template<typename Driver_>
      class DriverFactory<Driver_, true>
      {
      public:
        typedef Driver_ DriverType;
 
        static constexpr bool variadic = true;
        static constexpr bool tensorize = DriverType::tensorize;
        static constexpr int min_points = DriverType::min_points;
        static constexpr int max_points = DriverType::max_points;
 
      protected:
        int _num_points;
 
      public:
        explicit DriverFactory(int num_points) :
          _num_points(num_points)
        {
          XASSERT(num_points >= DriverType::min_points);
          XASSERT(num_points <= DriverType::max_points);
        }
 
        template<typename Weight_, typename Coord_>
        bool create(Rule<Weight_, Coord_>& rule)
        {
          return create(rule, _num_points);
        }
 
        template<typename Weight_, typename Coord_>
        static bool create(Rule<Weight_, Coord_>& rule, int num_points)
        {
          if((num_points < DriverType::min_points) || (num_points > DriverType::max_points))
            return false;
 
          rule = Rule<Weight_, Coord_>(num_points, (DriverType::name() + ":" + stringify(num_points)));
          DriverType::fill(rule, num_points);
          return true;
        }
 
        template<typename Weight_, typename Coord_>
        static bool create(Rule<Weight_, Coord_>& rule, const String& name_in)
        {
          // map alias names
          Intern::DriverFactoryAliasMapper<DriverType> mapper(name_in);
          DriverType::alias(mapper);
          String mapped_name(mapper.name());
 
          // try to find a colon within the string
          String::size_type k = mapped_name.find_first_of(':');
          if(k == mapped_name.npos)
            return false;
 
          // extract substrings until the colon
          String head(mapped_name.substr(0, k));
          String tail(mapped_name.substr(k + 1));
 
          // check head - this is the name of the formula
          if(head.trim().compare_no_case(DriverType::name()) != 0)
            return false;
 
          // check substring
          int num_points = 0;
          if(!tail.trim().parse(num_points))
            return false;
 
          // try to create the rule
          return create(rule, num_points);
        }
 
        static String name()
        {
          return DriverType::name();
        }
 
        template<typename Functor_>
        static void alias(Functor_& functor)
        {
          DriverType::alias(functor);
        }
      }; // class DriverFactory<...>
 
      namespace Intern
      {
        template<typename Driver_>
        class DriverFactoryAliasMapper<Driver_, false>
        {
        private:
          String _name;
          bool _mapped;
 
        public:
          explicit DriverFactoryAliasMapper(const String& name_in) :
            _name(name_in),
            _mapped(false)
          {
          }
 
          void alias(const String& alias_name)
          {
            if(!_mapped)
            {
              if(_name.compare_no_case(alias_name) == 0)
              {
                _name = Driver_::name();
                _mapped = true;
              }
            }
          }
 
          String name()
          {
            return _name;
          }
        };
 
        template<typename Driver_>
        class DriverFactoryAliasMapper<Driver_, true>
        {
        private:
          String _name;
          bool _mapped;
 
        public:
          explicit DriverFactoryAliasMapper(const String& name_in) :
            _name(name_in),
            _mapped(false)
          {
          }
 
          void alias(const String& alias_name, int num_points)
          {
            if(!_mapped)
            {
              if(_name.compare_no_case(alias_name) == 0)
              {
                _name = Driver_::name() + ":" + stringify(num_points);
                _mapped = true;
              }
            }
          }
 
          String name()
          {
            return _name;
          }
        };
      } // namespace Intern
    } // namespace Scalar
  } // namespace Cubature
} // namespace FEAT