YiAny.h

Go to the documentation of this file.

// © You i Labs Inc. 2000-2017. All rights reserved.
#ifndef _YI_ANY_H_
#define _YI_ANY_H_

#include "framework/YiPredef.h"
#include "utility/YiError.h"

#ifdef YI_DEBUG
#include <glm/fwd.hpp>

#if !defined(YI_ROKU) && !defined(YI_TIZEN_NACL)
#define YI_ANY_PROVIDE_TYPE_NAME
#endif

#endif

class CYIUrl;

// The internal storage size of a CYIAny for small types. The size is expanded
// to the nearest multiple of the pointer size.
//
// Objects this size or smaller are stored internally within the CYIAny. Objects
// larger than this are allocated on the heap.
//
// This define is set to the size of a glm::vec3, but expanded to avoid needing
// to include the glm headers.
#define YI_ANY_STORAGE_SIZE (sizeof(float) * 3)

class CYIAny
{
public:

    CYIAny();

    template <typename T>
    CYIAny(const T &value);

    CYIAny(const CYIAny &other);

    ~CYIAny();

    CYIAny &Swap(CYIAny &other);

    CYIAny &operator=(const CYIAny &other);

    template <typename T>
    CYIAny &operator=(const T &value);

    bool Empty() const;

    void Clear();

    template <typename T>
    bool ContainsType() const;

    bool MatchesType(const CYIAny &rOther) const;

    template <typename T>
    T &Get();

    template <typename T>
    const T &Get() const;

    template<typename T>
    static size_t GetRequiredHeapMemory();

    CYIString ToString() const;

private:
    friend class CYIAnyTest;

    // We wrap the template functions in a struct to allow partial specialization on bAllocate.
    template <typename T, bool bAllocate>
    struct TypeTableFunctions
    {
        // Creates a copy of the given value within the CYIAny (allocating storage if necessary.)
        static void Create(CYIAny *pAny, const void *pOther);

        // Gets a pointer to the value contained in this CYIAny (dereferencing to the storage as necessary.)
        static void *GetValue(CYIAny *pAny);

        // Destroys the content of this CYIAny (de-allocating storage if necessary.)
        static void Destroy(CYIAny *pAny);

        // Converts the content of this CYIAny to a string (dereferencing to the storage as necessary.)
        static CYIString ToString(const CYIAny *pAny);
    };

    // The function pointer table implementing operations on a specific static type.
    struct TypeTable
    {
        void (*Create)(CYIAny *pAny, const void *pOther);
        void *(*GetValue)(CYIAny *pAny);
        void (*Destroy)(CYIAny *pAny);
        CYIString (*ToString)(const CYIAny *pAny);
    };

    // Gets the dynamic TypeTable for the given static type.
    template <typename T>
    static TypeTable *GetTypeTable();

    // The table of functions for the type stored in the CYIAny, or nullptr if
    // the CYIAny is empty.
    TypeTable *m_pTypeTable;

#ifdef YI_ANY_PROVIDE_TYPE_NAME
    // The type stored in the CYIAny, as a char array
    const char *m_pTypeName;

    // Returns the demangled type name of the templated type. The function retains ownership of the returned pointer
    template<typename T>
    static const char *GetDemangledTypeName();
#endif

    // The storage for the contained value. If the value fits, it
    // is allocated within the storage via placement new; otherwise
    // a pointer to the value is stored.
    union Storage
    {
    public:
        void *GetVoid() const;

        template <typename T>
        T *GetCast() const;

        template <typename T>
        void Destroy();

    private:
        friend class CYIAnyTest;

        void *m_data[(YI_ANY_STORAGE_SIZE + sizeof(void *) - 1) / sizeof(void *)]; // round up to multiple of sizeof(void *)

#ifdef YI_DEBUG
        struct GlmVec3
        {
            float x, y, z;
        };
        struct GlmVec4
        {
            float x, y, z, w;
        };

        bool m_bool;
        char m_char;
        uint8_t m_uint8;
        int8_t m_int8;
        uint16_t m_uint16;
        int16_t m_int16;
        uint32_t m_uint32;
        int32_t m_int32;
        uint64_t m_uint64;
        int64_t m_int64;
        float m_float;
        double m_double;
        GlmVec3 m_glmVec3;
        GlmVec4 m_glmVec4;

        void *m_voidPointer;
        char *m_charArray;
        CYIString *m_string;
        CYIUrl *m_url;
        glm::mat3 *m_glmMat3;
        glm::mat4 *m_glmMat4;

    public:
        Storage()
        {
            memset(this, 0xFE, sizeof(Storage));
        }
#endif
    } m_storage;
};

#include "framework/YiAny.inl"

#endif // _YI_ANY_H_