vrpn_FixedPoint.h

Go to the documentation of this file.

 
#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_