std::fast_type< Bits, TBaseType > Template-Klassenreferenz

#include <fast_type.hpp>

Zusammengehörigkeiten von std::fast_type< Bits, TBaseType >:

Öffentliche Typen
using	self_type = fast_type< Bits, TBaseType >
using	value_type = TBaseType
using	bit_type = fbit

Öffentliche Methoden
	fast_type (value_type v)
	fast_type (const fast_type &c)
unsigned int	count ()
unsigned int	zeros ()
unsigned int	set (size_t pos, bool p)
size_t	size ()
value_type &	operator[] (const size_t p)
self_type &	operator= (value_type &v)
self_type &	operator= (self_type &other)
bool	operator== (self_type &other)
bool	operator!= (self_type &other)
bool	operator<= (self_type &other)
bool	operator>= (self_type &other)
bool	operator< (self_type &other)
bool	operator> (self_type &other)
self_type &	operator+= (self_type &other)
self_type &	operator-= (self_type &other)
self_type &	operator*= (self_type &other)
self_type &	operator&= (self_type &other)
self_type &	operator|= (self_type &other)
self_type &	operator^= (self_type &other)
self_type &	operator<<= (self_type &other)
self_type &	operator>>= (self_type &other)
self_type &	operator/= (self_type &other)
self_type &	operator+= (value_type &v)
self_type &	operator-= (value_type &v)
self_type &	operator*= (value_type &v)
self_type &	operator/= (value_type &v)
self_type &	operator<<= (value_type &v)
self_type &	operator>>= (value_type &v)
self_type &	operator- (const self_type &rhs)
self_type &	operator+ (const self_type &rhs)
self_type &	operator* (const self_type &rhs)
self_type &	operator/ (const self_type &rhs)
self_type &	operator<< (const self_type &rhs)
self_type &	operator>> (const self_type &rhs)
self_type &	operator| (const self_type &rhs)
self_type &	operator^ (const self_type &rhs)
self_type &	operator& (const self_type &rhs)
self_type &	operator~ ()
self_type &	operator++ ()
self_type &	operator-- ()
self_type &	operator~ ()

Öffentliche Attribute
union {
value_type   Value
bit_type   bits [Bits]
};

Ausführliche Beschreibung

template<size_t Bits, typename TBaseType>
class std::fast_type< Bits, TBaseType >

Dokumentation der benutzerdefinierten Datentypen

bit_type

template<size_t Bits, typename TBaseType >

using std::fast_type< Bits, TBaseType >::bit_type = fbit

self_type

template<size_t Bits, typename TBaseType >

using std::fast_type< Bits, TBaseType >::self_type = fast_type<Bits, TBaseType>

value_type

template<size_t Bits, typename TBaseType >

using std::fast_type< Bits, TBaseType >::value_type = TBaseType

Beschreibung der Konstruktoren und Destruktoren

fast_type() [1/2]

template<size_t Bits, typename TBaseType >

std::fast_type< Bits, TBaseType >::fast_type ( value_type  v )

inlineexplicit

: Value(v) {}

fast_type() [2/2]

template<size_t Bits, typename TBaseType >

std::fast_type< Bits, TBaseType >::fast_type ( const fast_type< Bits, TBaseType > &  c )

inline

                                      {
            Value = c.Value;
        }

Dokumentation der Elementfunktionen

count()

template<size_t Bits, typename TBaseType >

unsigned int std::fast_type< Bits, TBaseType >::count ( )

inline

                             { 
            unsigned int i;
            for(int j = 0; j < Bits; j++)
                i += bits[i].bit;
            return i;
        }

operator!=()

template<size_t Bits, typename TBaseType >

bool std::fast_type< Bits, TBaseType >::operator!= ( self_type &  other )

inline

                                            {
            return Value != other.Value;
        }

operator&()

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator & ( const self_type &  rhs )

inline

                                                      {
            self_type result = self_type(*this);
            result.Value &= rhs.Value;
            return result;
        }

operator&=()

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator &= ( self_type &  other )

inline

                                                  {
            Value &= other.Value; return *this;
        }

operator*()

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator* ( const self_type &  rhs )

inline

                                                      {
            return self_type(*this) *= rhs;
        }

operator*=() [1/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator*= ( self_type &  other )

inline

                                                  {
            Value *= other.Value; return *this;
        }

operator*=() [2/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator*= ( value_type &  v )

inline

                                               {
            Value *= v; return *this;
        }

operator+()

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator+ ( const self_type &  rhs )

inline

                                                      {
            return self_type(*this) += rhs;
        }

operator++()

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator++ ( )

inline

                                  {
            Value++; return *this;
        }

operator+=() [1/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator+= ( self_type &  other )

inline

                                                  {
            Value += other.Value; return *this;
        }

operator+=() [2/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator+= ( value_type &  v )

inline

                                               {
            Value += v; return *this;
        }

operator-()

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator- ( const self_type &  rhs )

inline

                                                      {
            return self_type(*this) -= rhs;
        }

operator--()

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator-- ( )

inline

                                  {
            Value--; return *this;
        }

operator-=() [1/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator-= ( self_type &  other )

inline

                                                  {
            Value -= other.Value; return *this;
        }

operator-=() [2/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator-= ( value_type &  v )

inline

                                               {
            Value -= v; return *this;
        }

operator/()

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator/ ( const self_type &  rhs )

inline

                                                      {
            return self_type(*this) /= rhs;
        }

operator/=() [1/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator/= ( self_type &  other )

inline

                                                  {
            Value /= other.Value; return *this;
        }

operator/=() [2/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator/= ( value_type &  v )

inline

                                               {
            Value /= v; return *this;
        }

operator<()

template<size_t Bits, typename TBaseType >

bool std::fast_type< Bits, TBaseType >::operator< ( self_type &  other )

inline

                                           {
            return Value < other.Value;
        }

operator<<()

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator<< ( const self_type &  rhs )

inline

                                                       {
            return self_type(*this) <<= rhs;
        }

operator<<=() [1/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator<<= ( self_type &  other )

inline

                                                   {
            Value <<= other.Value; return *this;
        }

operator<<=() [2/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator<<= ( value_type &  v )

inline

                                                {
            Value <<= v; return *this;
        }

operator<=()

template<size_t Bits, typename TBaseType >

bool std::fast_type< Bits, TBaseType >::operator<= ( self_type &  other )

inline

                                            {
            return Value <= other.Value;
        }

operator=() [1/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator= ( value_type &  v )

inline

                                              {
            Value = v; return *this;
        }

operator=() [2/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator= ( self_type &  other )

inline

                                                 {
            Value = other.Value; return *this;
        }

operator==()

template<size_t Bits, typename TBaseType >

bool std::fast_type< Bits, TBaseType >::operator== ( self_type &  other )

inline

                                            {
            return Value == other.Value;
        }

operator>()

template<size_t Bits, typename TBaseType >

bool std::fast_type< Bits, TBaseType >::operator> ( self_type &  other )

inline

                                           {
            return Value > other.Value;
        }

operator>=()

template<size_t Bits, typename TBaseType >

bool std::fast_type< Bits, TBaseType >::operator>= ( self_type &  other )

inline

                                            {
            return Value >= other.Value;
        }

operator>>()

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator>> ( const self_type &  rhs )

inline

                                                       {
            return self_type(*this) >>= rhs;
        }

operator>>=() [1/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator>>= ( self_type &  other )

inline

                                                   {
            Value >>= other.Value; return *this;
        }

operator>>=() [2/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator>>= ( value_type &  v )

inline

                                                {
            Value >>= v; return *this;
        }

operator[]()

template<size_t Bits, typename TBaseType >

value_type& std::fast_type< Bits, TBaseType >::operator[] ( const size_t  p )

inline

                                                 {
            return bits[p];
        }

operator^()

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator^ ( const self_type &  rhs )

inline

                                                      {
            self_type result = self_type(*this);
            result.Value ^= rhs.Value;
            return result;
        }

operator^=()

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator^= ( self_type &  other )

inline

                                                  {
            Value ^= other.Value; return *this;
        }

operator|()

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator| ( const self_type &  rhs )

inline

                                                      {
            self_type result = self_type(*this);
            result.Value |= rhs.Value;
            return result;
        }

operator|=()

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator|= ( self_type &  other )

inline

                                                  {
            Value |= other.Value; return *this;
        }

operator~() [1/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator~ ( )

inline

                                 {
            self_type result = self_type(*this);
            result.Value = ~result.Value;
            return result;
        }

operator~() [2/2]

template<size_t Bits, typename TBaseType >

self_type& std::fast_type< Bits, TBaseType >::operator~ ( )

inline

                                 {
            Value = ~Value; return *this;
        }

set()

template<size_t Bits, typename TBaseType >

unsigned int std::fast_type< Bits, TBaseType >::set ( size_t  pos, bool  p  )

inline

                                             {
            bits[pos].bit = p ? 1 : 0;
        } 

size()

template<size_t Bits, typename TBaseType >

size_t std::fast_type< Bits, TBaseType >::size ( )

inline

                      {
            return Bits;
        }

zeros()

template<size_t Bits, typename TBaseType >

unsigned int std::fast_type< Bits, TBaseType >::zeros ( )

inline

                             { 
            return Bits-count(); 
        }

Dokumentation der Datenelemente

@4

union { ... }

bits

template<size_t Bits, typename TBaseType >

bit_type std::fast_type< Bits, TBaseType >::bits[Bits]

Value

template<size_t Bits, typename TBaseType >

value_type std::fast_type< Bits, TBaseType >::Value

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• include/fast_type.hpp