attribute_set.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/base_header.hpp>
#include <kernel/util/assertion.hpp>
 
// includes, system
#include <vector>
 
namespace FEAT
{
  namespace Geometry
  {
    template<typename DataType_>
    class AttributeSet
    {
    public:
      typedef DataType_ DataType;
 
    protected:
      Index _num_values;
      int _dimension;
      std::vector<DataType> _values;
 
    public:
      explicit AttributeSet(Index num_values, int dimension = 1) :
        _num_values(num_values),
        _dimension(dimension)
      {
        XASSERT((dimension > 0) || (num_values == Index(0)));
        if(num_values > Index(0))
        {
          _values.resize(std::size_t(num_values) * std::size_t(dimension));
        }
      }
 
      AttributeSet(AttributeSet&& other) :
        _num_values(other._num_values),
        _dimension(other._dimension),
        _values(std::forward<std::vector<DataType>>(other._values))
      {
      }
 
      AttributeSet& operator=(AttributeSet&& other)
      {
        // avoid self-move
        if(this == &other)
          return *this;
 
        _num_values = other._num_values;
        _dimension = other._dimension;
        _values = std::forward<std::vector<DataType>>(other._values);
 
        return *this;
      }
 
      virtual ~AttributeSet()
      {
      }
 
      void clone(const AttributeSet& other)
      {
        this->_num_values = other._num_values;
        this->_dimension = other._dimension;
        this->_values = other._values;
      }
 
      AttributeSet clone() const
      {
        AttributeSet ats(this->_num_values, this->_dimension);
        ats._values = this->_values;
        return ats;
      }
 
      std::size_t bytes() const
      {
        return _values.size() * std::size_t(_dimension) * sizeof(DataType);
      }
 
      int get_dimension() const
      {
        return _dimension;
      }
 
      Index get_num_values() const
      {
        return _num_values;
      }
 
      DataType& operator()(Index i, int j)
      {
        ASSERT(i < _num_values);
        ASSERT((j >= 0) && (j < _dimension));
        return _values[std::size_t(i)*std::size_t(_dimension) + std::size_t(j)];
      }
 
      const DataType& operator()(Index i, int j) const
      {
        ASSERT(i < _num_values);
        ASSERT((j >= 0) && (j < _dimension));
        return _values[std::size_t(i)*std::size_t(_dimension) + std::size_t(j)];
      }
 
      // interpret attribute i as raw array and return pointer
      DataType* raw_at(Index i)
      {
        ASSERT(i < _num_values);
        return &_values.data()[std::size_t(i)*std::size_t(_dimension)];
      }
 
      const DataType* raw_at(Index i) const
      {
        ASSERT(i < _num_values);
        return &_values.data()[std::size_t(i)*std::size_t(_dimension)];
      }
 
      static String name()
      {
        return "AttributeSet<...>";
      }
    }; // class AttributeSet<...>
  } // namespace Geometry
} // namespace FEAT