tests; hex tools

src/CMakeLists.txt

   DataAccess/ScReader.cpp
   include/ScReader.h
   include/ScReader.hxx)
-add_library(pcsc_cpptools SHARED ${SOURCE_FILES})
+add_library(pcsc_cpptools SHARED ${SOURCE_FILES} include/ScHex.h DBO/ScHex.cpp)
 target_link_libraries(pcsc_cpptools pcsclite)

src/DBO/ScBasicCommand.cpp

 //
 
 #include <string>
+#include <ScHex.h>
 #include "ScBasicCommand.h"
 
 ScBasicCommand::ScBasicCommand(const std::string &data)
 {
-    DWORD size = 0;
-    for (auto c : data)
-    {
-        if (isxdigit(c))
-            ++size;
-    }
-    auto d = new BYTE[size];
-    size = 0;
-    for (int i = 0; i < data.size(); ++i)
-    {
-        auto c = data[i];
-        if (isxdigit(c))
-            d[size++] = hexToDec(c);
-    }
-    _data = ScByteArray(d, size);
+    _data = ScHex::stringToByteArray(data);
 }
 
 ScBasicCommand::~ScBasicCommand()

src/DBO/ScCommand.cpp

 {
 }
 
-int ScCommand::hexToDec(const char c)
-{
-    if (c >= 'a')
-        return 10 + (c - ('a' - 'A')) - 'A';
-    if (c >= 'A')
-        return 10 + c - 'A';
-    return c - '0';
-}

src/DBO/ScHex.cpp

+//
+// Created by robin on 6/29/15.
+//
+
+#include <sstream>
+#include "ScHex.h"
+
+
+char ScHex::hexCharToInt(const char& c)
+{
+    if (c >= 'a')
+        return (char)(10 + (c - ('a' - 'A')) - 'A');
+    if (c >= 'A')
+        return (char)(10 + c - 'A');
+    return c - '0';
+}
+
+ScByteArray ScHex::stringToByteArray(const std::string &str)
+{
+    std::string hexa;
+    for (auto c : str)
+    {
+        if (isxdigit(c))
+            hexa += c;
+    }
+    if (hexa.size() % 2)
+        hexa.insert(0, "0");
+    auto data = new BYTE[hexa.size() / 2];
+    for (size_t i = 0; i < hexa.size(); i += 2)
+    {
+        data[i / 2] = (hexCharToInt(hexa[i]) << 4) | hexCharToInt(hexa[i + 1]);
+    }
+    return ScByteArray(data, hexa.size() / 2);
+}
+
+std::string ScHex::byteArrayToString(const ScByteArray &bytes, const std::string &separator)
+{
+    std::string res;
+    for (DWORD i = 0; i < bytes.getSize();++i)
+    {
+        res += intToHexChar(bytes.getData()[i]);
+        if (i != bytes.getSize() - 1)
+            res += separator;
+    }
+    return res;
+}
+
+std::string ScHex::intToHexChar(const char &c)
+{
+    std::string res;
+    for (auto c1 : {(c & 0xf0) >> 4, c & 0x0f})
+    {
+        if (c1 < 10)
+            res += '0' + c1;
+        else
+            res += 'A' + (c1 - 10);
+    }
+    return res;
+}

src/DataAccess/ScReader.cpp

 #include <vector>
 #include "ScReader.h"
 
-LPSCARDCONTEXT ScReader::_context = nullptr;
+thread_local LPSCARDCONTEXT ScReader::_context = nullptr;
 
 ScReader::~ScReader()
 {

src/include/ScCommand.h

 
     virtual ScByteArray getData() const = 0;
 
-    static int hexToDec(const char c);
-
 };
 
 # include "ScCommand.hxx"

src/include/ScHex.h

+//
+// Created by robin on 6/29/15.
+//
+
+#ifndef PCSC_CPPTOOLS_SCHEX_H
+# define PCSC_CPPTOOLS_SCHEX_H
+
+# include <string>
+#include "ScByteArray.h"
+
+class ScHex
+{
+public:
+    static char hexCharToInt(const char& c);
+
+    static std::string intToHexChar(const char& c);
+
+    static std::string byteArrayToString(const ScByteArray& bytes, const std::string& separator = " ");
+
+    static ScByteArray stringToByteArray(const std::string& str);
+
+};
+
+#endif //PCSC_CPPTOOLS_SCHEX_H

tests/test_pcsc_cpp_tools.cpp

 #include <iostream>
-#include "ScReader.h"
+#include <ScHex.h>
+#include <ScReader.h>
 
 int main()
 {
+  auto bytes = new BYTE[5];
+  bytes[0] = 0x42;
+  bytes[1] = 0x00;
+  bytes[2] = 0xff;
+  bytes[3] = 0xaa;
+  bytes[4] = 0x24;
+  std::cout << "hex: " << ScHex::byteArrayToString(ScByteArray(bytes, 5)) << std::endl;
+
   std::cout << ScReader::establishContext() << std::endl;
   auto readers = ScReader::getReaders();
   for (auto reader : readers)