#include "None.hpp"
#include <utils/Vector.hpp>
#include <utils/serialization/filesystem.hpp>
#include <utils/serialization/unordered_map.hpp>
#include <utils/serialization/variant.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/vector.hpp>
#include <cstddef>
#include <filesystem>
#include <memory>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <variant>
#include <vector>

Include dependency graph for Variant.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	ScriptInterface::impl::recursive_variant< Ts >
	Recursive variant implementation. More...

Namespaces
namespace	Utils

namespace	ScriptInterface

namespace	ScriptInterface::impl

Typedefs
using	Utils::Vector3b = Utils::Vector< bool, 3 >

template<class... Ts>
using	ScriptInterface::impl::recursive_variant_add_containers = std::variant< Ts..., std::vector< recursive_variant< Ts... > >, std::unordered_map< int, recursive_variant< Ts... > >, std::unordered_map< std::string, recursive_variant< Ts... > > >
	Helper class to inject STL containers in a recursive variant typelist.

template<typename ObjectType >
using	ScriptInterface::make_recursive_variant = impl::recursive_variant< None, bool, int, std::size_t, double, std::string, std::filesystem::path, ObjectType, Utils::Vector3b, Utils::Vector3i, Utils::Vector2d, Utils::Vector3d, Utils::Vector4d, std::vector< int >, std::vector< double > >
	Helper typedef to generate consistent variant types.

using	ScriptInterface::ObjectRef = std::shared_ptr< ObjectHandle >

using	ScriptInterface::Variant = make_recursive_variant< ObjectRef >
	Possible types for parameters.

using	ScriptInterface::VariantMap = std::unordered_map< std::string, Variant >

Functions
template<typename T >
Variant	ScriptInterface::make_variant (const T &x)
	Make a Variant from argument.

template<typename K , typename V >
auto	ScriptInterface::make_unordered_map_of_variants (std::unordered_map< K, V > const &v)

template<typename T >
auto	ScriptInterface::make_vector_of_variants (std::vector< T > const &v)

template<class T >
constexpr bool	ScriptInterface::is_type (Variant const &v)
	Check is a Variant holds a specific type.

constexpr bool	ScriptInterface::is_none (Variant const &v)

Variables
constexpr const None	ScriptInterface::none {}
	None-"literal".

Classes

Namespaces

Typedefs

Functions

Variables