HSS1394Types.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------

#ifndef _HSS1394Types_
#define _HSS1394Types_

//*** Defines
//*****************************************************************************
#ifndef NULL
        #define NULL    ((void*)0x0)
#endif

// Some useful constants
#define HSS1394_k       (1024)
#define HSS1394_M       (HSS1394_k*HSS1394_k)


//*** Types
//*****************************************************************************
namespace hss1394 {
        // THSS1394Tags
        //-----------------------------------------------------------------------------
        typedef enum {
                // Must match with defines in NodeHSS1394.cpp on embedded endpoint.
                kUserData               = 0x00,         
                kDebugData              = 0x01,         
                kUserTagBase    = 0x10,         
                kUserTagTop             = 0xEF,         
                kReset                  = 0xF0,         
                kChangeAddress  = 0xF1,         
                kPing                   = 0xF2,         
                kPingResponse   = 0xF3,         
                kEchoAsUserData = 0xF4,         
                kUndefined              = 0xFF          
        }THSS1394Tags;


        // Useful bit-counted type definitions
        // Potentially Platform-dependent, however 32-bit assumptions can be made.
        //-----------------------------------------------------------------------------
        #ifdef _WIN32_
                typedef unsigned __int64 _u64;
        #else   // We assume Mac
                typedef uint64_t _u64;
        #endif

        // 32-bit machine/compiler assumption
        typedef unsigned int     uint;          
        typedef unsigned char    uint8;         
        typedef unsigned short   uint16;        
        typedef unsigned int     uint32;        
        
        class uint48 {
                public:
                        uint32 mu32Low;         
                        uint16 mu16High;        
                        uint16 mu16Guard;       

                        inline uint48(void) :
                                mu16Guard(0x0), mu16High(0x0), mu32Low(0x0) {
                        }

                        inline uint48(uint16 u16High, uint32 u32Low) :
                                mu16Guard(0x0), mu16High(u16High), mu32Low(u32Low) {
                        }
                                
                        inline bool operator==(const uint48 &other) const {
                                return ((mu16High == other.mu16High) && (mu32Low == other.mu32Low));
                        }

                        inline uint48 &operator=(const uint48 &other) {
                                mu16Guard = other.mu16Guard;
                                mu16High = other.mu16High;
                                mu32Low = other.mu32Low;
                                return *this;
                        }
        };

        class uint64 {
                public:
                        uint32 mu32Low;         
                        uint32 mu32High;        

                        inline uint64(void) :
                                mu32High(0x0), mu32Low(0x0) {
                        }

                        inline uint64(uint32 u32High, uint32 u32Low) :
                                mu32High(u32High), mu32Low(u32Low) {
                        }

                        inline bool operator==(const uint64 &other) const {
                                return ((mu32High == other.mu32High) && (mu32Low == other.mu32Low));
                        }

                        inline uint64 &operator=(const uint64 &other) {
                                mu32High = other.mu32High;
                                mu32Low = other.mu32Low;
                                return *this;
                        }

                        inline uint64 &operator=(const int other) {
                                mu32High = 0x0;
                                mu32Low = other;
                                return *this;
                        }
        };
        
};      // ::hss1394

#endif // _HSS1394Types_