BKE_node_socket_value.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "DNA_node_types.h"
 
#include "BLI_any.hh"
#include "BLI_generic_pointer.hh"
 
#include "BKE_node_socket_value_fwd.hh"
 
namespace blender::bke {

class SocketValueVariant {
 private:
  enum class Kind {
    None,
    Single,
    Field,
    Grid,
    List,
  };

  Kind kind_ = Kind::None;
  eNodeSocketDatatype socket_type_;
  Any<void, 24> value_;
 
 public:
  SocketValueVariant() = default;
  SocketValueVariant(const SocketValueVariant &other) = default;
  SocketValueVariant(SocketValueVariant &&other) = default;
  SocketValueVariant &operator=(const SocketValueVariant &other) = default;
  SocketValueVariant &operator=(SocketValueVariant &&other) = default;
  ~SocketValueVariant() = default;

  template<typename T,
           /* The enable-if is necessary to avoid overriding the copy/moveconstructors. */
           BLI_ENABLE_IF((std::is_trivial_v<std::decay_t<T>> ||
                          is_same_any_v<std::decay_t<T>, std::string>))>
  explicit SocketValueVariant(T &&value)
  {
    this->set(std::forward<T>(value));
  }

  template<typename T> static SocketValueVariant &ConstructIn(void *ptr, T &&value);

  template<typename T> static SocketValueVariant From(T &&value);

  bool valid_for_socket(eNodeSocketDatatype socket_type) const;

  template<typename T> T extract();

  template<typename T> T get() const;

  template<typename T> void set(T &&value);

  bool is_context_dependent_field() const;

  bool is_volume_grid() const;

  bool is_single() const;

  bool is_list() const;

  void convert_to_single();

  GPointer get_single_ptr() const;
  GMutablePointer get_single_ptr();

  const void *get_single_ptr_raw() const;

  void store_single(eNodeSocketDatatype socket_type, const void *value);

  void *allocate_single(eNodeSocketDatatype socket_type);
 
  friend std::ostream &operator<<(std::ostream &stream, const SocketValueVariant &value_variant);
 
 private:
  template<typename T> void store_impl(T value);
};
 
template<typename T>
inline SocketValueVariant &SocketValueVariant::ConstructIn(void *ptr, T &&value)
{
  SocketValueVariant *value_variant = new (ptr) SocketValueVariant();
  value_variant->set(std::forward<T>(value));
  return *value_variant;
}
 
template<typename T> inline SocketValueVariant SocketValueVariant::From(T &&value)
{
  SocketValueVariant value_variant;
  value_variant.set(std::forward<T>(value));
  return value_variant;
}
 
template<typename T> inline void SocketValueVariant::set(T &&value)
{
  static_assert(!is_same_any_v<std::decay_t<T>, SocketValueVariant, bke::SocketValueVariant *>);
  this->store_impl<std::decay_t<T>>(std::forward<T>(value));
}
 
inline const void *SocketValueVariant::get_single_ptr_raw() const
{
  BLI_assert(kind_ == Kind::Single);
  return value_.get();
}
 
}  // namespace blender::bke