polymorphicsmallobject.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_FUNCTIONS_COMMON_POLYMORPHICSMALLOBJECT_HH
#define DUNE_FUNCTIONS_COMMON_POLYMORPHICSMALLOBJECT_HH
 
#include <utility>
#include <type_traits>
 
#include <dune/common/std/type_traits.hh>
#include <dune/common/hybridutilities.hh>
 
namespace Dune {
namespace Functions {
 
 
template<class Base, size_t bufferSize>
class PolymorphicSmallObject
{
public:
 
  PolymorphicSmallObject() :
    p_(nullptr)
  {}
 
  template<class Derived,
        typename std::enable_if<std::is_base_of<Base, std::remove_cv_t<
          std::remove_reference_t<Derived>>>::value, int>::type = 0>
  PolymorphicSmallObject(Derived&& derived)
  {
    using namespace Dune::Hybrid;
    auto useBuffer = Dune::Std::bool_constant<(sizeof(Derived) <= bufferSize)>();
    ifElse(useBuffer, [&](auto id) {
      p_ = new (&buffer_) Derived(std::forward<Derived>(derived));
    }, [&](auto id) {
      p_ = new Derived(std::forward<Derived>(derived));
    });
  }
 
  PolymorphicSmallObject(PolymorphicSmallObject&& other)
  {
    moveToWrappedObject(std::move(other));
  }
 
  PolymorphicSmallObject(const PolymorphicSmallObject& other)
  {
    copyToWrappedObject(other);
  }
 
  ~PolymorphicSmallObject()
  {
    destroyWrappedObject();
  }
 
  PolymorphicSmallObject& operator=(const PolymorphicSmallObject& other)
  {
    if (&other!=this)
    {
      destroyWrappedObject();
      copyToWrappedObject(other);
    }
    return *this;
  }
 
  PolymorphicSmallObject& operator=(PolymorphicSmallObject&& other)
  {
    destroyWrappedObject();
    moveToWrappedObject(std::move(other));
    return *this;
  }
 
  explicit operator bool() const
  {
    return p_;
  }
 
  bool bufferUsed() const
  {
    return ((void*) (p_) == (void*)(&buffer_));
  }
 
  const Base& get() const
  {
    return *p_;
  }
 
  Base& get()
  {
    return *p_;
  }
 
private:
 
  void destroyWrappedObject()
  {
    if (operator bool())
    {
      if (bufferUsed())
        p_->~Base();
      else
        delete p_;
    }
  }
 
  void moveToWrappedObject(PolymorphicSmallObject&& other)
  {
    if (other.bufferUsed())
      p_ = other.p_->move(&buffer_);
    else
    {
      // We don't need to check for &other_!=this, because you can't
      // have an rvalue to *this and call it's assignment/constructor
      // at the same time. (Despite trying to shoot yourself in the foot
      // with std::move explicitly.)
 
      // Take ownership of allocated object
      p_ = other.p_;
 
      // Leave pointer in a clean state to avoid double freeing it.
      other.p_ = 0;
    }
  }
 
  void copyToWrappedObject(const PolymorphicSmallObject& other)
  {
    if (other.bufferUsed())
      p_ = other.p_->clone(&buffer_);
    else
      p_ = other.p_->clone();
  }
 
  std::aligned_storage_t<bufferSize> buffer_;
  Base* p_;
};
 
 
} // namespace Functions
} // namespace Dune
 
#endif // DUNE_FUNCTIONS_COMMON_POLYMORPHICSMALLOBJECT_HH