Change the Data class to a template

Author: epsilonrt

include/modbuspp-data.h

@@ -1,4 +1,4 @@
-/* Copyright © 2018 Pascal JEAN, All rights reserved.
+/* Copyright © 2018-2019 Pascal JEAN, All rights reserved.
  * This file is part of the libmodbuspp Library.
  *
  * The libmodbuspp Library is free software; you can redistribute it and/or
@@ -18,110 +18,171 @@
 #ifndef MODBUSPP_DATA_H
 #define MODBUSPP_DATA_H
 
-#include <string>
-#include <modbus.h>
-#include "global.h"
+#include <cstdio>     // printf
+#include <cstring>    // mencpy ...
+#include <array>
+#include <type_traits>
+#include "modbuspp-swap.h"
+
+#ifndef __DOXYGEN__
+#endif /* __DOXYGEN__ not defined */
 
 /**
  *
  */
 namespace Modbus {
 
+  enum Endian { // network number ABCD
+    EndianBigBig = 0x00,    // bytes in big endian order, word in big endian order : ABCD
+    EndianBig = EndianBigBig, // big endian order : ABCD
+    EndianBigLittle = 0x01, // bytes in big endian order, word in little endian order : CDAB
+    EndianLittleBig = 0x02, // bytes in little endian order, word in big endian order : BADC
+    EndianLittleLittle = 0x03, // bytes in little endian order, word in little endian order : DCBA
+    EndianLittle = EndianLittleLittle // little endian order : DCBA
+  };
+
+
+  class Device;
+  class Master;
+
   /**
    * @class Data
-   * @brief
+   * @author Pascal JEAN, aka epsilonrt
+   * @copyright GNU Lesser General Public License
+   * @brief 
    */
+  template <typename T, Endian e = EndianBigBig>
   class Data {
     public:
-      enum Type {
-        Byte, // 2 Bytes (nothing is smaller than the word on MODBUS)
-        Word, // 2 Bytes - 1 MODBUS register
-        LongWord, // 4 Bytes - 2 MODBUS registers
-        LongLongWord, // 8 Bytes - 4 MODBUS registers
-        Float, // 4 Bytes - 2 MODBUS registers
-        Double, // 8 Bytes - 4 MODBUS registers
-        Void = -1
-      };
-
-      enum Endian { // network number ABCD
-        EndianBigBig = 0x00,    // bytes in big endian order, word in big endian order : ABCD
-        EndianBig = EndianBigBig, // big endian order : ABCD
-        EndianBigLittle = 0x01, // bytes in big endian order, word in little endian order : CDAB
-        EndianLittleBig = 0x02, // bytes in little endian order, word in big endian order : BADC
-        EndianLittleLittle = 0x03, // bytes in little endian order, word in little endian order : DCBA
-        EndianLittle = EndianLittleLittle // little endian order : DCBA
-      };
-
-      Data (Type type = Void, Endian endian = EndianBig); // default constructor
-      Data (const Data & other);
-      virtual ~Data();
-
-      Data (uint8_t v, Endian endian = EndianBig);
-      Data (uint16_t v, Endian endian = EndianBig);
-      Data (uint32_t v, Endian endian = EndianBig);
-      Data (uint64_t v, Endian endian = EndianBig);
-      Data (char v, Endian endian = EndianBig);
-      Data (int v, Endian endian = EndianBig);
-      Data (long v, Endian endian = EndianBig);
-      Data (long long v, Endian endian = EndianBig);
-      Data (float v, Endian endian = EndianBig);
-      Data (double v, Endian endian = EndianBig);
-
-      void swap (Data &other);
-      Data& operator= (const Data &other);
-
-      void set (uint8_t v);
-      void set (uint16_t v);
-      void set (uint32_t v);
-      void set (uint64_t v);
-
-      void set (char v);
-      void set (int v);
-      void set (long v);
-      void set (long long v);
-      void set (float v);
-      void set (double v);
-
-      void get (uint8_t & v) const;
-      void get (uint16_t & v) const;
-      void get (uint32_t & v) const;
-      void get (uint64_t & v) const;
-
-      void get (char & v) const;
-      void get (int & v) const;
-      void get (long & v) const;
-      void get (long long & v) const;
-      void get (float & v) const;
-      void get (double & v) const;
-
-      Endian endianness() const;
-      Type type() const;
-      void setType (Type t);
-      size_t size() const;
-      uint16_t * ptr();
-      const uint16_t * ptr() const;
+      static_assert ( (sizeof (T) >= 2 && (sizeof (T) % 2) == 0), "Bad Data typename !");
+      static_assert (std::is_arithmetic<T>::value, "Arithmetic type required.");
+
+      Data() : m_endian (e) {
+        m_value = 0;
+        updateRegisters();
+      }
+
+      Data (const T& t) :  m_value (t), m_endian (e) {
+        updateRegisters();
+      }
+
+      operator T&() {
+        return m_value;
+      }
+
+      operator T&() const {
+        return m_value;
+      }
+
+      T& value() {
+        return m_value;
+      }
+
+      const T& value() const {
+        return m_value;
+      }
+
+      T* operator&() {
+        return & m_value;
+      }
+
+      const T* operator&() const {
+        return & m_value;
+      }
+
+      T& operator= (const T& t) {
+        m_value = t;
+        updateRegisters();
+        return m_value;
+      }
+
+      Endian endianness() const {
+        return m_endian;
+      }
+
+      std::size_t size() const {
+        return sizeof (m_value);
+      }
+
+      std::array < uint16_t, sizeof (T) / 2 > & registers() {
+        return m_registers;
+      }
+      
+      const std::array < uint16_t, sizeof (T) / 2 > & registers() const {
+        return m_registers;
+      }
+
+
+      void swap (T & v) {
+
+        switch (m_endian) { // net value: ABCDEFGH
+          case EndianBigBig: // ABCDEFGH: bytes Big, word Big : no swap
+            break;
+          case EndianBigLittle: // GHEFCDAB: bytes Big, word Little : swap words
+            v = swapWords (v);
+            break;
+          case EndianLittleBig: // BADCFEHG: bytes Little, word Big : swap bytes of words
+            v = swapBytesInWords (v);
+            break;
+          case EndianLittleLittle: // HGFEDCBA: bytes Little, word Little: swap all
+            v = swapBytes (v);
+            break;
+        }
+      }
 
       // debug purpose
-      void print () const;
-      static void print (const uint8_t * p, const size_t s);
-      static void print (const uint8_t & v);
-      static void print (const uint16_t & v);
-      static void print (const uint32_t & v);
-      static void print (const uint64_t & v);
-      static void print (const char & v);
-      static void print (const int & v);
-      static void print (const long & v);
-      static void print (const long long & v);
-      static void print (const float & v);
-      static void print (const double & v);
+      static void print (const uint8_t * p, const size_t s) {
+        std::printf ("0x");
+        for (std::size_t i = 0; i < s; i++) {
+          std::printf ("%02X", p[i]);
+        }
+        std::printf ("\n");
+      }
+
+      static void print (const T & v) {
+        print ( (const uint8_t *) &v, sizeof (v));
+      }
+
+      void print () {
+        updateRegisters();
+        print ( (const uint8_t *) m_registers.data(), size());
+      }
+
+      friend class Device;
+      friend class Master;
 
     protected:
-      class Private;
-      Data (Private &dd);
-      std::unique_ptr<Private> d_ptr;
+
+      // update MODBUS registers from data value
+      // to call before writing in the MODBUS registers
+      void updateRegisters() {
+        T v;
+
+        v = hton (m_value);
+        swap (v);
+        std::memcpy (m_registers.data(), &v, sizeof (T));
+        for (auto & r : m_registers) {
+          r = ntoh (r);
+        }
+      }
+
+      // update data value from MODBUS registers
+      // to call after reading the modbus registers
+      void updateValue() {
+        T v;
+
+        for (auto & r : m_registers) {
+          r = hton (r);
+        }
+        std::memcpy (&v, m_registers.data(), sizeof (T));
+        swap (v);
+        m_value = ntoh (v);
+      }
 
     private:
-      PIMP_DECLARE_PRIVATE (Data)
+      T m_value;
+      Endian m_endian;
+      std::array < uint16_t, sizeof (T) / 2 > m_registers;
   };
 }
 /**

include/modbuspp-swap.h

@@ -0,0 +1,93 @@
+/* Copyright © 2018-2019 Pascal JEAN, All rights reserved.
+ * This file is part of the libmodbuspp Library.
+ *
+ * The libmodbuspp Library 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; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * The libmodbuspp Library 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 Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with the libmodbuspp Library; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MODBUSPP_SWAP_H
+#define MODBUSPP_SWAP_H
+
+#ifndef __DOXYGEN__
+
+#include <algorithm>  // std::swap until C++11
+#include <utility>    // std::swap since C++11
+
+/*
+ * reverse the order of the bytes
+ */
+template <typename T>
+T swapBytes (T input) { // swap bytes
+  uint8_t * ptr = reinterpret_cast<uint8_t*> (&input);
+
+  for (std::size_t i = 0; i < sizeof (T) / 2; ++i) {
+
+    std::swap (ptr[i], ptr[ sizeof (T) - 1 - i ]);
+  }
+  return input;
+}
+
+/*
+ * reverse the order of the 16-bit words
+ */
+template <typename T>
+T swapWords (T input) { // swap words
+  uint16_t * ptr = reinterpret_cast<uint16_t*> (&input);
+
+  for (std::size_t i = 0; i < sizeof (T) / 4; ++i) {
+
+    std::swap (ptr[i], ptr[ (sizeof (T) / 2) - 1 - i ]);
+  }
+  return input;
+}
+
+/*
+ * reverse the byte order of each 16-bit word.
+ */
+template <typename T>
+T swapBytesInWords (T input) { // swap bytes in each words
+  uint16_t * ptr = reinterpret_cast<uint16_t*> (&input);
+
+  for (std::size_t i = 0; i < sizeof (T) / 2; ++i) {
+
+    ptr[i] = swapBytes (ptr[i]);
+  }
+  return input;
+}
+
+/*
+ * converts the input from host byte order to network byte order. 
+ */
+template <typename T>
+T hton (T input) {
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+  return swapBytes (input);
+#else
+  return input;
+#endif
+}
+
+/*
+ * converts the input from host byte network to host byte order. 
+ */
+template <typename T>
+T ntoh (T input) {
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+  return swapBytes (input);
+#else
+  return input;
+#endif
+}
+#endif /* __DOXYGEN__ not defined */
+/* ========================================================================== */
+#endif /* MODBUSPP_SWAP_H defined */