VariantBasedNode.hpp

#pragma once
#include <score/model/tree/InvisibleRootNode.hpp>
 
#include <ossia/detail/nullable_variant.hpp>
 
namespace score
{
 
template <typename... Args>
class VariantBasedNode
{
public:
  using variant_type = ossia::nullable_variant<InvisibleRootNode, Args...>;
 
  VariantBasedNode(const VariantBasedNode& t) = default;
  VariantBasedNode(VariantBasedNode&& t) noexcept = default;
  VariantBasedNode& operator=(const VariantBasedNode& t) = default;
 
  VariantBasedNode()
      : m_data{InvisibleRootNode{}}
  {
  }
 
  template <typename T>
  VariantBasedNode(const T& t)
      : m_data{t}
  {
  }
 
  template <typename T>
  bool is() const
  {
    return m_data.template target<T>() != nullptr;
  }
 
  template <typename T>
  const T* target() const
  {
    return m_data.template target<T>();
  }
 
  template <typename T>
  T* target()
  {
    return m_data.template target<T>();
  }
 
  template <typename T>
  void set(const T& t)
  {
    m_data = t;
  }
 
  template <typename T>
  const T& get() const
  {
    return *m_data.template target<T>();
  }
 
  template <typename T>
  T& get()
  {
    return *m_data.template target<T>();
  }
 
  auto which() const { return m_data.which(); }
 
  auto& impl() const { return m_data; }
 
  auto& impl() { return m_data; }
 
  bool operator==(const VariantBasedNode& other) const { return m_data == other.m_data; }
 
protected:
  ossia::nullable_variant<InvisibleRootNode, Args...> m_data;
};
}