class_info_detail.h

Go to the documentation of this file.

#ifndef _ADTF_UCOM_ANT_CLASS_INFO_DETAIL_INCLUDES_HEADER_
#define _ADTF_UCOM_ANT_CLASS_INFO_DETAIL_INCLUDES_HEADER_
 
#ifdef GetClassInfo
#undef GetClassInfo
#endif
 
namespace adtf
{
namespace ucom
{
namespace ant
{
namespace detail
{

template<typename T>
class has_class_dependencies_type
{
    struct yes { char x[1];  };
    struct no  { char x[2];  };

    template<typename C>
    static yes exists(typename C::template class_dependencies<static_cast<C*>(nullptr)>* = nullptr);
    template<typename C> static no  exists(...);
 
public:
    static const bool value = sizeof(exists<T>(nullptr)) == sizeof(yes);
};//template<typename T> class has_class_dependencies_type
class has_class_dependencies_type {…};

template<typename T>
class has_class_versions_type
{
    struct yes { char x[1];  };
    struct no  { char x[2];  };

    template<typename C>
    static yes exists(typename C::template class_versions<static_cast<C*>(nullptr)>* = nullptr);
    template<typename C> static no  exists(...);
 
public:
    static const bool value = sizeof(exists<T>(nullptr)) == sizeof(yes);
};//template<typename T> class has_class_versions_type
class has_class_versions_type {…};
 
 
template<typename EnclosingType>
struct class_info_detail
{
private:
    template<typename U, bool = has_class_dependencies_type<U>::value>
    struct class_dependency_traits //false 
    {
        static const tDependencyDescription* dependency_data() { return nullptr; }
        static std::size_t             dependency_size() { return 0; }
    };
    struct class_dependency_traits //false  {…};
 
    template<typename U>
    struct class_dependency_traits <U, true>
    {
        static const tDependencyDescription* dependency_data()
        {
            return U::template class_dependencies<(U*)nullptr>::get_dependencies().data();
        }
        
        static std::size_t dependency_size()
        {
            return U::template class_dependencies<(U*)nullptr>::get_dependencies().size();
        }
    };
    struct class_dependency_traits <U, true> {…};
 
    template<typename U, bool = has_class_versions_type<U>::value>
    struct class_versions_traits //false 
    {   //at least the default version set with ADTF_CLASS_ID() must be considered
        static const tNamedVersion* version_data() { return &DefaultCVersion(); }
        static const std::size_t    version_size() { return 1; }
    };
    struct class_versions_traits //false  {…};
 
    template<typename U>
    struct class_versions_traits <U, true>
    {
        static const tNamedVersion* version_data()
        {
            return U::template class_versions<(U*)nullptr>::get_versions().data();
        }
 
        static const std::size_t version_size()
        {
            return U::template class_versions<(U*)nullptr>::get_versions().size();
        }
    };
    struct class_versions_traits <U, true> {…};
 
public:
    static const adtf::ucom::ant::tNamedVersion& DefaultCVersion()
    {
        using tNamedVersion = adtf::ucom::ant::tNamedVersion;
        static const tNamedVersion oVersion{ UCOM_VERSION_ID, adtf::ucom::get_ucom_version_information() };
        return oVersion;
    }
 
    static const adtf::ucom::ant::iterator_adapter<const adtf::ucom::ant::tNamedVersion,
                                                   adtf::ucom::ant::pointer_iterator>
        CVersions()
    {
        return GetClass_Info().GetCVersions();
    }
 
    static const adtf::ucom::ant::iterator_adapter<const adtf::ucom::ant::tDependencyDescription, 
                                                   adtf::ucom::ant::pointer_iterator>
        CDependencies()
    {
        return GetClass_Info().GetCDependencies();
    }
 
    static const adtf::ucom::cClassInfo& GetClass_Info()
    {   //To prevent information being added twice to the static object, everything
        //has to be passed via initialization
        static const adtf::ucom::cClassInfo s_oClassInfo(
            adtf::ucom::get_class_id<EnclosingType>(),
            adtf::ucom::get_class_label<EnclosingType>(),
            class_dependency_traits<EnclosingType>::dependency_data(),
            class_dependency_traits<EnclosingType>::dependency_size(),
            class_versions_traits<EnclosingType>::version_data(),
            class_versions_traits<EnclosingType>::version_size());
        return s_oClassInfo;
    }
};//struct class_info_detail
struct class_info_detail {…};
 
}//ns detail
}//ns ant
 
namespace detail
{
using ant::detail::class_info_detail;
}//ns detail
 
}//ns ucom
}//ns adtf
 
#endif // _ADTF_UCOM_ANT_CLASS_INFO_DETAIL_INCLUDES_HEADER_