ClassInfo.h

#pragma once

#include <string>
#include <typeindex>
#include <type_traits>

namespace BeeeOn {

class ClassInfo {
private:
        class NoneType {
                NoneType() = delete;
        };

public:
        ClassInfo();
        ClassInfo(const std::type_index &index);
        ClassInfo(const std::type_info &info);

        template <typename T>
        ClassInfo(const T &t): m_index(typeid(t))
        {
                static_assert(!std::is_pointer<T>::value,
                        "for pointers use forPointer() method");
        }

        template <typename T>
        static ClassInfo forPointer(const T *t)
        {
                if (t == NULL)
                        return ClassInfo();

                return ClassInfo(*t);
        }

        template <typename T>
        static ClassInfo forClass()
        {
                return ClassInfo(typeid(T));
        }

        std::string id() const;
        std::string name() const;
        std::type_index index() const;

        template <typename T>
        bool is() const
        {
                return ClassInfo(typeid(T)) == *this;
        }

        bool operator <(const ClassInfo &info) const
        {
                return info.index() < m_index;
        }

        bool operator ==(const ClassInfo &info) const
        {
                return info.index() == m_index;
        }

        bool operator !=(const ClassInfo &info) const
        {
                return info.index() != m_index;
        }

        static ClassInfo byName(const std::string &name);

        template <typename T>
        static void registerClass(const std::string &name)
        {
                registerClassInfo(name, typeid(T));
        }

        template <typename T>
        static std::string repr(const T *t)
        {
                return reprImpl(
                        ClassInfo::forPointer(t),
                        reinterpret_cast<const void *>(t));
        }

protected:
        static void registerClassInfo(
                        const std::string &name,
                        const std::type_info &info);

        static std::string reprImpl(const ClassInfo &c, const void *p);

private:
        std::type_index m_index;
};

#define BEEEON_CLASS_REGISTER(T, name, reg)     \
class reg {                                     \
public:                                         \
        reg()                                   \
        {                                       \
                ClassInfo::                     \
                        registerClass<T>(name); \
        }                                       \
};                                              \
static reg reg##Register;

#define BEEEON_CLASS(T)                         \
namespace BeeeOn {                              \
namespace Reflex {                              \
BEEEON_CLASS_REGISTER(T, #T, Class##__COUNTER__)\
}                                               \
}

}