First commit

Author: SloCompTech

examples/SimpleTest.cpp

@@ -0,0 +1,38 @@
+#include <iostream>
+#include <cstdlib>
+#include "../libbyteconvert/ByteConvert.hpp"
+
+using namespace std;
+
+int main() {
+  cout << "Simple test" << endl;
+  cout << "size(short): " << sizeof(short) << endl;
+  cout << "size(int): " << sizeof(int) << endl;
+  cout << "size(float): " << sizeof(float) << endl;
+  cout << "size(char): " << sizeof(char) << endl;
+  cout << "size(uint8_t): " << sizeof(uint8_t) << endl;
+  cout << "valToHex: 9->" << ByteConvert::valToHex(0x09) << endl;
+  cout << "valToHex: b->" << ByteConvert::valToHex(0x0b) << endl;
+  cout << "byteToHexString: fa->" << ByteConvert::byteToHexString(0xfa) << endl;
+
+  uint8_t array1[] = {0xfa,0xca,0xde,0xda};
+  cout << "facadeda -> " << ByteConvert::arrayToString(4,array1) << endl;
+
+  size_t s2 = 0;
+  uint8_t *array2 = ByteConvert::stringToArray(s2,"bedababa");
+  cout << "Size(bedababba): " << s2 << endl;
+  cout << "bedababba -> " << ByteConvert::arrayToString(s2,array2) << endl;
+
+  delete array2;
+
+  int in = 5;
+  cout << "Orig: 5 -> " << in << endl;
+  size_t s3 = 0;
+  uint8_t *array3 = ByteConvert::varToArray<int>(s3,in);
+  cout << "00000005 -> " << ByteConvert::arrayToString(s3,array3) << endl;
+  cout << "5 -> " << ByteConvert::arrayToVar<int>(array3) << endl;
+
+  delete array3;
+
+  return 0;
+}

libbyteconvert/ByteConvert.cpp

@@ -0,0 +1,48 @@
+#include "ByteConvert.hpp"
+namespace ByteConvert {
+  char valToHex(uint8_t val) {
+    if ((val & 0x0f) < 10)
+      return ('0' + val);
+    else
+      return ('a' + (val - 10));
+  }
+  uint8_t hexToVal(char c) {
+    if (c >= 'a')
+      return (15 - ('f' - c));
+    else
+      return (9 - ('9' - c));
+  }
+  std::string byteToHexString(uint8_t b) {
+    std::string buffer = "";
+    buffer += valToHex(b & 0x0f);
+    b >>= 4;
+    buffer = valToHex(b & 0x0f) + buffer;
+    return buffer;
+  }
+  uint8_t hexStringToByte(std::string block) {
+    if (block.length() != 2)
+      return 0x00;
+    return 16*hexToVal(block.at(0))+hexToVal(block.at(1));
+  }
+
+  std::string arrayToString(size_t size,uint8_t *src) {
+    std::string buffer = "";
+    for (size_t i = 0;i < (size);i++)
+      buffer += byteToHexString(src[i]);
+    return buffer;
+  }
+  uint8_t* stringToArray(size_t &size,std::string src) {
+    // Length of src must be odd !!
+    if (src.length() % 2 == 1)
+      src = "0" + src;
+    size = src.length()/2;
+    uint8_t *dst = new uint8_t[size]; // Allocate memory space
+    std::string buff = "";
+    for (size_t i = 0;i < (size);i++) {
+      buff = src.at(i*2);
+      buff += src.at(i*2+1);
+      dst[i] = hexStringToByte(buff);
+    }
+    return dst;
+  }
+}

libbyteconvert/ByteConvert.hpp

@@ -0,0 +1,36 @@
+#ifndef _ByteConvert_hpp_
+#define _ByteConvert_hpp_
+
+#include <string>
+#include <cstdint>
+
+namespace ByteConvert {
+  template<class T>
+  T arrayToVar(uint8_t *array) {
+    size_t size = sizeof(T)/sizeof(uint8_t);
+    T var = 0x00;
+    for (size_t i = 0;i < (size);i++) {
+      if (i != 0) var <<= 8;
+      var |= array[i];
+    }
+    return var;
+  }
+  template<class T>
+  uint8_t *varToArray(size_t &size,T var) {
+    size = sizeof(T)/sizeof(uint8_t);
+    uint8_t *array = new uint8_t[size]; // Alocate memory
+    for (size_t i = 0;i < size;i++) {
+      if (i != 0) var >>= 8;
+      array[size-1-i] = (uint8_t)(var&0xff);
+    }
+    return array;
+  }
+  char valToHex(uint8_t val);
+  uint8_t hexToVal(char c);
+  std::string byteToHexString(uint8_t b);
+  uint8_t hexStringToByte(std::string block);
+  std::string arrayToString(size_t size,uint8_t *src);
+  uint8_t* stringToArray(size_t &size,std::string src);
+}
+
+#endif