constraints.h

 
 
#ifndef _aspose_system_constrains_h_
#define _aspose_system_constrains_h_
 
#include <system/shared_ptr.h>
#include <system/weak_ptr.h>
#include <system/boxable_traits.h>
#include <type_traits>
 
namespace System { namespace Constraints {
 
template <class Base, class Derived>
struct IsBaseOf : std::is_base_of<Base, Derived> {};
 
template <class Base, class Derived>
struct IsBaseOf<Base, SharedPtr<Derived>> : std::is_base_of<Base, Derived> {};
 
template <class Base, class Derived>
struct IsBaseOf<SharedPtr<Base>, SharedPtr<Derived>> : std::is_base_of<Base, Derived> {};
 
template <typename T, typename = void>
struct IsDefaultConstructibleTest : public std::false_type {};
 
template <typename T>
struct IsDefaultConstructibleTest<T, decltype(void(new (std::declval<T*>()) T()))> : public std::true_type {};
 
template <typename T>
struct IsDefaultConstructible : public IsDefaultConstructibleTest<T> {};
 
template <typename T>
struct IsDefaultConstructible<SmartPtr<T>> : public IsDefaultConstructibleTest<T> {};
 
template <typename T>
struct IsCsPointer : std::false_type{};
 
template <class T>
struct IsCsPointer<SharedPtr<T> > : std::true_type {};
 
template <class T>
struct IsCsPointer<WeakPtr<T> > : std::true_type {};
 
template <typename>
struct IsStdTuple : std::false_type {};
 
template <typename T>
struct IsStdTuple<std::tuple<T>> : std::true_type {};
 
}} // namespace System::Constrains
 
 
namespace System {
    class String;
    class DateTime;
    class TimeSpan;
}
 
namespace System { namespace Constraints {
    template<> struct IsCsPointer<System::String> : std::true_type {};
    template<> struct IsCsPointer<System::DateTime> : std::true_type {};
    template<> struct IsCsPointer<System::TimeSpan> : std::true_type {};
}}
 
 
// for translate "where T: A"
#define assert_is_base_of(Base, Derived) \
    static_assert(System::Constraints::IsBaseOf<Base, Derived>::value || System::BoxedValueDetail::ImplementsInterface_v<Derived, Base>, "typename " #Derived " must be child of " #Base)
 
// for translate "where T: new()"
#define assert_is_constructable(T) \
    static_assert(System::Constraints::IsDefaultConstructible<T>::value, "typename " #T " must be default-constructible")
 
// for translate "where T: class"
#define assert_is_cs_class(T) \
    static_assert(System::Constraints::IsCsPointer<T>::value, \
        "typename " #T " must be System::SharedPtr<> or 'force-valued' type")
 
// for translate "where T: struct"
#define assert_is_cs_struct(T) \
    static_assert(!System::Constraints::IsCsPointer<T>::value, \
        "typename " #T " must not be System::SharedPtr<> or 'force-valued' type")
 
#endif // _aspose_system_constrains_h_