limits.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_COMMON_LIMITS_H
#define BALL_COMMON_LIMITS_H

#ifndef BALL_CONFIG_CONFIG_H
# include <BALL/CONFIG/config.h>
#endif

#ifndef BALL_COMMON_GLOBAL_H
# include <BALL/COMMON/global.h>
#endif

#ifdef BALL_HAS_NUMERIC_LIMITS
# include <limits>
#else
# ifdef BALL_HAS_LIMITS_H
#   include <limits.h>
# endif
# ifdef BALL_HAS_VALUES_H
#   include <limits.h>
# endif
#endif

# ifdef BALL_HAS_FLOAT_H
#   include <float.h>
# endif

namespace BALL 
{
  

  template <typename T>
  class BALL_EXPORT Limits
  {
    public:

#ifdef BALL_HAS_NUMERIC_LIMITS


    static T min()  
    { 
      return std::numeric_limits<T>::min(); 
    }

    static T max()  
    { 
      return std::numeric_limits<T>::max(); 
    }
#else
    static T min()  
    { 
      return (T)0; 
    }
    static T max()  
    { 
      return (T)0; 
    }
#endif
  };

#ifndef BALL_HAS_NUMERIC_LIMITS
  
  template <> 
  class BALL_EXPORT Limits<float>
  {
    public:
      
    static float min() 
    {
      return FLT_MIN;
    }

    static float max() 
    {
      return FLT_MAX;
    }
  };

  template <> 
  class BALL_EXPORT Limits<double>
  {
    public:
      
    static double min() 
    {
      return DBL_MIN;
    }

    static double max() 
    {
      return DBL_MAX;
    }
  };

  template <> 
  class BALL_EXPORT Limits<bool>
  {
    public:
      
    static bool min() 
    {
      return false;
    }

    static bool max() 
    {
      return true;
    }
  };

  template <> 
  class BALL_EXPORT Limits<char>
  {
    public:
      
    static char min() 
    {
      return CHAR_MIN;
    }

    static char max() 
    {
      return CHAR_MAX;
    }
  };

  template <> 
  class BALL_EXPORT Limits<signed char>
  {
    public:
      
    static signed char min() 
    {
      return SCHAR_MIN;
    }

    static signed char max() 
    {
      return SCHAR_MAX;
    }
  };

  template <> 
  class BALL_EXPORT Limits<unsigned char>
  {
    public:
      
    static unsigned char min() 
    {
      return 0;
    }

    static unsigned char max() 
    {
      return UCHAR_MAX;
    }
  };

  template <> 
  class BALL_EXPORT Limits<short>
  {
    public:
      
    static short min() 
    {
      return SHRT_MIN;
    }

    static short max() 
    {
      return SHRT_MAX;
    }
  };

  template <> 
  class BALL_EXPORT Limits<unsigned short>
  {
    public:
      
    static unsigned short min() 
    {
      return 0;
    }

    static unsigned short max() 
    {
      return USHRT_MAX;
    }
  };

  template <> 
  class BALL_EXPORT Limits<int>
  {
    public:
      
    static int min() 
    {
      return INT_MIN;
    }

    static int max() 
    {
      return INT_MAX;
    }
  };

  template <> 
  class BALL_EXPORT Limits<unsigned int>
  {
    public:
      
    static unsigned int min() 
    {
      return 0;
    }

    static unsigned int max() 
    {
      return UINT_MAX;
    }
  };

  template <> 
  class BALL_EXPORT Limits<long>
  {
    public:
      
    static long min() 
    {
      return LONG_MIN;
    }

    static long max() 
    {
      return LONG_MAX;
    }
  };

  template <> 
  class BALL_EXPORT Limits<unsigned long>
  {
    public:
      
    static unsigned long min() 
    {
      return 0;
    }

    static unsigned long max() 
    {
      return ULONG_MAX;
    }
  };

#endif // BALL_HAS_NUMERIC_LIMITS

} // namespace BALL

#endif // BALL_COMMON_LIMITS_H