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 <cstddef>
#include <utility>
#include <type_traits>
#include <algorithm>
 
namespace Dune {
namespace Functions {
 
 
template<class Base, size_t bufferSize>
class PolymorphicSmallObject
{
  // Actual buffer size must be > 0
  static constexpr std::size_t actualBufferSize = std::max(sizeof(std::byte), bufferSize);
 
  // Alignment requirement for the buffer. The `Derived` type must have
  // an alignment requirement that is a divisor of `bufferAlignment`
  static constexpr std::size_t bufferAlignment = alignof(std::max_align_t);
 
public:
 
  PolymorphicSmallObject() :
    p_(nullptr)
  {}
 
  template<class Derived,
        std::enable_if_t<std::is_base_of_v<Base, std::remove_cv_t<
          std::remove_reference_t<Derived>>>, int> = 0>
  PolymorphicSmallObject(Derived&& derived)
  {
    constexpr bool useBuffer = (sizeof(Derived) <= bufferSize)
        && (bufferAlignment % alignof(Derived) == 0);
 
    if constexpr (useBuffer) {
      p_ = new (&buffer_) Derived(std::forward<Derived>(derived));
    } else {
      p_ = new Derived(std::forward<Derived>(derived));
    }
  }
 
  PolymorphicSmallObject(PolymorphicSmallObject&& other) noexcept
  {
    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) noexcept
  {
    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() noexcept
  {
    if (operator bool())
    {
      if (bufferUsed())
        p_->~Base();
      else
        delete p_;
    }
  }
 
  void moveToWrappedObject(PolymorphicSmallObject&& other) noexcept
  {
    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();
  }
 
  alignas(bufferAlignment) std::byte buffer_[actualBufferSize];
  Base* p_;
};
 
 
} // namespace Functions
} // namespace Dune
 
#endif // DUNE_FUNCTIONS_COMMON_POLYMORPHICSMALLOBJECT_HH