Version 2

- Rewritten whole library
- Improved preformace
- Changed function names
- Improved meson framework
- Fixed issues in Readme.md
- Added make file
- Added CI for auto testing
- Added tests
- Added examples
- Fixed issues in `Readme.md`

Author: SloCompTech

.travis.yml

@@ -0,0 +1,26 @@
+language: generic
+sudo: enabled
+services:
+- docker
+stages:
+- test
+jobs:
+  include:
+    stage: test
+    install:
+      - sudo docker pull slocomptech/docker-meson-cpp:latest
+      - sudo docker run -it -d --name buildenv slocomptech/docker-meson-cpp bash
+      - sudo docker ps
+      - sudo docker exec buildenv apt-get install git -y
+    before_script:
+      - sudo docker exec buildenv git clone -b ${TRAVIS_BRANCH} https://github.com/SloCompTech/ByteConvert_cpp.git ByteConvert_cpp
+    script:
+      - sudo docker exec buildenv bash -c 'cd ByteConvert_cpp && meson build'
+      - sudo docker exec buildenv bash -c 'cd ByteConvert_cpp && ninja -C build'
+      - sudo docker exec buildenv bash -c 'cd ByteConvert_cpp && ninja -C build test'
+      - sudo docker exec buildenv bash -c 'cd ByteConvert_cpp && ninja -C build install'
+    after_script:
+      - sudo docker stop buildenv
+      - sudo docker rm buildenv
+      - sudo docker rmi slocomptech/docker-meson-cpp:latest
+      - sudo docker ps -a

ByteConvert/ByteConvert.cpp

@@ -0,0 +1,81 @@
+/**
+ * @file ByteConvert.cpp
+ * 
+ * @authors Martin Dagarin
+ * @date 22/07/2018
+ * 
+ * @brief Source file of ByteConvert module
+ */
+
+#include "ByteConvert.hpp"
+
+namespace ByteConvert 
+{
+  std::string byte_to_hex(const uint8_t& byte)
+  {
+    std::string buffer("");
+    uint8_t val;
+
+    for (uint8_t i = 0; i < 2; i++) {
+      if (i == 0)
+        val = (byte >> 4);
+      else
+        val = byte & 0x0f;
+      if (val >= 16)
+        buffer += '?';
+      else if (val < 10)
+        buffer += ('0' + val);
+      else
+        buffer += ('W' + val);
+    }
+    return buffer;
+  }
+
+  uint8_t hex_to_byte(const std::string& hex)
+  {
+    uint8_t val = 0x00;
+    uint8_t pos = (hex.size() > 1) ? hex.size() - 2 : hex.size() - 1;
+    char c;
+    for (; pos < hex.size(); pos++) {
+      c = hex[pos];
+      if (c >= 'A' && c <= 'F')
+        val += (c - '7');
+      else if (c >= 'a' && c <= 'f')
+        val += (c - 'W');
+      else if (c >= '0' && c <= '9')
+        val += (c - '0');
+      else
+        val += '?';
+      if (pos == 0 && hex.size() > 1)
+        val = (val << 4);
+    }
+    return val;
+  }
+
+  std::string block_to_hex_string(const uint8_t* const block, const size_t& size)
+  {
+    std::string buffer("");
+    for (size_t i = 0; i < size; i++) {
+      buffer += byte_to_hex(block[i]);
+    }
+    return buffer;
+  }
+
+  uint8_t* hex_string_to_block(const std::string& hex_string, size_t* const size)
+  {
+    size_t block_size = hex_string.size()/2 + ((hex_string.size() % 2 == 1) ? 1 : 0);
+    uint8_t* block = new uint8_t[block_size];
+    int offset = 0;
+    for (size_t i = 0;i < block_size; i++) {
+      if (i == 0 && hex_string.size() % 2 == 1) {
+        offset = -1;
+        block[i] = hex_to_byte(std::string("0") + hex_string[0]);
+        continue;
+      }
+      block[i] = hex_to_byte(std::string(1,hex_string[i*2 + offset]) + hex_string[i*2 + 1 + offset]);  
+    }
+    if (size != nullptr)
+      *size = block_size;
+    return block;
+  }  
+}

ByteConvert/ByteConvert.hpp

@@ -0,0 +1,112 @@
+/**
+ * @file ByteConvert.hpp
+ * 
+ * @authors Martin Dagarin
+ * @date 22/07/2018
+ * 
+ * @brief Header of ByteConvert module
+ */
+
+#ifndef _ByteConvert_hpp_
+#define _ByteConvert_hpp_
+
+#include <string>
+#include <cstdint>
+
+
+/**
+ * @brief Namespace which holds all ByteConvert functions
+ */
+namespace ByteConvert {
+  /**
+   * @brief Converts single byte to hex string
+   * 
+   * @param[in] byte Byte to convert to hex string
+   * @return Hex string
+   */
+  std::string byte_to_hex(const uint8_t& byte);
+
+  /**
+   * @brief Converts hex string (1 or 2 chars) to byte
+   * 
+   * @param[in] hex Hex string (1 or 2 chars) to convert to byte
+   * @return Byte
+   */
+  uint8_t hex_to_byte(const std::string& hex);
+
+  /**
+   * @brief Converts array of bytes to hex string
+   * 
+   * @param[in] block Array of bytes
+   * @param[in] size Size of block
+   * @return Hex string
+   */
+  std::string block_to_hex_string(const uint8_t* const block, const size_t& size);
+
+  /**
+   * @brief Converts hex string to array of bytes
+   * 
+   * @param[in] hex_string Hex string
+   * @param[out] size Size of returned array
+   * @return Array of bytes
+   */
+  uint8_t* hex_string_to_block(const std::string& hex_string,size_t* const size);  
+  
+  /**
+   * @brief Converts numeric without floating point variables (uses sizeof()) to array of bytes 
+   * 
+   * @param[in] variable Variable to convert to bytes
+   * @param[out] size Size of array (if pointer specifed)
+   * @return Array of bytes
+   */
+  template<class T>
+  uint8_t* to_block(T variable,size_t* const size)
+  {
+    uint8_t block_size = sizeof(T)/sizeof(uint8_t);
+    uint8_t *block = new uint8_t[block_size];
+    for (size_t i = 0; i < block_size; i++) {
+      if (i != 0) variable >>= 8;
+      block[block_size - 1 - i] = (uint8_t)(variable & 0xff);
+    }
+    if (size != nullptr)
+      *size = block_size;
+    return block;
+  }
+
+  /**
+   * @brief Converts byte to variable
+   * 
+   * @param[in] block Array of bytes
+   * @return Variable
+   */
+  template<class T>
+  T to_variable(const uint8_t* block)
+  {
+    size_t var_size = sizeof(T)/sizeof(uint8_t);
+    T var = 0x00;
+    for (size_t i = 0; i < var_size; i++) {
+      if (i != 0) var <<= 8;
+      var |= block[i];
+    }
+    return var;
+  }
+
+  /**
+   * @brief Converts byte to variable
+   * 
+   * @param[in] block Array of bytes
+   * @return Variable
+   */
+  template<class T>
+  T to_variable(const uint8_t* block, const size_t& block_size)
+  {
+    T var = 0x00;
+    for (size_t i = 0; i < block_size; i++) {
+      if (i != 0) var <<= 8;
+      var |= block[i];
+    }
+    return var;
+  }
+}
+
+#endif

libbyteconvert/meson.build renamed to ByteConvert/meson.build

@@ -0,0 +1,11 @@
+# 2.0.0
+- Rewritten whole library
+- Improved preformace
+- Changed function names
+- Improved meson framework
+- Fixed issues in Readme.md
+- Added make file
+- Added CI for auto testing
+- Added tests
+- Added examples
+- Fixed issues in `Readme.md`

CHANGELOG

@@ -0,0 +1,8 @@
+build:
+	meson build
+	ninja -C build
+	ninja -C build test
+install:
+	ninja -C build install
+clean:
+	rm -rf build

Makefile

@@ -1,84 +1,51 @@
 <p align="center"><img src="extras/graphics/512.png" alt="Byteconvert" height="200px"></p>
 
 # ByteConvert
+
 [![Build Status](https://travis-ci.org/SloCompTech/ByteConvert_cpp.svg?branch=master)](https://travis-ci.org/SloCompTech/ByteConvert_cpp)
 [![Packagist](https://img.shields.io/packagist/l/doctrine/orm.svg)]()    
 
 ## What's about ?
-Have you ever wanted to transmit `int`,`short`,`long`,`double` or any other numeric type over I2C,SPI,serial or other protocol or bus, but you converted variable to string to be able to transmit it char by char. This library enables you to convert any numeric value to bytes or other way around and you can also print array of bytes.
+
+Have you ever wanted to transmit `int`,`short`,`long` or any other numeric type over I2C,SPI,serial or other protocol or bus, but you converted variable to string to be able to transmit it char by char. This library enables you to convert any numeric value to bytes or other way around and you can also print array of bytes.
 
 ## What you need to consider, when you are using this library
+
 When you are using this library, you need to consider variable byte size, because if you are using different platforms, then there may be some errors, because int on platform 1 has 4 bytes and int on platform 2 may has 2 bytes.
 
 ## What you need to install this project ?
-You need [python3](https://www.python.org/), [ninja](https://ninja-build.org/) and [meson](http://mesonbuild.com).
-
-```
-$ sudo apt-get install python3 python3-pip ninja-build
-```
-
-## How to install
-```
-$ cd <library_directory>
-$ mkdir build
-$ meson build && cd build
-$ ninja
-$ sudo ninja install
-```
-
-If you have problems, that library can't be found run `sudo ldconfig /usr/local/lib/x86_64-linux-gnu/` if you haven't changed prefix, else mofidy path.
-
-## How to include library to your c or c++ project ?
-It's simple. At the top of your source file include library:
-``` c++
-#include<ByteConvert/ByteConvert.hpp>
-```
 
-And when you compile add flag `-lbyteconvert`, example `g++ -std=c++11 MyProject.cpp -lbyteconvert -o MyProject`.
-## Examples
-Convert numeric variable for eg. `int`,`short`,`float`,`double` to array of bytes.
-``` c++
-int somevar = 5;
-size_t blk_size = 0;
-uint8_t *block = ByteConvert::varToArray<int>(blk_size,somevar);
-
-// Use array
+You need [python3](https://www.python.org/), [ninja](https://ninja-build.org/) and [meson](http://mesonbuild.com).
 
-delete block; // Don't forget to free memory, when you don't need array any more
+```bash
+sudo apt-get install python3 python3-pip ninja-build
+sudo pip3 install meson
 ```
 
-Convert array of bytes to numeric variable.
-``` c++
-uint8_t *block; // Predefined byte array with size of int
-int somevar = ByteConvert::arrayToVar<int>(block);
-
-// Use block & somevar
+## Installing
+```bash
+meson build
+ninja -C build
+ninja -C build test
+ninja -C build install
 
-delete block; // Don't forget to free memory, when you don't need array any more
-
-// Use somevar
+# Or simply
+make
+sudo make install
 ```
 
-Convert array of bytes to string of hex characters
-``` c++
-size_t blk_size; // Predefined size of byte array
-uint8_t *block; // Predefined byte array with size of int
-String somevar = ByteConvert::arrayToString(blk_size,block);
+If you have problems, that library can't be found run `sudo ldconfig /usr/local/lib/x86_64-linux-gnu/` if you haven't changed prefix, else modify path.
 
-// Use block & somevar
+## How to include library to your c or c++ project ?
 
-delete block; // Don't forget to free memory, when you don't need array any more
+It's simple. At the top of your source file include library:
 
-// Use somevar
+```c++
+#include <ByteConvert/ByteConvert.hpp>
 ```
 
-Convert string of hex characters to array of bytes
-``` c++
-String somevar = ""; // Predefined string
-size_t blk_size = 0; 
-uint8_t *block = ByteConvert::stringToArray(blk_size,somevar);
+And when you compile add flag `-lbyteconvert`, example `g++ -std=c++11 MyProject.cpp -lbyteconvert -o MyProject`.
 
-// Use block 
+## Examples
 
-delete block; // Don't forget to free memory, when you don't need array any more
-```
+See [**examples folder**](https://github.com/SloCompTech/ByteConvert_cpp/tree/master/examples)