plugify/any_8hpp_source.html

 #pragma once


 #include <plugify/numerics.hpp>

 #include <plugify/string.hpp>

 #include <plugify/variant.hpp>

 #include <plugify/vector.hpp>


 namespace plg {

     struct invalid {};

     struct none {};

     union function { void* ptr; };


     using any = variant<

             invalid,


             none,

             bool,

             char,

             char16_t,

             int8_t,

             int16_t,

             int32_t,

             int64_t,

             uint8_t,

             uint16_t,

             uint32_t,

             uint64_t,

             void*,

             float,

             double,

             function,

             string,

             variant<none>,

             vector<bool>,

             vector<char>,

             vector<char16_t>,

             vector<int8_t>,

             vector<int16_t>,

             vector<int32_t>,

             vector<int64_t>,

             vector<uint8_t>,

             vector<uint16_t>,

             vector<uint32_t>,

             vector<uint64_t>,

             vector<void*>,

             vector<float>,

             vector<double>,

             vector<string>,

             vector<variant<none>>,

             vector<vec2>,

             vector<vec3>,

             vector<vec4>,

             vector<mat4x4>,

             vec2,

             vec3,

             vec4

             //mat4x4

             >;

 } // namespace plg

plg::variant
Definition: variant.hpp:539

plg::vector
Definition: vector.hpp:240

plg::invalid
Represents an invalid type.
Definition: any.hpp:9

plg::none
Represents the absence of a value.
Definition: any.hpp:10

plg::vec2
Definition: numerics.hpp:19

plg::vec3
Definition: numerics.hpp:29

plg::vec4
Definition: numerics.hpp:40

plg::function
Represents a function pointer as a union for flexibility.
Definition: any.hpp:11