TypeTraits.h

/*
This file is part of Hummingbird, a modern user interface library.

Copyright (c) 2012-2017 Coherent Labs AD and/or its licensors. All
rights reserved in all media.

The coded instructions, statements, computer programs, and/or related
material (collectively the "Data") in these files contain confidential
and unpublished information proprietary Coherent Labs and/or its
licensors, which is protected by United States of America federal
copyright law and by international treaties.

This software or source code is supplied under the terms of a license
agreement and nondisclosure agreement with Coherent Labs AD and may
not be copied, disclosed, or exploited except in accordance with the
terms of that agreement. The Data may not be disclosed or distributed to
third parties, in whole or in part, without the prior written consent of
Coherent Labs AD.

COHERENT LABS MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS
SOURCE CODE FOR ANY PURPOSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER, ITS AFFILIATES,
PARENT COMPANIES, LICENSORS, SUPPLIERS, OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OR PERFORMANCE OF THIS SOFTWARE OR SOURCE CODE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once

#include <cohtml/Config.h>

#if defined(COHERENT_COMPILER_SUPPORTS_IS_ENUM)
#include <type_traits>
#endif

namespace cohtml
{
template <bool v>
struct BoolConstant
{
    enum { Value = v };
};

typedef BoolConstant<true> TrueType;
typedef BoolConstant<false> FalseType;

#if defined(COHERENT_COMPILER_SUPPORTS_IS_ENUM)
template <typename T>
struct IsExposedByRef : BoolConstant<std::is_enum<T>::value>
{
};
#else
template <typename T>
struct IsExposedByRef : FalseType
{
};
#endif

template <typename T>
struct IsExposedByRef<T&> : TrueType
{
};

template <>
struct IsExposedByRef<bool> : TrueType
{
};

template <>
struct IsExposedByRef<signed int> : TrueType
{
};

template <>
struct IsExposedByRef<unsigned int> : TrueType
{
};

template <>
struct IsExposedByRef<signed long> : TrueType
{
};

template <>
struct IsExposedByRef<unsigned long> : TrueType
{
};

template <>
struct IsExposedByRef<signed long long> : TrueType
{
};

template <>
struct IsExposedByRef<unsigned long long> : TrueType
{
};

template <>
struct IsExposedByRef<signed char> : TrueType
{
};

template <>
struct IsExposedByRef<unsigned char> : TrueType
{
};

template <>
struct IsExposedByRef<float> : TrueType
{
};

template <>
struct IsExposedByRef<double> : TrueType
{
};

template <>
struct IsExposedByRef<char*> : TrueType
{
};

template <>
struct IsExposedByRef<wchar_t*> : TrueType
{
};

template <>
struct IsExposedByRef<const bool> : TrueType
{
};

template <>
struct IsExposedByRef<const signed int> : TrueType
{
};

template <>
struct IsExposedByRef<const unsigned int> : TrueType
{
};

template <>
struct IsExposedByRef<const signed long> : TrueType
{
};

template <>
struct IsExposedByRef<const unsigned long> : TrueType
{
};

template <>
struct IsExposedByRef<const signed long long> : TrueType
{
};

template <>
struct IsExposedByRef<const unsigned long long> : TrueType
{
};

template <>
struct IsExposedByRef<const signed char> : TrueType
{
};

template <>
struct IsExposedByRef<const unsigned char> : TrueType
{
};

template <>
struct IsExposedByRef<const float> : TrueType
{
};

template <>
struct IsExposedByRef<const double> : TrueType
{
};

template <>
struct IsExposedByRef<const char*> : TrueType
{
};

template <>
struct IsExposedByRef<const wchar_t*> : TrueType
{
};

template <typename T>
struct ReturnsByRef : FalseType
{
};

template <typename T, typename C>
struct ReturnsByRef<T(C::*)> : TrueType
{
    typedef T& ValuePassType;
};

template <typename T, typename C>
struct ReturnsByRef<T(C::*)()> : IsExposedByRef<T>
{
    typedef T ValuePassType;
};

template <typename T, typename C>
struct ReturnsByRef<T(C::*)() const> : IsExposedByRef<T>
{
    typedef T ValuePassType;
};

template <typename T, typename C>
struct ReturnsByRef<T& (C::*)()> : IsExposedByRef<T&>
{
    typedef const T& ValuePassType;
};

template <typename T, typename C>
struct ReturnsByRef<T& (C::*)() const> : IsExposedByRef<T&>
{
    typedef const T& ValuePassType;
};

template <typename T>
struct RemoveConstRef
{
    typedef T Type;
};

template <typename T>
struct RemoveConstRef<const T>
{
    typedef T Type;
};

template <typename T>
struct RemoveConstRef<T &>
{
    typedef T Type;
};

template <typename T>
struct RemoveConstRef<const T &>
{
    typedef T Type;
};

template <typename T>
struct PointerTrait : FalseType
{
    typedef T StoredType;

    static void* Deref(T& ptr)
    {
        return &ptr;
    }
};

template <typename T>
struct UnwrapPointer : PointerTrait<T>
{
    static void* Unwrap(T* ptr)
    {
        if (!ptr || !PointerTrait<T>::Value)
        {
            return ptr;
        }
        typedef typename RemoveConstRef<typename PointerTrait<T>::StoredType>::Type ClearedStoredType;
        return UnwrapPointer<ClearedStoredType>::Unwrap((ClearedStoredType*)PointerTrait<T>::Deref(*ptr));
    }
};

template <typename T, bool v>
struct UnwrapPointerType
{
    typedef T Type;
};

template <typename T>
struct UnwrapPointerType<T, true>
{
    typedef typename PointerTrait<T>::StoredType StoredType;
    typedef typename RemoveConstRef<StoredType>::Type ClearedStoredType;
    typedef typename UnwrapPointerType<ClearedStoredType, PointerTrait<ClearedStoredType>::Value>::Type Type;
};

template <typename T>
struct PointerTrait<T*> : TrueType
{
    typedef T StoredType;
    static void* Deref(T*& ptr)
    {
        return ptr;
    }
};

template <typename T>
struct PointerTrait<const T*> : TrueType
{
    typedef T StoredType;
    static void* Deref(const T*& ptr)
    {
        return const_cast<T*&>(ptr);
    }
};

template <bool Test, typename T = void>
struct EnableIf
{
};

template <typename T>
struct EnableIf<true, T>
{
    typedef T Type;
};

}