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/rule.hpp>
 
namespace FEAT
{
  namespace Cubature
  {
    namespace Intern
    {
      template<
        typename Driver_,
        bool variadic_ = Driver_::variadic>
      class DriverFactoryAliasMapper;
    } // namespace Intern
 
    template<
      template<typename> class Driver_,
      typename Shape_,
      bool variadic_ = Driver_<Shape_>::variadic>
    class DriverFactory DOXY({});
 
    template<
      template<typename> class Driver_,
      typename Shape_>
    class DriverFactory<Driver_, Shape_, false>
    {
    public:
      typedef Driver_<Shape_> DriverType;
      typedef Shape_ ShapeType;
      static constexpr bool variadic = false;
      static constexpr int num_points = DriverType::num_points;
 
    public:
      DriverFactory()
      {
      }
 
      template<typename Weight_, typename Coord_, typename Point_>
      static bool create(Rule<Shape_, Weight_, Coord_, Point_>& rule)
      {
        rule = Rule<Shape_, Weight_, Coord_, Point_>(DriverType::num_points, DriverType::name());
        DriverType::fill(rule);
        return true;
      }
 
      template<typename Weight_, typename Coord_, typename Point_>
      static bool create(Rule<Shape_, Weight_, Coord_, Point_>& 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<...,false>
 
    template<
      template<typename> class Driver_,
      typename Shape_>
    class DriverFactory<Driver_, Shape_, true>
    {
    public:
      typedef Driver_<Shape_> DriverType;
      typedef Shape_ ShapeType;
      static constexpr bool variadic = true;
      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_, typename Point_>
      bool create(Rule<Shape_, Weight_, Coord_, Point_>& rule)
      {
        return create(rule, _num_points);
      }
 
      template<typename Weight_, typename Coord_, typename Point_>
      static bool create(Rule<Shape_, Weight_, Coord_, Point_>& rule, int num_points)
      {
        if((num_points < DriverType::min_points) || (num_points > DriverType::max_points))
          return false;
 
        rule = Rule<Shape_, Weight_, Coord_, Point_>(DriverType::count(num_points),
          (DriverType::name() + ":" + stringify(num_points)));
        DriverType::fill(rule, num_points);
        return true;
      }
 
      template<typename Weight_, typename Coord_, typename Point_>
      static bool create(Rule<Shape_, Weight_, Coord_, Point_>& rule, const String& name)
      {
        // map alias names
        Intern::DriverFactoryAliasMapper<DriverType> mapper(name);
        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<...,true>
 
    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 Cubature
} // namespace FEAT