VTypes.h

/*
 * Copyright (c) 2015 Pavel Vainerman.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, version 2.1.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Lesser Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
#ifndef _RTUTypes_H_
#define _RTUTypes_H_
// -----------------------------------------------------------------------------
#include <string>
#include <cmath>
#include <cstring>
#include <ostream>
#include "modbus/ModbusTypes.h"
// -----------------------------------------------------------------------------
namespace uniset
{
// -----------------------------------------------------------------------------
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 ) noexcept;           
VType str2type( const std::string& s ) noexcept;    
int wsize( VType t ) noexcept;                      
// -------------------------------------------------------------------------
class F2
{
    public:

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

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

        ~F2() noexcept {}
        // ------------------------------------------
        static size_t 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() noexcept
        {
            raw_backorder.val = 0;
        }

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

        ~F2r() noexcept {}

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

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

        ~F4() noexcept {}
        // ------------------------------------------
        static size_t 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 size_t bsize = 2;

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

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

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

        ~Byte() noexcept {}
        // ------------------------------------------
        static size_t 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() noexcept: raw(0) {}

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

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

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

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

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

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

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

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

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

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

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

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

        I2mem raw;
};
// --------------------------------------------------------------------------
class I2r:
    public I2
{
    public:
        I2r() noexcept
        {
            raw_backorder.val = 0;
        }

        I2r( const int v ) noexcept: I2(v)
        {
            raw_backorder = raw;
            std::swap(raw_backorder.v[0], raw_backorder.v[1]);
        }

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

        ~I2r() noexcept {}

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

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

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

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

        U2mem raw;
};
// --------------------------------------------------------------------------
class U2r:
    public U2
{
    public:
        U2r() noexcept
        {
            raw_backorder.val = 0;
        }

        U2r( int v ) noexcept: U2(v)
        {
            raw_backorder = raw;
            std::swap(raw_backorder.v[0], raw_backorder.v[1]);
        }

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

        ~U2r() {}

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

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