C++ improvements

cli/cli/MainClass.cpp

 void MainClass::printVersion()
 {
     cout() << "LibNfc version: " << LibNfc::Core::LibNfcContext::getLibNfcVersion() << std::endl;
-    cout() << "Mifare-tools version: " << LibNfc::Core::LibNfcContext::getMifareToolsVersion() << std::endl;
+    cout() << "Mifare-tools version: " << LibNfc::Core::LibNfcContext::getLibNfcCppToolsVersion() << std::endl;
 }
 
 std::shared_ptr<LibNfc::Core::NfcDevice> MainClass::getDevice(const std::string &deviceName, std::vector<std::shared_ptr<LibNfc::Core::NfcDevice>> devices)

libnfc_cpptools/inc/libnfc_cpptools/ArrayUtils.h

 // Created by robin on 7/23/16.
 //
 
-#ifndef MIFARE_TOOLS_ARRAYUTILS_H
-#define MIFARE_TOOLS_ARRAYUTILS_H
+#ifndef LIBNFC_CPPTOOLS_ARRAYUTILS_H
+#define LIBNFC_CPPTOOLS_ARRAYUTILS_H
 
 
 namespace LibNfc
 }; // Utils
 }; // LibNfc
 
-#endif //MIFARE_TOOLS_ARRAYUTILS_H
+#endif // LIBNFC_CPPTOOLS_ARRAYUTILS_H

libnfc_cpptools/inc/libnfc_cpptools/FreeFareAccessBits.h

 // Created by robin on 7/21/16.
 //
 
-#ifndef MIFARE_TOOLS_ACCESSBITSDBO_H
-#define MIFARE_TOOLS_ACCESSBITSDBO_H
+#ifndef LIBNFC_CPPTOOLS_ACCESSBITSDBO_H
+#define LIBNFC_CPPTOOLS_ACCESSBITSDBO_H
 
 
 #include <string>
     static const char invertedBitPosition[4][4];
 
     FreeFareAccessBits();
-    FreeFareAccessBits(const std::string& bits);
+    explicit FreeFareAccessBits(const std::string& bits);
+    ~FreeFareAccessBits() = default;
 
     char getUserData() const;
     void setUserData(const char& data);
 }; // FreeFare
 }; // LibNfc
 
-#endif //MIFARE_TOOLS_ACCESSBITSDBO_H
+#endif //LIBNFC_CPPTOOLS_ACCESSBITSDBO_H

libnfc_cpptools/inc/libnfc_cpptools/FreeFareDevice.h

 // Created by robin on 7/22/16.
 //
 
-#ifndef MIFARE_TOOLS_FREEFAREDEVICEBUSINESS_H
-#define MIFARE_TOOLS_FREEFAREDEVICEBUSINESS_H
+#ifndef LIBNFC_CPPTOOLS_FREEFAREDEVICEBUSINESS_H
+#define LIBNFC_CPPTOOLS_FREEFAREDEVICEBUSINESS_H
 
 #include "NfcDevice.h"
 #include "FreeFareTag.h"
 class FreeFareDevice
 {
 public:
-    FreeFareDevice(std::shared_ptr<LibNfc::Core::NfcDevice> device);
+    explicit FreeFareDevice(std::shared_ptr<LibNfc::Core::NfcDevice> device);
+    ~FreeFareDevice() = default;
 
     LibNfc::Utils::Result<std::vector<std::shared_ptr<FreeFareTag>>> getTags() const;
 
 }; // FreeFare
 }; // LibNfc
 
-#endif //MIFARE_TOOLS_FREEFAREDEVICEBUSINESS_H
+#endif //LIBNFC_CPPTOOLS_FREEFAREDEVICEBUSINESS_H

libnfc_cpptools/inc/libnfc_cpptools/FreeFareSector.h

 // Created by robin on 7/22/16.
 //
 
-#ifndef MIFARE_TOOLS_SECTORDBO_H
-#define MIFARE_TOOLS_SECTORDBO_H
+#ifndef LIBNFC_CPPTOOLS_SECTORDBO_H
+#define LIBNFC_CPPTOOLS_SECTORDBO_H
 
 
 #include <string>
 class FreeFareSector
 {
 public:
-    FreeFareSector(const std::string& data = "");
+    explicit FreeFareSector(const std::string& data = "");
+    ~FreeFareSector() = default;
 
     const std::string& getBlock(int block) const;
 
 }; // FreeFare
 }; // LibNfc
 
-#endif //MIFARE_TOOLS_SECTORDBO_H
+#endif //LIBNFC_CPPTOOLS_SECTORDBO_H

libnfc_cpptools/inc/libnfc_cpptools/FreeFareTag.h

 // Created by robin on 7/22/16.
 //
 
-#ifndef MIFARE_TOOLS_FREEFARETAGBUSINESS_H
-#define MIFARE_TOOLS_FREEFARETAGBUSINESS_H
+#ifndef LIBNFC_CPPTOOLS_FREEFARETAGBUSINESS_H
+#define LIBNFC_CPPTOOLS_FREEFARETAGBUSINESS_H
 
 
 #include <boost/shared_ptr.hpp>
 
     static std::string getTagTypeString(FreeFareTagType type);
 
-    FreeFareTag(std::shared_ptr<FreeFareTagInternal> tag);
+    explicit FreeFareTag(std::shared_ptr<FreeFareTagInternal> tag);
+    ~FreeFareTag() = default;
 
-    LibNfc::Utils::ResultBool authenticate(int sector, std::string key, int keyType);
+    LibNfc::Utils::ResultBool authenticate(int sector, const std::string& key, int keyType);
 
-    LibNfc::Utils::Result<MappedKeys> mapKeys(std::vector<std::string> keys, std::function<void(int, int)> cb = 0);
+    LibNfc::Utils::Result<MappedKeys> mapKeys(const std::vector<std::string>& keys, std::function<void(int, int)> cb = nullptr);
 
-    LibNfc::Utils::ResultString readBlock(int sector, int block, std::string key, int keyType);
+    LibNfc::Utils::ResultString readBlock(int sector, int block, const std::string& key, int keyType);
 
-    LibNfc::Utils::Result<FreeFareSector> readSector(int sector, std::string key, int keyType);
+    LibNfc::Utils::Result<FreeFareSector> readSector(int sector, const std::string& key, int keyType);
 
-    LibNfc::Utils::Result<std::vector<FreeFareSector>> read(MappedKeys keys, std::function<void(int, int)> cb = 0);
+    LibNfc::Utils::Result<std::vector<FreeFareSector>> read(const MappedKeys& keys, std::function<void(int, int)> cb = nullptr);
 
-    LibNfc::Utils::Result<std::vector<FreeFareSector>> read(std::vector<std::string> keys, std::function<void(int, int)> mapCb = 0,
-                                        std::function<void(int, int)> readCb = 0);
+    LibNfc::Utils::Result<std::vector<FreeFareSector>> read(const std::vector<std::string>& keys, std::function<void(int, int)> mapCb = nullptr,
+                                        std::function<void(int, int)> readCb = nullptr);
 
-    LibNfc::Utils::ResultBool writeBlock(int sector, int block, std::string key, int keyType, const std::string& data);
+    LibNfc::Utils::ResultBool writeBlock(int sector, int block, const std::string& key, int keyType, const std::string& data);
 
-    LibNfc::Utils::ResultBool writeSector(int sector, std::string key, int keyType, const std::string& data);
+    LibNfc::Utils::ResultBool writeSector(int sector, const std::string& key, int keyType, const std::string& data);
 
-    LibNfc::Utils::ResultBool write(MappedKeys keys, const std::string& data, bool writeSector0, std::function<void(int, int)> cb = 0);
+    LibNfc::Utils::ResultBool write(const MappedKeys& keys, const std::string& data, bool writeSector0, std::function<void(int, int)> cb = nullptr);
 
-    LibNfc::Utils::ResultBool write(std::vector<std::string> keys, const std::string& data, bool writeSector0,
-                     std::function<void(int, int)> mapCb = 0, std::function<void(int, int)> writeCb = 0);
+    LibNfc::Utils::ResultBool write(const std::vector<std::string>& keys, const std::string& data, bool writeSector0,
+                     std::function<void(int, int)> mapCb = nullptr, std::function<void(int, int)> writeCb = nullptr);
 
     const std::string& getUid() const;
 
 }; // FreeFare
 }; // LibNfc
 
-#endif //MIFARE_TOOLS_FREEFARETAGBUSINESS_H
+#endif //LIBNFC_CPPTOOLS_FREEFARETAGBUSINESS_H

libnfc_cpptools/inc/libnfc_cpptools/LibNfc.h

 // Created by robin on 7/22/16.
 //
 
-#ifndef MIFARE_TOOLS_LIBNFCBUSINESS_H
-#define MIFARE_TOOLS_LIBNFCBUSINESS_H
+#ifndef LIBNFC_CPPTOOLS_LIBNFCBUSINESS_H
+#define LIBNFC_CPPTOOLS_LIBNFCBUSINESS_H
 
 
 #include <libnfc_cpptools/Result.h>
 
     static std::string getLibNfcVersion();
 
-    static std::string getMifareToolsVersion();
+    static std::string getLibNfcCppToolsVersion();
 
 protected:
     std::shared_ptr<LibNfcInternal> _libNfc;
 }; // Core
 }; // LibNfc
 
-#endif //MIFARE_TOOLS_LIBNFCBUSINESS_H
+#endif //LIBNFC_CPPTOOLS_LIBNFCBUSINESS_H

libnfc_cpptools/inc/libnfc_cpptools/NfcDevice.h

 // Created by robin on 7/22/16.
 //
 
-#ifndef MIFARE_TOOLS_NFCDEVICEBUSINESS_H
-#define MIFARE_TOOLS_NFCDEVICEBUSINESS_H
+#ifndef LIBNFC_CPPTOOLS_NFCDEVICEBUSINESS_H
+#define LIBNFC_CPPTOOLS_NFCDEVICEBUSINESS_H
 
 #include <string>
 #include <memory>
 class NfcDevice
 {
 public:
-    NfcDevice(std::shared_ptr<NfcDeviceInternal> device);
+    explicit NfcDevice(std::shared_ptr<NfcDeviceInternal> device);
+    ~NfcDevice() = default;
 
     LibNfc::Utils::ResultBool open();
 
 }; // Core
 }; // LibNfc
 
-#endif //MIFARE_TOOLS_NFCDEVICEBUSINESS_H
+#endif //LIBNFC_CPPTOOLS_NFCDEVICEBUSINESS_H

libnfc_cpptools/inc/libnfc_cpptools/Result.h

 #include <string>
 #include <vector>
 #include <iostream>
-#include <errno.h>
-#include <string.h>
+#include <cerrno>
+#include <cstring>
 
 namespace LibNfc
 {
 template <class T> class Result
 {
 public:
+    Result();
+
     static const Result<T> ok(const T& data);
     static const Result<T> strerror();
     static const Result<T> error(const std::string& error);
     const Result<T>& print() const;
 
 private:
-    Result();
-
     T _data;
 
     std::string _error;
 
 template<class T>
 Result<T>::Result()
+    : _success(false)
 {
 }
 

libnfc_cpptools/inc/libnfc_cpptools/StringUtils.h

 // Created by robin on 6/20/16.
 //
 
-#ifndef MIFARE_TOOLS_HEX_H
-#define MIFARE_TOOLS_HEX_H
+#ifndef LIBNFC_CPPTOOLS_HEX_H
+#define LIBNFC_CPPTOOLS_HEX_H
 
 
 #include <string>
 }; // Utils
 }; // LibNfc
 
-#endif //MIFARE_TOOLS_HEX_H
+#endif //LIBNFC_CPPTOOLS_HEX_H

libnfc_cpptools/src/freefare/FreeFareAccessBits.cpp

 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
-    bool c3 = getBit(3, 3);
     return !c1 && !c2;
 }
 
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
-    bool c3 = getBit(3, 3);
     return !c1 && !c2;
 }
 

libnfc_cpptools/src/freefare/FreeFareDeviceInternal.h

 // Created by robin on 6/19/16.
 //
 
-#ifndef MIFARE_TOOLS_FREEFAREDEVICE_H
-#define MIFARE_TOOLS_FREEFAREDEVICE_H
+#ifndef LIBNFC_CPPTOOLS_FREEFAREDEVICE_H
+#define LIBNFC_CPPTOOLS_FREEFAREDEVICE_H
 
 
 #include <freefare.h>
 class FreeFareDeviceInternal
 {
 public:
-    FreeFareDeviceInternal(std::shared_ptr<LibNfc::Core::NfcDeviceInternal> device);
+    explicit FreeFareDeviceInternal(std::shared_ptr<LibNfc::Core::NfcDeviceInternal> device);
+    ~FreeFareDeviceInternal() = default;
 
     LibNfc::Utils::Result<std::vector<std::shared_ptr<FreeFareTagInternal>>> getTags();
 
 }; // FreeFare
 }; // LibNfc
 
-#endif //MIFARE_TOOLS_FREEFAREDEVICE_H
+#endif //LIBNFC_CPPTOOLS_FREEFAREDEVICE_H

libnfc_cpptools/src/freefare/FreeFareSector.cpp

 FreeFareSector::FreeFareSector(const std::string &data)
 {
     std::string d = LibNfc::Utils::StringUtils::ensureSize(data, 64);
-    for (int i = 0; i < 4; ++i) {
+    for (unsigned int i = 0; i < 4; ++i) {
         _blocks[i] = d.substr(16 * i, 16);
         _haveBlocks[i] = true;
     }

libnfc_cpptools/src/freefare/FreeFareTag.cpp

 {
 }
 
-LibNfc::Utils::ResultBool FreeFareTag::authenticate(int sector, std::string key, int keyType)
+LibNfc::Utils::ResultBool FreeFareTag::authenticate(int sector, const std::string& key, int keyType)
 {
     return _tag->authenticate(sector, key, keyType);
 }
 
-LibNfc::Utils::Result<MappedKeys> FreeFareTag::mapKeys(std::vector<std::string> keys, std::function<void(int, int)> cb)
+LibNfc::Utils::Result<MappedKeys> FreeFareTag::mapKeys(const std::vector<std::string>& keys, std::function<void(int, int)> cb)
 {
     MappedKeys mappedKeys;
-    int done = 0;
-    int total = 16 * keys.size();
+    unsigned long done = 0;
+    unsigned long total = 16 * keys.size();
 
     for (int i = 0; i < 16; ++i) {
         std::pair<std::string, std::string> blockKeys;
-        for (int k = 0; k < keys.size(); ++k) {
-            auto key = keys[k];
+        for (const auto& key : keys)
+        {
             if (authenticate(i, key, MFC_KEY_A)) {
                 blockKeys.first = key;
             }
             if (authenticate(i, key, MFC_KEY_B)) {
                 blockKeys.second = key;
             }
-            if (cb != 0) {
+            if (cb != nullptr) {
                 cb(++done, total);
             }
             if (!blockKeys.first.empty() && !blockKeys.second.empty()) {
         }
         mappedKeys.push_back(blockKeys);
     }
-    if (cb != 0 && done < total) {
+    if (cb != nullptr && done < total) {
         cb(total, total);
     }
 
     return LibNfc::Utils::Result<MappedKeys>::ok(mappedKeys);
 }
 
-LibNfc::Utils::ResultString FreeFareTag::readBlock(int sector, int block, std::string key, int keyType)
+LibNfc::Utils::ResultString FreeFareTag::readBlock(int sector, int block, const std::string& key, int keyType)
 {
     return _tag->readBlock(sector, block, key, keyType);
 }
 
-LibNfc::Utils::Result<FreeFareSector> FreeFareTag::readSector(int sector, std::string key, int keyType)
+LibNfc::Utils::Result<FreeFareSector> FreeFareTag::readSector(int sector, const std::string& key, int keyType)
 {
     std::string res;
     int lastBlock = _tag->getSectorBlockCount(sector);
     return LibNfc::Utils::Result<FreeFareSector>::ok(FreeFareSector(res));
 }
 
-LibNfc::Utils::Result<std::vector<FreeFareSector>> FreeFareTag::read(MappedKeys keys, std::function<void(int, int)> cb)
+LibNfc::Utils::Result<std::vector<FreeFareSector>> FreeFareTag::read(const MappedKeys& keys, std::function<void(int, int)> cb)
 {
     if (keys.size() != 16) {
         return LibNfc::Utils::Result<std::vector<FreeFareSector>>::error("Must have 16 sectors keys");
                 }
             }
             sector.setBlock(b, data);
-            if (cb != 0) {
+            if (cb != nullptr) {
                 cb(++done, total);
             }
         }
         int b = 3;
-        std::string dataA = "";
-        std::string dataB = "";
+        std::string dataA;
+        std::string dataB;
         if (!sectorKey.first.empty()) {
             auto blockResult = readBlock(s, b, sectorKey.first, MFC_KEY_A);
             if (blockResult) {
                 keyB = true;
             }
         }
-        if (cb != 0) {
+        if (cb != nullptr) {
             cb(++done, total);
         }
 
 
         sectors.push_back(sector);
     }
-    if (cb != 0 && done < total) {
+    if (cb != nullptr && done < total) {
         cb(total, total);
     }
 
     return LibNfc::Utils::Result<std::vector<FreeFareSector>>::ok(sectors);
 }
 
-LibNfc::Utils::Result<std::vector<FreeFareSector>> FreeFareTag::read(std::vector<std::string> keys, std::function<void(int, int)> mapCb,
-                                                         std::function<void(int, int)> readCb)
+LibNfc::Utils::Result<std::vector<FreeFareSector>> FreeFareTag::read(const std::vector<std::string>& keys,
+                                                                     std::function<void(int, int)> mapCb,
+                                                                     std::function<void(int, int)> readCb)
 {
     auto mappedKeysResult = mapKeys(keys, mapCb);
     if (!mappedKeysResult) {
     return read(mappedKeysResult.getData(), readCb);
 }
 
-LibNfc::Utils::ResultBool FreeFareTag::writeBlock(int sector, int block, std::string key, int keyType, const std::string &data)
+LibNfc::Utils::ResultBool FreeFareTag::writeBlock(int sector, int block, const std::string& key, int keyType, const std::string& data)
 {
     return _tag->writeBlock(sector, block, key, keyType, LibNfc::Utils::StringUtils::ensureSize(data, 16));
 }
 
-LibNfc::Utils::ResultBool FreeFareTag::writeSector(int sector, std::string key, int keyType, const std::string &data)
+LibNfc::Utils::ResultBool FreeFareTag::writeSector(int sector, const std::string& key, int keyType, const std::string& data)
 {
     std::string d = LibNfc::Utils::StringUtils::ensureSize(data, 64);
     std::string errors;
     return LibNfc::Utils::ResultBool::error(errors);
 }
 
-LibNfc::Utils::ResultBool FreeFareTag::write(MappedKeys keys, const std::string &data, bool writeSector0, std::function<void(int, int)> cb)
+LibNfc::Utils::ResultBool FreeFareTag::write(const MappedKeys& keys, const std::string& data, bool writeSector0, std::function<void(int, int)> cb)
 {
     if (keys.size() != 16) {
         return LibNfc::Utils::ResultBool::error("Must have 16 sectors keys");
     }
     std::string d = LibNfc::Utils::StringUtils::ensureSize(data, 1024);
     std::string errors;
-    int done = 0;
-    int total = 4 * keys.size();
-    for (int s = 0; s < keys.size(); ++s) {
+    unsigned long done = 0;
+    unsigned long total = 4 * keys.size();
+    for (unsigned long s = 0; s < keys.size(); ++s) {
         auto sectorKey = keys[s];
         for (int b = 0; b < 4; ++b) {
             if (s == 0 && b == 0 && !writeSector0) {
                 continue;
             }
             std::string blockData = d.substr((s * 64) + (b * 16), 16);
-            if (cb != 0 && done < total) {
+            if (cb != nullptr && done < total) {
                 bool keyA = false;
                 bool keyB = false;
                 std::string sectorErrors;
             }
         }
     }
-    if (cb != 0 && done < total) {
+    if (cb != nullptr && done < total) {
         cb(total, total);
     }
     if (errors.empty()) {
     return LibNfc::Utils::ResultBool::error(errors);
 }
 
-LibNfc::Utils::ResultBool FreeFareTag::write(std::vector<std::string> keys, const std::string &data, bool writeSector0,
+LibNfc::Utils::ResultBool FreeFareTag::write(const std::vector<std::string>& keys, const std::string& data, bool writeSector0,
                                       std::function<void(int, int)> mapCb, std::function<void(int, int)> writeCb)
 {
     auto mappedKeysResult = mapKeys(keys, mapCb);

libnfc_cpptools/src/freefare/FreeFareTagInternal.h

 // Created by robin on 6/19/16.
 //
 
-#ifndef MIFARE_TOOLS_FREEFARETAG_H
-#define MIFARE_TOOLS_FREEFARETAG_H
+#ifndef LIBNFC_CPPTOOLS_FREEFARETAG_H
+#define LIBNFC_CPPTOOLS_FREEFARETAG_H
 
 #include <freefare.h>
 #include <string>
 {
 public:
 
-    FreeFareTagInternal(FreefareTag tag);
+    explicit FreeFareTagInternal(FreefareTag tag);
     ~FreeFareTagInternal();
 
     LibNfc::Utils::ResultBool authenticate(int sector, std::string key, int keyType);
 }; // FreeFare
 }; // LibNfc
 
-#endif //MIFARE_TOOLS_FREEFARETAG_H
+#endif //LIBNFC_CPPTOOLS_FREEFARETAG_H

libnfc_cpptools/src/libnfc/LibNfc.cpp

     return LibNfc::Utils::Result<std::vector<std::shared_ptr<NfcDevice>>>::ok(devicesBusiness);
 }
 
-std::string LibNfcContext::getMifareToolsVersion()
+std::string LibNfcContext::getLibNfcCppToolsVersion()
 {
     return QUOTE(GIT_REF_NAME)  "-"  QUOTE(GIT_SHA1);
 }

libnfc_cpptools/src/libnfc/LibNfcInternal.h

 // Created by robin on 6/19/16.
 //
 
-#ifndef MIFARE_TOOLS_LIBNFC_H
-#define MIFARE_TOOLS_LIBNFC_H
+#ifndef LIBNFC_CPPTOOLS_LIBNFC_H
+#define LIBNFC_CPPTOOLS_LIBNFC_H
 
 #include <memory>
 #include <nfc/nfc.h>
 }; // Core
 }; // LibNfc
 
-#endif //MIFARE_TOOLS_LIBNFC_H
+#endif //LIBNFC_CPPTOOLS_LIBNFC_H

libnfc_cpptools/src/libnfc/NfcDeviceInternal.cpp

 
 NfcDeviceInternal::NfcDeviceInternal(const LibNfcInternal* libNfc, const std::string& str)
     : _connStr(str)
-    , _device(0)
+    , _device(nullptr)
     , _libNfc(libNfc)
 {
 }
 void NfcDeviceInternal::close()
 {
     nfc_close(_device);
-    _device = 0;
+    _device = nullptr;
 }
 
 nfc_device *NfcDeviceInternal::getDevice() const

libnfc_cpptools/src/libnfc/NfcDeviceInternal.h

 // Created by robin on 6/19/16.
 //
 
-#ifndef MIFARE_TOOLS_NFCDEVICEDBO_H
-#define MIFARE_TOOLS_NFCDEVICEDBO_H
+#ifndef LIBNFC_CPPTOOLS_NFCDEVICEDBO_H
+#define LIBNFC_CPPTOOLS_NFCDEVICEDBO_H
 
 
 #include <string>
 }; // Core
 }; // LibNfc
 
-#endif //MIFARE_TOOLS_NFCDEVICEDBO_H
+#endif //LIBNFC_CPPTOOLS_NFCDEVICEDBO_H