added progress callback

cli/Interface/MainClass.cpp

 #include <sysexits.h>
 #include <DBO/StringUtils.h>
 #include <Business/FreeFareDeviceBusiness.h>
+#include <iomanip>
 #include "DBO/Result.h"
 #include "Business/LibNfcBusiness.h"
 #include "CommandLineParser.h"
 //    keys.push_back(StringUtils::humanToRaw("ffffffffffff").getData());
     keys.push_back(StringUtils::humanToRaw("484558414354").getData());
 
-    int res = dump(tag, keys); //mapKeys(tag);
+    int res = dump(tag, keys);
+//    int res = mapKeys(tag, keys);
 
     device->close();
     libNfc.clean();
 
 int MainClass::mapKeys(std::shared_ptr<FreeFareTagBusiness> tag, std::vector<std::string> keys)
 {
-    auto mappedKeysResult = tag->mapKeys(keys);
+    auto mappedKeysResult = tag->mapKeys(keys, printPercent);
+    std::cout << "\r";
     if (!mappedKeysResult) {
         mappedKeysResult.print();
     }
 
 int MainClass::dump(std::shared_ptr<FreeFareTagBusiness> tag, std::vector<std::string> keys)
 {
-    auto dumpResult = tag->dump(keys);
+    auto dumpResult = tag->dump(keys, printPercent, printPercent);
+    std::cout << "\r";
     if (!dumpResult) {
         dumpResult.print();
         return 7;
     std::cout << " key B read: " << (accessBits.canKeyAReadKeyBTrailer() ? "A" : "") << (accessBits.canKeyBReadKeyBTrailer() ? "B" : "");
     std::cout << " key B write: " << (accessBits.canKeyAWriteKeyBTrailer() ? "A" : "") << (accessBits.canKeyBWriteKeyBTrailer() ? "B" : "") << std::endl;;
 }
+
+void MainClass::printPercent(int done, int total)
+{
+    std::cout << "\r" << std::fixed << std::setprecision(1) <<  ((float)done / (float)total * 100.0) << "%" << std::flush;
+}

cli/Interface/MainClass.h

 
     void printTrailerAccessBits(const AccessBitsDbo& accessBits);
 
+    static void printPercent(int done, int total);
+
 private:
     int _argc;
 

src/Business/FreeFareTagBusiness.cpp

     return _tag;
 }
 
-Result<MappedKeys> FreeFareTagBusiness::mapKeys(std::vector<std::string> keys)
+Result<MappedKeys> FreeFareTagBusiness::mapKeys(std::vector<std::string> keys, std::function<void(int, int)> cb)
 {
     std::vector<std::vector<std::pair<std::string, std::string>>> mappedKeys;
 
         std::vector<std::pair<std::string, std::string>> sectorKeys;
         for (int j = 0; j < 4; ++j) {
             std::pair<std::string, std::string> blockKeys;
-            for (auto key : keys) {
+            for (int k = 0; k < keys.size(); ++k) {
+                auto key = keys[k];
                 if (authenticate(i, j, key, MFC_KEY_A)) {
                     blockKeys.first = key;
                 }
                 if (authenticate(i, j, key, MFC_KEY_B)) {
                     blockKeys.second = key;
                 }
+                if (cb != 0) {
+                    cb((i * 4 * keys.size()) + (j * keys.size()) + k + 1, 16 * 4 * keys.size());
+                }
                 if (!blockKeys.first.empty() && !blockKeys.second.empty()) {
                     break;
                 }
     return Result<std::vector<std::vector<std::pair<std::string, std::string>>>>::ok(mappedKeys);
 }
 
-Result<std::vector<SectorDbo>> FreeFareTagBusiness::dump(MappedKeys keys)
+Result<std::vector<SectorDbo>> FreeFareTagBusiness::dump(MappedKeys keys, std::function<void(int, int)> cb)
 {
     if (keys.size() != 16) {
         return Result<std::vector<SectorDbo>>::error("Must have 16 sectors");
                 }
             }
             sector.setBlock(b, data);
+            if (cb != 0) {
+                cb((s * sectorKeys.size()) + b + 1, keys.size() * sectorKeys.size());
+            }
         }
         int b = sectorKeys.size() - 1;
         auto blockKey = sectorKeys[b];
         }
         sector.setBlock(b, data);
         AccessBitsDbo accessBitsDbo = sector.getAccessBitsDbo();
+        if (cb != 0) {
+            cb((s * sectorKeys.size()) + b + 1, keys.size() * sectorKeys.size());
+        }
 
         sector.setKeyA(keyA ? blockKey.first : "");
         sector.setKeyB(keyB ? blockKey.second : "");
     return Result<std::vector<SectorDbo>>::ok(sectors);
 }
 
-Result<std::vector<SectorDbo>> FreeFareTagBusiness::dump(std::vector<std::string> keys)
+Result<std::vector<SectorDbo>> FreeFareTagBusiness::dump(std::vector<std::string> keys, std::function<void(int, int)> mapCb, std::function<void(int, int)> dumpCb)
 {
-    auto mappedKeysResult = mapKeys(keys);
+    auto mappedKeysResult = mapKeys(keys, mapCb);
     if (!mappedKeysResult) {
         return Result<std::vector<SectorDbo>>::error(mappedKeysResult);
     }
-    return dump(mappedKeysResult.getData());
+    return dump(mappedKeysResult.getData(), dumpCb);
 }

src/Business/FreeFareTagBusiness.h

 
     Result<SectorDbo> readSector(int sector, std::string key, int keyType);
 
-    Result<MappedKeys> mapKeys(std::vector<std::string> keys);
+    Result<MappedKeys> mapKeys(std::vector<std::string> keys, std::function<void(int, int)> cb = 0);
 
-    Result<std::vector<SectorDbo>> dump(MappedKeys keys);
+    Result<std::vector<SectorDbo>> dump(MappedKeys keys, std::function<void(int, int)> cb  = 0);
 
-    Result<std::vector<SectorDbo>> dump(std::vector<std::string> keys);
+    Result<std::vector<SectorDbo>> dump(std::vector<std::string> keys, std::function<void(int, int)> mapCb = 0, std::function<void(int, int)> dumpCb = 0);
 
     const std::string& getUid() const;