any_8hpp_source.html

#pragma once


#include "numerics.hpp"

#include "string.hpp"

#include "variant.hpp"

#include "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

            >;


    static_assert(sizeof(any) == 32);

} // namespace plg

plg::allocator
Definition allocator.hpp:28

plg::variant
Definition variant.hpp:544

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