Program Listing for File numeric_limits.hpp

↰ Return to documentation for file (include/ecl/type_traits/numeric_limits.hpp)

/*****************************************************************************
** Ifdefs
*****************************************************************************/

#ifndef ECL_TYPE_TRAITS_NUMERIC_LIMITS_HPP_
#define ECL_TYPE_TRAITS_NUMERIC_LIMITS_HPP_

/*****************************************************************************
** Includes
*****************************************************************************/

#include <limits>
#include <climits>
#include <ecl/config/portable_types.hpp>
#include "macros.hpp"

/*****************************************************************************
** Namespaces
*****************************************************************************/

namespace ecl {

/*****************************************************************************
** Parent Template
*****************************************************************************/
template <typename T>
class ecl_type_traits_PUBLIC numeric_limits : public std::numeric_limits<T> {
public:
    numeric_limits() {}
private:
};

/*****************************************************************************
** Specialisations
*****************************************************************************/
template <>
class ecl_type_traits_PUBLIC numeric_limits<char> : public std::numeric_limits<char> {
public:
    static const char one = 1;
    static const uint16 bits = ECL_SIZE_OF_CHAR*8;
    static const uint16 bytes = ECL_SIZE_OF_CHAR;
    static const char minimum = CHAR_MIN;
    static const char maximum = CHAR_MAX;

    typedef float Precision;
    static const Precision dummy_precision;
};

template <>
class ecl_type_traits_PUBLIC numeric_limits<unsigned char> : public std::numeric_limits<unsigned char> {
public:
    static const unsigned char one = 1U;
    static const uint16 bits = ECL_SIZE_OF_CHAR*8;
    static const uint16 bytes = ECL_SIZE_OF_CHAR;
    static const unsigned char minimum = 0U;
    static const unsigned char maximum = UCHAR_MAX;

    typedef float Precision;
    static const Precision dummy_precision;
};

template <>
class ecl_type_traits_PUBLIC numeric_limits<short> : public std::numeric_limits<short> {
public:
    static const short one = 1;
    static const uint16 bits = ECL_SIZE_OF_SHORT*8;
    static const uint16 bytes = ECL_SIZE_OF_SHORT;
    static const short minimum = SHRT_MIN;
    static const short maximum = SHRT_MAX;

    typedef float Precision;
    static const Precision dummy_precision;
};

template <>
class ecl_type_traits_PUBLIC numeric_limits<unsigned short> : public std::numeric_limits<unsigned short> {
public:
    static const unsigned short one = 1U;
    static const uint16 bits = ECL_SIZE_OF_SHORT*8;
    static const uint16 bytes = ECL_SIZE_OF_SHORT;
    static const unsigned short minimum = 0U;
    static const unsigned short maximum = USHRT_MAX;

    typedef float Precision;
    static const Precision dummy_precision;
};

template <>
class ecl_type_traits_PUBLIC numeric_limits<int> : public std::numeric_limits<int> {
public:
    static const int one = 1;
    static const uint16 bits = ECL_SIZE_OF_INT*8;
    static const uint16 bytes = ECL_SIZE_OF_INT;
    static const int minimum = INT_MIN;
    static const int maximum = INT_MAX;

    typedef float Precision;
    static const Precision dummy_precision;
};

template <>
class ecl_type_traits_PUBLIC numeric_limits<unsigned int> : public std::numeric_limits<unsigned int> {
public:
    static const unsigned int one = 1U;
    static const uint16 bits = ECL_SIZE_OF_INT*8;
    static const uint16 bytes = ECL_SIZE_OF_INT;
    static const unsigned int minimum = 0U;
    static const unsigned int maximum = UINT_MAX;

    typedef float Precision;
    static const Precision dummy_precision;
};


template <>
class ecl_type_traits_PUBLIC numeric_limits<long> : public std::numeric_limits<long> {
public:
    static const long one = 1L;
    static const uint16 bits = ECL_SIZE_OF_LONG*8;
    static const uint16 bytes = ECL_SIZE_OF_LONG;
    static const long minimum = LONG_MIN;
    static const long maximum = LONG_MAX;

    typedef float Precision;
    static const Precision dummy_precision;
};

template <>
class ecl_type_traits_PUBLIC numeric_limits<unsigned long> : public std::numeric_limits<unsigned long> {
public:
    static const unsigned long one = 1UL;
    static const uint16 bits = ECL_SIZE_OF_LONG*8;
    static const uint16 bytes = ECL_SIZE_OF_LONG;
    static const unsigned long minimum = 0UL;
    static const unsigned long maximum = ULONG_MAX;

    typedef float Precision;
    static const Precision dummy_precision;
};

template <>
class ecl_type_traits_PUBLIC numeric_limits<long long> : public std::numeric_limits<long long> {
public:
    static const long long one = 1LL;
    static const uint16 bits = ECL_SIZE_OF_LONG_LONG*8;
    static const uint16 bytes = ECL_SIZE_OF_LONG_LONG;
    static const long long minimum = LLONG_MIN;
    static const long long maximum = LLONG_MAX;

    typedef float Precision;
    static const Precision dummy_precision;
};

template <>
class ecl_type_traits_PUBLIC numeric_limits<unsigned long long> : public std::numeric_limits<unsigned long long> {
public:
    static const unsigned long long one = 1ULL;
    static const uint16 bits = ECL_SIZE_OF_LONG_LONG*8;
    static const uint16 bytes = ECL_SIZE_OF_LONG_LONG;
    static const unsigned long long minimum = 0ULL;
    static const unsigned long long maximum = ULLONG_MAX;

    typedef float Precision;
    static const Precision dummy_precision;
};

template <>
class ecl_type_traits_PUBLIC numeric_limits<float> : public std::numeric_limits<float> {
public:
    static const uint16 bits = ECL_SIZE_OF_FLOAT*8;
    static const uint16 bytes = ECL_SIZE_OF_FLOAT;

    typedef float Precision;
    static const float dummy_precision;
    static const float minimum;
    static const float maximum;
};

template <>
class ecl_type_traits_PUBLIC numeric_limits<double> : public std::numeric_limits<double> {
public:
    static const uint16 bits = ECL_SIZE_OF_DOUBLE*8;
    static const uint16 bytes = ECL_SIZE_OF_DOUBLE;

    typedef double Precision;
    static const double dummy_precision;
    static const double minimum;
    static const double maximum;
};

template <>
class ecl_type_traits_PUBLIC numeric_limits<long double> : public std::numeric_limits<long double> {
public:
    static const uint16 bits = ECL_SIZE_OF_LONG_DOUBLE*8;
    static const uint16 bytes = ECL_SIZE_OF_LONG_DOUBLE;

    typedef long double Precision;
    static const long double dummy_precision;
    static const long double minimum;
    static const long double maximum;
};


} // namespace ecl

#endif /* ECL_TYPE_TRAITS_NUMERIC_LIMITS_HPP_ */