---

at_gray_code.h

Go to the documentation of this file.

//
// The Austria library is copyright (c) Gianni Mariani 2004.
// 
// Grant Of License.  Grants to LICENSEE the non-exclusive right to use the Austria
// library subject to the terms of the LGPL.
// 
// A copy of the license is available in this directory or one may be found at this URL:
//      http://www.gnu.org/copyleft/lesser.txt
// 
#ifndef x_at_gray_code_h_x
#define x_at_gray_code_h_x 1

#include <limits>

// Austria namespace
namespace at
{
        
namespace gray_tools
{

template <typename T, bool is_signed=std::numeric_limits<T>::is_signed >
struct signed_tester
{
    inline static bool gtez( const T & i_rhs )
    {
        return i_rhs >= 0;
    }
};

template <typename T>
struct signed_tester<T, false>
{
    inline static bool gtez( const T & i_rhs )
    {
        return true;
    }
};

template <typename T>
T bin_to_gray( const T & i_value )
{
    
    if ( signed_tester<T>::gtez( i_value ) )
    {
        return i_value ^ ( i_value >> 1 );
    }
    else
    {
        return ( ( ~i_value ) ^ ( ( ~i_value ) >> 1 ) ) + std::numeric_limits<T>::min();
    }
}


template <
    typename T,
    int shift_count = 1,
    bool terminal_calc = ( shift_count >= ( std::numeric_limits<T>::digits ) )
>
struct gray_to_bin_helper
{
    inline static void calculate( T & io_value )
    {
        io_value ^= io_value >> shift_count;
        gray_to_bin_helper<T,shift_count*2>::calculate( io_value );
    }
};

template <
    typename T,
    int shift_count
>
struct gray_to_bin_helper<T,shift_count,true>
{
    inline static void calculate( T & value )
    {
    }
};
    
template <typename T>
T gray_to_bin( T value )
{
    if ( signed_tester<T>::gtez( value ) )
    {
        gray_to_bin_helper<T>::calculate( value );
    }
    else
    {
        value = value - std::numeric_limits<T>::min();
        gray_to_bin_helper<T>::calculate( value );
        value = ~ value;
    }
    
    return value;
}

};

template <typename T>
class gray_code
{
    public:
    typedef T           value_type;

    protected:
    value_type          m_value;

    public:
    template <typename T2> friend class gray_code;

    operator value_type () const throw()
    {
        return getbin();
    }

    value_type getbin() const throw()
    {
        return gray_tools::gray_to_bin( m_value );
    }

    value_type getgray() const throw()
    {
        return m_value;
    }

    void setgray( value_type value ) throw()
    {
        m_value = value;
    }

    enum ArgType
    {
        is_gray,
        
        is_binary
    };

    gray_code( const T & i_value, ArgType i_arg_type )
      : m_value( i_arg_type == is_gray ? i_value : gray_tools::bin_to_gray( i_value ) )
    {
    }

    gray_code( const T & i_value )
      : m_value( gray_tools::bin_to_gray( i_value ) )
    {
    }

    template <typename RHS_T>
    gray_code( const gray_code<RHS_T> & i_other_gray )
      : m_value(
            std::numeric_limits<value_type>::is_signed == std::numeric_limits<RHS_T>::is_signed
            ? i_other_gray.m_value
            : gray_tools::bin_to_gray( value_type( i_other_gray.getbin() ) )
        )
    {
    }

    template <typename RHS_T>
    gray_code & operator= (const RHS_T & i_other_gray )
    {

        m_value = (
            std::numeric_limits<value_type>::is_signed == std::numeric_limits<RHS_T>::is_signed
            ? i_other_gray.m_value
            : gray_tools::bin_to_gray( value_type( i_other_gray.getbin() ) )
        );
        
        return * this;
    }

    bool gtez()
    {
        return gray_tools::signed_tester<T>::gtez( m_value );
    }
    
    bool equal_to_zero()
    {
        return m_value == 0;
    }
};
    
}; // namespace
#endif // x_at_gray_code_h_x

Generated for Austria by and MakeXS at Sun Oct 24 17:35:34 PDT 2004