utils.h

Go to the documentation of this file.

/*
 * /phoenix/include/triton/utils.h
 *
 * This file is a part of Phoenix operating system.
 * Copyright (c) 2011-2012, Artyom Lebedev <artyom.lebedev@gmail.com>
 * All rights reserved.
 * See COPYING file for copyright details.
 */

#ifndef UTILS_H_
#define UTILS_H_

namespace triton {

/* ************************************************************************** */

namespace triton_internal {

template <typename T>
struct remove_const_impl {
    typedef T type;
};

template <typename T>
struct remove_const_impl<const T> {
    typedef T type;
};

template <typename T>
struct remove_volatile_impl {
    typedef T type;
};

template <typename T>
struct remove_volatile_impl<volatile T> {
    typedef T type;
};

template <typename T>
struct remove_ptr_impl {
    typedef T type;
};

template <typename T>
struct remove_ptr_impl<T *> {
    typedef T type;
};

} /* namespace triton_internal */

template <typename T>
using remove_const = typename triton_internal::remove_const_impl<T>::type;

template <typename T>
using remove_volatile = typename triton_internal::remove_volatile_impl<T>::type;

template <typename T>
using remove_cv = typename triton_internal::remove_volatile_impl<
                  typename triton_internal::remove_const_impl<T>::type>::type;

template <typename T>
using remove_ptr = typename triton_internal::remove_ptr_impl<T>::type;

/* ************************************************************************** */

namespace triton_internal {

/* Conditional template instantiation helpers. Idea borrowed from Boost library. */

template <bool cond, class T = void>
struct enable_if_impl {
    typedef T type;
};

template <class T>
struct enable_if_impl<false, T> {};

template <bool cond, class T = void>
struct disable_if_impl {
    typedef T type;
};

template <class T>
struct disable_if_impl<true, T> {};

} /* namespace triton_internal */

template <bool cond, class T = void>
using enable_if = typename triton_internal::enable_if_impl<cond, T>::type;

template <bool cond, class T = void>
using disable_if = typename triton_internal::enable_if_impl<cond, T>::type;

/* ************************************************************************** */

template <typename T>
using add_const = const T;

template <typename T>
using add_reference = T &;

template <typename T>
using add_const_reference = const T &;

/* ************************************************************************** */
/* Integral constant expressions manipulations. */

namespace triton_internal {

template <bool... values>
struct ice_or_impl;

template <>
struct ice_or_impl<>
{
    static const bool value = false;
};

template <bool... values>
struct ice_or_impl<true, values...>
{
    static const bool value = true;
};

template <bool... values>
struct ice_or_impl<false, values...>
{
    static const bool value = ice_or_impl<values...>::value;
};

template <bool... values>
struct ice_and_impl;

template <>
struct ice_and_impl<>
{
    static const bool value = true;
};

template <bool... values>
struct ice_and_impl<false, values...>
{
    static const bool value = false;
};

template <bool... values>
struct ice_and_impl<true, values...>
{
    static const bool value = ice_and_impl<values...>::value;
};

} /* namespace triton_internal */

template <bool... values>
constexpr bool
ice_or()
{
    return triton_internal::ice_or_impl<values...>::value;
}

template <bool... values>
constexpr bool
ice_and()
{
    return triton_internal::ice_and_impl<values...>::value;
}

template <bool value>
constexpr bool
ice_not()
{
    return true;
}

template <>
constexpr bool
ice_not<true>()
{
    return false;
}

/* ************************************************************************** */

namespace triton_internal {

template <typename T>
constexpr bool
is_integral_impl()
{
    return false;
}

#define TRITON_IS_INTEGRAL_IMPL(__type) \
template <> \
constexpr bool \
is_integral_impl<__type>() \
{ \
    return true; \
}

TRITON_IS_INTEGRAL_IMPL(char)
TRITON_IS_INTEGRAL_IMPL(unsigned char)
TRITON_IS_INTEGRAL_IMPL(wchar_t)
TRITON_IS_INTEGRAL_IMPL(int)
TRITON_IS_INTEGRAL_IMPL(unsigned)
TRITON_IS_INTEGRAL_IMPL(long)
TRITON_IS_INTEGRAL_IMPL(unsigned long)
TRITON_IS_INTEGRAL_IMPL(long long)
TRITON_IS_INTEGRAL_IMPL(unsigned long long)

template <typename T>
constexpr bool
is_float_impl()
{
    return false;
}

#define TRITON_IS_FLOAT_IMPL(__type) \
template <> \
constexpr bool \
is_float_impl<__type>() \
{ \
    return true; \
}

TRITON_IS_FLOAT_IMPL(float)
TRITON_IS_FLOAT_IMPL(double)
TRITON_IS_FLOAT_IMPL(long double)

} /* namespace triton_internal */

template <typename T>
constexpr bool
is_integral()
{
    return triton_internal::is_integral_impl<remove_cv<T>>();
}

template <typename T>
constexpr bool
is_float()
{
    return triton_internal::is_float_impl<remove_cv<T>>();
}

template <typename T>
constexpr bool
is_numeric()
{
    return triton_internal::is_integral_impl<remove_cv<T>>() ||
           triton_internal::is_float_impl<remove_cv<T>>();
}

/* ************************************************************************** */

} /* namespace triton */

#endif /* UTILS_H_ */