VTypes.h

// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
#ifndef _RTUTypes_H_
#define _RTUTypes_H_
// -----------------------------------------------------------------------------
#include <string>
#include <cmath>
#include <cstring>
#include <ostream>
#include "modbus/ModbusTypes.h"
// -----------------------------------------------------------------------------
namespace VTypes
{
    enum VType
    {
        vtUnknown,
        vtF2,        
        vtF2r,       
        vtF4,        
        vtByte,      
        vtUnsigned,  
        vtSigned,    
        vtI2,        
        vtI2r,       
        vtU2,        
        vtU2r        
    };

    std::ostream& operator<<( std::ostream& os, const VType& vt );

    // -------------------------------------------------------------------------
    std::string type2str( VType t );           
    VType str2type( const std::string& s );    
    int wsize( VType t );                      
    // -------------------------------------------------------------------------
    class F2
    {
        public:

            // ------------------------------------------
            static const int f2Size = 2;
            typedef union
            {
                unsigned short v[f2Size];
                float val; //
            } F2mem;
            // ------------------------------------------
            // конструкторы на разные случаи...
            F2()
            {
                memset(raw.v, 0, sizeof(raw.v));
            }

            F2( const float& f )
            {
                raw.val = f;
            }
            F2( const ModbusRTU::ModbusData* data, int size )
            {
                for( int i = 0; i < wsize() && i < size; i++ )
                    raw.v[i] = data[i];
            }

            ~F2() {}
            // ------------------------------------------
            static int wsize()
            {
                return f2Size;
            }
            static VType type()
            {
                return vtF2;
            }
            // ------------------------------------------
            operator float()
            {
                return raw.val;
            }
            operator long()
            {
                return lroundf(raw.val);
            }
            operator int()
            {
                return lroundf(raw.val);
            }

            F2mem raw;
    };
    // --------------------------------------------------------------------------
    class F2r:
        public F2
    {
        public:

            // ------------------------------------------
            // конструкторы на разные случаи...
            F2r() {}

            F2r( const float& f ): F2(f)
            {
                raw_backorder = raw;
                std::swap(raw_backorder.v[0], raw_backorder.v[1]);
            }
            F2r( const ModbusRTU::ModbusData* data, int size ): F2(data, size)
            {
                // принимаем в обратном порядке.. поэтому переворачиваем raw
                raw_backorder = raw;
                std::swap(raw.v[0], raw.v[1]);
            }

            ~F2r() {}

            F2mem raw_backorder;
    };
    // --------------------------------------------------------------------------
    class F4
    {
        public:
            // ------------------------------------------
            static const int f4Size = 4;
            typedef union
            {
                unsigned short v[f4Size];
                float val; //
            } F4mem;
            // ------------------------------------------
            // конструкторы на разные случаи...
            F4()
            {
                memset(raw.v, 0, sizeof(raw.v));
            }

            F4( const float& f )
            {
                raw.val = f;
            }
            F4( const ModbusRTU::ModbusData* data, int size )
            {
                for( int i = 0; i < wsize() && i < size; i++ )
                    raw.v[i] = data[i];
            }

            ~F4() {}
            // ------------------------------------------
            static int wsize()
            {
                return f4Size;
            }
            static VType type()
            {
                return vtF4;
            }
            // ------------------------------------------
            operator float()
            {
                return raw.val;
            }
            operator long()
            {
                return lroundf(raw.val);
            }

            F4mem raw;
    };
    // --------------------------------------------------------------------------
    class Byte
    {
        public:

            static const int bsize = 2;

            // ------------------------------------------
            typedef union
            {
                unsigned short w;
                unsigned char b[bsize];
            } Bytemem;
            // ------------------------------------------
            // конструкторы на разные случаи...
            Byte()
            {
                raw.w = 0;
            }

            Byte( unsigned char b1, unsigned char b2 )
            {
                raw.b[0] = b1;
                raw.b[1] = b2;
            }
            Byte( const long& val )
            {
                raw.w = val;
            }

            Byte( const ModbusRTU::ModbusData dat )
            {
                raw.w = dat;
            }

            ~Byte() {}
            // ------------------------------------------
            static int wsize()
            {
                return 1;
            }
            static VType type()
            {
                return vtByte;
            }
            // ------------------------------------------
            operator long()
            {
                return lroundf(raw.w);
            }
            operator unsigned short()
            {
                return raw.w;
            }

            unsigned char operator[]( const int i )
            {
                return raw.b[i];
            }

            Bytemem raw;
    };
    // --------------------------------------------------------------------------
    class Unsigned
    {
        public:

            // ------------------------------------------
            // конструкторы на разные случаи...
            Unsigned(): raw(0) {}

            Unsigned( const long& val )
            {
                raw = val;
            }

            Unsigned( const ModbusRTU::ModbusData dat )
            {
                raw = dat;
            }

            ~Unsigned() {}
            // ------------------------------------------
            static int wsize()
            {
                return 1;
            }
            static VType type()
            {
                return vtUnsigned;
            }
            // ------------------------------------------
            operator long()
            {
                return raw;
            }

            unsigned short raw;
    };
    // --------------------------------------------------------------------------
    class Signed
    {
        public:

            // ------------------------------------------
            // конструкторы на разные случаи...
            Signed(): raw(0) {}

            Signed( const long& val )
            {
                raw = val;
            }

            Signed( const ModbusRTU::ModbusData dat )
            {
                raw = dat;
            }

            ~Signed() {}
            // ------------------------------------------
            static int wsize()
            {
                return 1;
            }
            static VType type()
            {
                return vtSigned;
            }
            // ------------------------------------------
            operator long()
            {
                return raw;
            }

            signed short raw;
    };
    // --------------------------------------------------------------------------
    class I2
    {
        public:

            // ------------------------------------------
            static const int i2Size = 2;
            typedef union
            {
                unsigned short v[i2Size];
                int val; //
            } I2mem;
            // ------------------------------------------
            // конструкторы на разные случаи...
            I2()
            {
                memset(raw.v, 0, sizeof(raw.v));
            }

            I2( int v )
            {
                raw.val = v;
            }
            I2( const ModbusRTU::ModbusData* data, int size )
            {
                for( int i = 0; i < wsize() && i < size; i++ )
                    raw.v[i] = data[i];
            }

            ~I2() {}
            // ------------------------------------------
            static int wsize()
            {
                return i2Size;
            }
            static VType type()
            {
                return vtI2;
            }
            // ------------------------------------------
            operator int()
            {
                return raw.val;
            }

            I2mem raw;
    };
    // --------------------------------------------------------------------------
    class I2r:
        public I2
    {
        public:
            I2r() {}

            I2r( const int v ): I2(v)
            {
                raw_backorder = raw;
                std::swap(raw_backorder.v[0], raw_backorder.v[1]);
            }
            I2r( const ModbusRTU::ModbusData* data, int size ): I2(data, size)
            {
                // принимаем в обратном порядке.. поэтому переворачиваем raw
                raw_backorder = raw;
                std::swap(raw.v[0], raw.v[1]);
            }

            ~I2r() {}

            I2mem raw_backorder;
    };
    // --------------------------------------------------------------------------
    class U2
    {
        public:

            // ------------------------------------------
            static const int u2Size = 2;
            typedef union
            {
                unsigned short v[u2Size];
                unsigned int val; //
            } U2mem;
            // ------------------------------------------
            // конструкторы на разные случаи...
            U2()
            {
                memset(raw.v, 0, sizeof(raw.v));
            }

            U2( unsigned int v )
            {
                raw.val = v;
            }
            U2( const ModbusRTU::ModbusData* data, int size )
            {
                for( int i = 0; i < wsize() && i < size; i++ )
                    raw.v[i] = data[i];
            }

            ~U2() {}
            // ------------------------------------------
            static int wsize()
            {
                return u2Size;
            }
            static VType type()
            {
                return vtU2;
            }
            // ------------------------------------------
            operator unsigned int()
            {
                return raw.val;
            }

            U2mem raw;
    };
    // --------------------------------------------------------------------------
    class U2r:
        public U2
    {
        public:
            U2r() {}

            U2r( int v ): U2(v)
            {
                raw_backorder = raw;
                std::swap(raw_backorder.v[0], raw_backorder.v[1]);
            }
            U2r( const ModbusRTU::ModbusData* data, int size ): U2(data, size)
            {
                // принимаем в обратном порядке.. поэтому переворачиваем raw
                raw_backorder = raw;
                std::swap(raw.v[0], raw.v[1]);
            }

            ~U2r() {}

            U2mem raw_backorder;
    };
    // --------------------------------------------------------------------------

} // end of namespace VTypes
// --------------------------------------------------------------------------
#endif // _RTUTypes_H_
// -----------------------------------------------------------------------------