vrpn_FixedPoint.h

浏览该文件的文档.

 
#ifndef VRPN_FIXED_POINT_H_
#define VRPN_FIXED_POINT_H_
 
// Internal Includes
#include "vrpn_Types.h"
 
// Library/third-party includes
// - none
 
// Standard includes
#include <cstddef> // for NULL
 
namespace vrpn {
 
 namespace detail {
 struct IntegerOverflow;
 
 template <int NUM_BITS> struct IntegerOfSize {
 // An integer requiring n bits can be represented by an integer of
 // size n+1 bits.
 typedef typename IntegerOfSize<NUM_BITS + 1>::type type;
        };
 
 template <> struct IntegerOfSize<8> {
 typedef vrpn_int8 type;
        };
 
 template <> struct IntegerOfSize<16> {
 typedef vrpn_int16 type;
        };
 
 template <> struct IntegerOfSize<32> {
 typedef vrpn_int32 type;
        };
 
 template <> struct IntegerOfSize<64> {
 typedef IntegerOfSize type;
        };
 template <int NUM_BITS> struct UnsignedIntegerOfSize {
 // An integer requiring n bits can be represented by an integer of
 // size n+1 bits.
 typedef typename UnsignedIntegerOfSize<NUM_BITS + 1>::type type;
        };
 
 template <> struct UnsignedIntegerOfSize<8> {
 typedef vrpn_uint8 type;
        };
 
 template <> struct UnsignedIntegerOfSize<16> {
 typedef vrpn_uint16 type;
        };
 
 template <> struct UnsignedIntegerOfSize<32> {
 typedef vrpn_uint32 type;
        };
 
 
 template <int BITS, bool SIGNED = true>
 struct IntegerOfSizeAndSignedness : IntegerOfSize<BITS> {
        };
 template <int BITS>
 struct IntegerOfSizeAndSignedness<BITS, false>
            : UnsignedIntegerOfSize<BITS> {
        };
    } // namespace detail
 
 template <int INTEGER_BITS, int FRACTIONAL_BITS, bool SIGNED = true>
 class FixedPoint {
 public:
 typedef typename detail::IntegerOfSizeAndSignedness<
            INTEGER_BITS, SIGNED>::type IntegerType;
 
 typedef typename detail::IntegerOfSizeAndSignedness<
            INTEGER_BITS + FRACTIONAL_BITS, SIGNED>::type RawType;
 
 FixedPoint()
            : value_(0)
        {
        }
 explicit FixedPoint(
 typename detail::IntegerOfSizeAndSignedness<8, SIGNED>::type x)
            : value_(x)
        {
        }
 explicit FixedPoint(
 typename detail::IntegerOfSizeAndSignedness<16, SIGNED>::type x)
            : value_(x)
        {
        }
 explicit FixedPoint(
 typename detail::IntegerOfSizeAndSignedness<32, SIGNED>::type x)
            : value_(x)
        {
        }
 explicit FixedPoint(double x)
            : value_(x * (1 << FRACTIONAL_BITS))
        {
        }
 explicit FixedPoint(float x)
            : value_(x * (1 << FRACTIONAL_BITS))
        {
        }
 
 
 template <typename T> T get() const
 {
 return get(reinterpret_cast<TypeWrapper<T> *>(NULL));
        }
 
        RawType value() const { return value_; }
 
 private:
 template <typename T> struct TypeWrapper;
        vrpn_float32 get(TypeWrapper<vrpn_float32> *) const
 {
 return static_cast<vrpn_float32>(value_) / (1 << FRACTIONAL_BITS);
        }
 
        vrpn_float64 get(TypeWrapper<vrpn_float64> *) const
 {
 return static_cast<vrpn_float64>(value_) / (1 << FRACTIONAL_BITS);
        }
 
        RawType value_;
    };
 
} // namespace vrpn
 
#endif // VRPN_FIXED_POINT_H_