rule.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/util/assertion.hpp>
#include <kernel/util/string.hpp>
 
// includes, system
#include <vector>
 
namespace FEAT
{
  namespace Cubature
  {
    namespace Scalar
    {
      template<
        typename Weight_ = Real,
        typename Coord_ = Real>
      class Rule
      {
      public:
        typedef Weight_ WeightType;
        typedef Coord_ CoordType;
 
      protected:
        String _name;
        int _num_points;
        std::vector<WeightType> _weights;
        std::vector<CoordType> _coords;
 
      public:
        Rule() :
          _name(),
          _num_points(0)
        {
        }
 
        explicit Rule(int num_points, String name) :
          _name(name),
          _num_points(num_points)
        {
          if(num_points > 0)
          {
            _weights.resize(std::size_t(num_points));
            _coords.resize(std::size_t(num_points));
          }
        }
 
        Rule(Rule&& other) :
          _name(other._name),
          _num_points(other._num_points),
          _weights(std::forward<std::vector<WeightType>>(other._weights)),
          _coords(std::forward<std::vector<CoordType>>(other._coords))
        {
          other._name.clear();
          other._num_points = 0;
        }
 
        Rule& operator=(Rule&& other)
        {
          // avoid self-move
          if(this == &other)
            return *this;
 
          _name = other._name;
          _num_points = other._num_points;
          _weights = std::forward<std::vector<WeightType>>(other._weights);
          _coords = std::forward<std::vector<CoordType>>(other._coords);
 
          other._name.clear();
          other._num_points = 0;
 
          return *this;
        }
 
        virtual ~Rule()
        {
        }
 
        Rule clone() const
        {
          Rule rule(_num_points, _name);
          rule._weights = this->_weights;
          rule._coords = this->_coords;
          return rule;
        }
 
        const String& get_name() const
        {
          return _name;
        }
 
        int get_num_points() const
        {
          return _num_points;
        }
 
        WeightType& get_weight(int i)
        {
          ASSERTM(i < _num_points, "weight index out-of-range");
          return _weights[std::size_t(i)];
        }
 
        const WeightType& get_weight(int i) const
        {
          ASSERTM(i < _num_points, "weight index out-of-range");
          return _weights[std::size_t(i)];
        }
 
        CoordType& get_coord(int i)
        {
          ASSERTM(i < _num_points, "point index out-of-range");
          return _coords[std::size_t(i)];
        }
 
        const CoordType& get_coord(int i) const
        {
          ASSERTM(i < _num_points, "point index out-of-range");
          return _coords[std::size_t(i)];
        }
      }; // class Rule<...>
    } // namespace Scalar
  } // namespace Cubature
} // namespace FEAT