localfiniteelement.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
#ifndef DUNE_LOCALFUNCTIONS_COMMON_TYPEERASEDLOCALFINITEELEMENT
#define DUNE_LOCALFUNCTIONS_COMMON_TYPEERASEDLOCALFINITEELEMENT
 
#include <memory>
#include <type_traits>
#include <utility>
 
#include <dune/common/typeutilities.hh>
 
#include <dune/geometry/type.hh>
 
 
#include <dune/localfunctions/common/virtualinterface.hh>
#include <dune/localfunctions/common/virtualwrappers.hh>
 
namespace Dune
{
 
  template<class LBT>
  class LocalFiniteElement
  {
    using LocalBasisTraits = LBT;
    using VirtualLFE = typename Dune::LocalFiniteElementVirtualInterface<LBT>;
 
  public:
 
    using Traits = typename VirtualLFE::Traits;
 
    LocalFiniteElement() = default;
 
    template<class LFEImpl,
      Dune::disableCopyMove<LocalFiniteElement, LFEImpl> = 0 >
    LocalFiniteElement(LFEImpl&& lfe)
      : lfe_(new LocalFiniteElementVirtualImp<std::decay_t<LFEImpl>>(std::forward<LFEImpl>(lfe)))
      , size_(lfe.size())
      , type_(lfe.type())
    {}
 
    LocalFiniteElement(const LocalFiniteElement& other)
      : lfe_(other.lfe_ ? other.lfe_->clone() : nullptr)
      , size_(other.size())
      , type_(other.type())
    {}
 
    LocalFiniteElement(LocalFiniteElement&& other) = default;
 
    LocalFiniteElement& operator=(const LocalFiniteElement& rhs)
    {
      if (&rhs!=this)
      {
        if (rhs.lfe_)
          lfe_.reset(rhs.lfe_->clone());
        else
          lfe_.release();
        size_ = rhs.size();
        type_ = rhs.type();
      }
      return *this;
    }
 
    LocalFiniteElement& operator=(LocalFiniteElement&& other) = default;
 
    operator bool () const
    {
      return lfe_;
    }
 
    const typename Traits::LocalBasisType& localBasis () const
    {
      return lfe_->localBasis();
    }
 
    const typename Traits::LocalCoefficientsType& localCoefficients () const
    {
      return lfe_->localCoefficients();
    }
 
    const typename Traits::LocalInterpolationType& localInterpolation () const
    {
      return lfe_->localInterpolation();
    }
 
    unsigned int size () const
    {
      return size_;
    }
 
    const GeometryType& type () const
    {
      return type_;
    }
 
  private:
    std::unique_ptr<VirtualLFE> lfe_;
    unsigned int size_ = 0;
    Dune::GeometryType type_;
  };
 
}
#endif