type_info.h

 
#ifndef _TypeInfo_h_
#define _TypeInfo_h_
 
#include <system/shared_ptr.h>
#include <system/reflection/binding_flags.h>
#include <system/reflection.h>
 
#include <memory>
#include <vector>
#include <functional>
#include <type_traits>
#include <cwchar>
#include <iosfwd>
#include <map>
 
#include <fwd.h>
 
namespace System { namespace Reflection { class Assembly; } }
namespace System { namespace Reflection { class MemberInfo; }}
namespace System { namespace Reflection { class MethodInfo; }}
namespace System { namespace Reflection { class PropertyInfo; } }
namespace System { namespace Reflection { class ConstructorInfo; }}
namespace System { namespace Reflection { class FieldInfo; } }
 
namespace System
{
 
class Object;
class String;
 
template<unsigned i>
class StringHashCompiletime
{
public:
    static void Hash(uint32_t &hash, int strLen, const char_t *input)
    {
        hash = input[strLen - i] + (hash << 6) + (hash << 16) - hash;
        StringHashCompiletime<i - 1>::Hash(hash, strLen, input);
    }
};
 
template<>
class StringHashCompiletime<0>
{
public:
    static void Hash(uint32_t &hash, int strLen, const char_t* input)
    {
        ASPOSE_UNUSED(hash);
        ASPOSE_UNUSED(strLen);
        ASPOSE_UNUSED(input);
    }
};
 
class TypeInfo;
 
struct TypeInfoPtr
{
    std::unique_ptr<TypeInfo> ptr;
    operator TypeInfo*()
    {
        return ptr.get();
    }
 
    TypeInfoPtr() = default;
 
    ASPOSECPP_SHARED_API TypeInfoPtr(const std::type_info& info);
 
    ASPOSECPP_SHARED_API TypeInfoPtr(const char_t* name, uint32_t hash);
 
    ASPOSECPP_SHARED_API TypeInfoPtr(const char_t* name);
 
    ASPOSECPP_SHARED_API TypeInfoPtr(const String& name);
 
    ASPOSECPP_SHARED_API ~TypeInfoPtr();
};
 
class TypeInfoImpl;
 
class ASPOSECPP_SHARED_CLASS TypeInfo
{
    friend class TypeInfoImpl;
 
    typedef SharedPtr<Object> ObjectPtr;
    typedef const TypeInfo& (*GetTypeInfoFunPtr)();
 
    std::shared_ptr<TypeInfoImpl> m_pimpl;
    TypeInfoImpl *getPipml() const;
 
 
public:
    static uint32_t StringHash(const char_t *str)
    {
        uint32_t hash = 0;
 
        while (char_t c = *str++)
            hash = c + (hash << 6) + (hash << 16) - hash;
 
        return hash;
    }
    
    ASPOSECPP_SHARED_API TypeInfo();
    ASPOSECPP_SHARED_API TypeInfo(std::nullptr_t);
    ASPOSECPP_SHARED_API TypeInfo(const char_t* name);
    ASPOSECPP_SHARED_API TypeInfo(const char_t* name, uint32_t hash);
    ASPOSECPP_SHARED_API TypeInfo(const std::type_info& info);
 
    ASPOSECPP_SHARED_API String get_Name() const;
 
    ASPOSECPP_SHARED_API String get_Namespace() const;
 
    ASPOSECPP_SHARED_API String get_FullName() const;
 
    ASPOSECPP_SHARED_API System::SharedPtr<System::Reflection::Assembly> get_Assembly() const;
 
    ASPOSECPP_SHARED_API String get_AssemblyQualifiedName() const;
 
    ASPOSECPP_SHARED_API bool IsSubclassOf(const TypeInfo& type) const;
 
    ASPOSECPP_SHARED_API bool IsInstanceOfType(const SharedPtr<Object>& obj) const;
 
    ASPOSECPP_SHARED_API bool IsAssignableFrom(const TypeInfo& type) const;
 
    ASPOSECPP_SHARED_API bool IsDefined(const TypeInfo& attributeType, bool inherit) const;
 
    ASPOSECPP_SHARED_API bool get_IsSealed() const;
    ASPOSECPP_SHARED_API bool get_IsInterface() const;
    ASPOSECPP_SHARED_API bool get_IsAbstract() const;
    ASPOSECPP_SHARED_API bool get_IsEnum() const;
    ASPOSECPP_SHARED_API bool get_IsArray() const;
    ASPOSECPP_SHARED_API bool get_IsClass() const;
    ASPOSECPP_SHARED_API bool get_IsValueType() const;
    ASPOSECPP_SHARED_API bool get_IsVisible() const;
    ASPOSECPP_SHARED_API bool get_ContainsGenericParameters() const;
    // /Gets a value indicating whether the current type is a generic type
    ASPOSECPP_SHARED_API bool get_IsGenericType() const;
    ASPOSECPP_SHARED_API bool get_IsGenericTypeDefinition() const;
    ASPOSECPP_SHARED_API ArrayPtr<TypeInfo> get_GenericTypeArguments() const;
    ASPOSECPP_SHARED_API ArrayPtr<TypeInfo> GetGenericArguments() const;
 
    ASPOSECPP_SHARED_API ArrayPtr<TypeInfo> GetInterfaces() const;
 
    ASPOSECPP_SHARED_API TypeInfo GetElementType() const;
 
    ASPOSECPP_SHARED_API ArrayPtr<SharedPtr<System::Reflection::ConstructorInfo>> GetConstructors(System::Reflection::BindingFlags bindingAttr) const;
    ASPOSECPP_SHARED_API ArrayPtr<SharedPtr<System::Reflection::ConstructorInfo>> GetConstructors() const;
    ASPOSECPP_SHARED_API SharedPtr<System::Reflection::ConstructorInfo> GetConstructor(const ArrayPtr<TypeInfo>& types) const;
 
    ASPOSECPP_SHARED_API String ToString() const;
 
    ASPOSECPP_SHARED_API uint32_t Hash() const;
 
    int GetHashCode() const
    {
        return Hash();
    }
 
    bool Equals(const TypeInfo& other) const
    {
        return *this == other;
    }
 
    bool operator == (const TypeInfo& info) const
    {
        if (*this == nullptr && info == nullptr)
        {
            return true;
        }
 
        if (*this == nullptr || info == nullptr)
        {
            return false;
        }
 
        return Hash() == info.Hash();
    }
 
    bool operator != (const TypeInfo& info) const
    {
        return !operator==(info);
    }
        
    bool operator == (std::nullptr_t) const
    {
        return !m_pimpl;
    }
 
    bool operator != (std::nullptr_t) const
    {
        return !!m_pimpl;
    }
 
    ASPOSECPP_SHARED_API void AddAttribute(const ObjectPtr& attribute);
    ASPOSECPP_SHARED_API void AddMember(const SharedPtr<System::Reflection::MemberInfo>& member);
    ASPOSECPP_SHARED_API ArrayPtr<SharedPtr<System::Reflection::MemberInfo>> GetMember(const String& name) const;
    ASPOSECPP_SHARED_API ArrayPtr<SharedPtr<System::Reflection::MemberInfo>> get_DeclaredMember(const String& name) const;
    ASPOSECPP_SHARED_API SharedPtr<System::Reflection::MethodInfo> GetMethod(const String& name) const;
 
    ASPOSECPP_SHARED_API ArrayPtr<SharedPtr<System::Reflection::PropertyInfo>> GetProperties() const;
    ASPOSECPP_SHARED_API ArrayPtr<SharedPtr<System::Reflection::PropertyInfo>> GetProperties(System::Reflection::BindingFlags bindingAttr) const;
    ASPOSECPP_SHARED_API ArrayPtr<SharedPtr<System::Reflection::FieldInfo>> GetFields(System::Reflection::BindingFlags bindingAttr) const;
    ASPOSECPP_SHARED_API SharedPtr<System::Reflection::FieldInfo> GetField(const System::String& name, System::Reflection::BindingFlags bindingAttr) const;
 
    ASPOSECPP_SHARED_API ObjectPtr GetCustomAttribute(const TypeInfo& attributeType) const;
 
    ASPOSECPP_SHARED_API ArrayPtr<ObjectPtr> GetCustomAttributes() const;
    ASPOSECPP_SHARED_API ArrayPtr<ObjectPtr> GetCustomAttributes(const TypeInfo& attributeType, bool inherit) const;
 
    ASPOSECPP_SHARED_API TypeInfo get_BaseType() const;
    ASPOSECPP_SHARED_API void SetBaseType(GetTypeInfoFunPtr basetype);
    ASPOSECPP_SHARED_API void SetTemplParamType(const TypeInfo& templParam);
 
    ASPOSECPP_SHARED_API TypeInfo GetTemplParamType() const;
 
    ASPOSECPP_SHARED_API void reset();
 
    template <class T> inline void AddDefaultConstructor();
 
    typedef std::function<ObjectPtr()> DefaultConstructor;
 
    ASPOSECPP_SHARED_API void AddDefaultConstructor(DefaultConstructor method);
 
    ASPOSECPP_SHARED_API void set_IsValueType(bool value);
 
    template <class T> static inline const TypeInfo& BoxedValueType()
    {
        return *System::static_holder<TypeInfo::BoxedValue<T>>();
    }
 
    template <class T> struct BoxedValue : TypeInfoPtr
    {
        BoxedValue()
            : TypeInfoPtr(typeid(BoxedValue<T>))
        {}
    };
 
    ASPOSECPP_SHARED_API static ArrayPtr<TypeInfo> EmptyTypes;
 
    ASPOSECPP_SHARED_API static TypeInfo EmptyType;
 
    static const TypeInfo& Type();
 
};
 
ASPOSECPP_SHARED_API std::ostream& operator<<(std::ostream& stream, const TypeInfo& type_info);
 
ASPOSECPP_SHARED_API std::wostream& operator<<(std::wostream& stream, const TypeInfo& type_info);
 
} // namespace System
 
namespace std
{
template<>
struct hash<System::TypeInfo> {
public:
    size_t operator()(const System::TypeInfo &ti) const
    {
        return ti.Hash();
    }
};
}
 
#endif // _TypeInfo_h_