* Moved functions in argumentparser.h to 'cmdline' namespace

end2endzone · end2endzone · commit a38f439f803c · 2018-01-23T19:29:43.000-05:00
* Moved loggers functions to 'logger' namespace.
diff --git a/src/argumentparser.cpp b/src/argumentparser.cpp
@@ -2,7 +2,7 @@
 
 #include "argumentparser.h"
 
-namespace bin2cpp
+namespace cmdline
 {
   bool parseArgument(const std::string & name, std::string & value, int argc, char **argv)
   {
@@ -75,4 +75,4 @@ namespace bin2cpp
     return false;
   }
 
-}; //bin2cpp
+}; //cmdline
diff --git a/src/argumentparser.h b/src/argumentparser.h
@@ -2,7 +2,7 @@
 
 #include <string>
 
-namespace bin2cpp
+namespace cmdline
 {
   ///<summary>
   ///Parses an argument from the command line parameters (argc, argv)
@@ -37,4 +37,4 @@ namespace bin2cpp
   ///<return>True when an argument named [name] is found. False otherwise.<return>
   bool parseArgument(const std::string & name, size_t & value, int argc, char **argv);
 
-}; //bin2cpp
+}; //cmdline
diff --git a/src/logger.cpp b/src/logger.cpp
@@ -6,7 +6,7 @@
 #include <stdarg.h>
 #include <shlobj.h>
 
-namespace bin2cpp
+namespace logger
 {
   bool gQuietMode = false;
 
@@ -52,4 +52,4 @@ namespace bin2cpp
     }
   }
 
-}; //bin2cpp
+}; //logger
diff --git a/src/logger.h b/src/logger.h
@@ -2,7 +2,7 @@
 
 #include <string>
 
-namespace bin2cpp
+namespace logger
 {
 
   ///<summary>
@@ -34,4 +34,4 @@ namespace bin2cpp
   ///<param name="iFormat">The format of the given argument. Same as printf's format.</param>
   void log(LOGGER_LEVEL iLevel, const char * iFormat, ...);
 
-}; //bin2cpp
+}; //logger
diff --git a/src/main.cpp b/src/main.cpp
@@ -117,7 +117,7 @@ int main(int argc, char* argv[])
 {
   //help
   std::string dummy;
-  if (bin2cpp::parseArgument("help", dummy, argc, argv))
+  if (cmdline::parseArgument("help", dummy, argc, argv))
   {
     printHeader();
     printUsage();
@@ -126,14 +126,14 @@ int main(int argc, char* argv[])
 
   //noheader
   bool noheader = false;
-  if (bin2cpp::parseArgument("noheader", dummy, argc, argv))
+  if (cmdline::parseArgument("noheader", dummy, argc, argv))
   {
     noheader = true;
   }
 
   //quiet
   bool quiet = false;
-  if (bin2cpp::parseArgument("quiet", dummy, argc, argv))
+  if (cmdline::parseArgument("quiet", dummy, argc, argv))
   {
     quiet = true;
   }
@@ -142,10 +142,10 @@ int main(int argc, char* argv[])
   if (quiet)
     noheader = true;
 
-  bin2cpp::setQuietMode(quiet);
+  logger::setQuietMode(quiet);
 
   //version
-  if (bin2cpp::parseArgument("version", dummy, argc, argv))
+  if (cmdline::parseArgument("version", dummy, argc, argv))
   {
     if (!noheader)
       printHeader();
@@ -161,34 +161,34 @@ int main(int argc, char* argv[])
   std::string headerFilename;
   std::string functionIdentifier;
 
-  if (!bin2cpp::parseArgument("file", inputFile, argc, argv))
+  if (!cmdline::parseArgument("file", inputFile, argc, argv))
   {
     APP_ERROR_CODES error = APP_ERROR_MISSINGARGUMENTS;
-    bin2cpp::log(bin2cpp::LOG_ERROR, "%s (file)", getErrorCodeDescription(error));
+    logger::log(logger::LOG_ERROR, "%s (file)", getErrorCodeDescription(error));
     printUsage();
     return error;
   }
 
-  if (!bin2cpp::parseArgument("output", outputFolder, argc, argv))
+  if (!cmdline::parseArgument("output", outputFolder, argc, argv))
   {
     APP_ERROR_CODES error = APP_ERROR_MISSINGARGUMENTS;
-    bin2cpp::log(bin2cpp::LOG_ERROR, "%s (output)", getErrorCodeDescription(error));
+    logger::log(logger::LOG_ERROR, "%s (output)", getErrorCodeDescription(error));
     printUsage();
     return error;
   }
 
-  if (!bin2cpp::parseArgument("headerfile", headerFilename, argc, argv))
+  if (!cmdline::parseArgument("headerfile", headerFilename, argc, argv))
   {
     APP_ERROR_CODES error = APP_ERROR_MISSINGARGUMENTS;
-    bin2cpp::log(bin2cpp::LOG_ERROR, "%s (headerfile)", getErrorCodeDescription(error));
+    logger::log(logger::LOG_ERROR, "%s (headerfile)", getErrorCodeDescription(error));
     printUsage();
     return error;
   }
 
-  if (!bin2cpp::parseArgument("identifier", functionIdentifier, argc, argv))
+  if (!cmdline::parseArgument("identifier", functionIdentifier, argc, argv))
   {
     APP_ERROR_CODES error = APP_ERROR_MISSINGARGUMENTS;
-    bin2cpp::log(bin2cpp::LOG_ERROR, "%s (identifier)", getErrorCodeDescription(error));
+    logger::log(logger::LOG_ERROR, "%s (identifier)", getErrorCodeDescription(error));
     printUsage();
     return error;
   }
@@ -206,27 +206,27 @@ int main(int argc, char* argv[])
   std::string encodingStr;
 
   size_t tmpChunkSize = 0;
-  if (bin2cpp::parseArgument("chunksize", tmpChunkSize, argc, argv))
+  if (cmdline::parseArgument("chunksize", tmpChunkSize, argc, argv))
   {
     chunkSize = tmpChunkSize;
   }
 
-  if (bin2cpp::parseArgument("override", dummy, argc, argv))
+  if (cmdline::parseArgument("override", dummy, argc, argv))
   {
     overrideExisting = true;
   }
 
-  if (!bin2cpp::parseArgument("namespace", codeNamespace, argc, argv))
+  if (!cmdline::parseArgument("namespace", codeNamespace, argc, argv))
   {
     codeNamespace = DEFAULT_NAMESPACE;
   }
 
-  if (!bin2cpp::parseArgument("baseclass", baseClass, argc, argv))
+  if (!cmdline::parseArgument("baseclass", baseClass, argc, argv))
   {
     baseClass = DEFAULT_BASECLASSNAME;
   }
 
-  if (bin2cpp::parseArgument("encoding", encodingStr, argc, argv))
+  if (cmdline::parseArgument("encoding", encodingStr, argc, argv))
   {
     if (uppercase(encodingStr) == "OCT")
       encoding = IGenerator::CPP_ENCODER_OCT;
@@ -235,7 +235,7 @@ int main(int argc, char* argv[])
     else
     {
       APP_ERROR_CODES error = APP_ERROR_MISSINGARGUMENTS;
-      bin2cpp::log(bin2cpp::LOG_ERROR, "%s (encoding)", getErrorCodeDescription(error));
+      logger::log(logger::LOG_ERROR, "%s (encoding)", getErrorCodeDescription(error));
       printUsage();
       return error;
     }
@@ -252,7 +252,7 @@ int main(int argc, char* argv[])
   bin2cpp::IGenerator * generator = NULL;
 
   std::string generatorName;
-  if (bin2cpp::parseArgument("generator", generatorName, argc, argv))
+  if (cmdline::parseArgument("generator", generatorName, argc, argv))
   {
     if (generatorName == "segment")
     {
@@ -271,7 +271,7 @@ int main(int argc, char* argv[])
     if (generator == NULL)
     {
       APP_ERROR_CODES error = APP_ERROR_MISSINGARGUMENTS;
-      bin2cpp::log(bin2cpp::LOG_ERROR, "%s, unknown values for 'generator' argument!", getErrorCodeDescription(error));
+      logger::log(logger::LOG_ERROR, "%s, unknown values for 'generator' argument!", getErrorCodeDescription(error));
       printUsage();
       return error;
     }
@@ -295,7 +295,7 @@ int main(int argc, char* argv[])
   if (overrideExisting)
     info << " overriding existing files";
   info << "...";
-  bin2cpp::log(bin2cpp::LOG_INFO, info.c_str());
+  logger::log(logger::LOG_INFO, info.c_str());
 
   //prepare output files path
   std::string outputHeaderPath = outputFolder + "\\" + headerFilename;
@@ -340,7 +340,7 @@ FILE_UPDATE_MODE getFileUpdateMode(const std::string & inputFile, const std::str
   uint64_t lastModifiedDate = getFileModifiedDate(inputFile);
   uint64_t outputModifiedDate = getOutputFileModifiedDate(iOutputFilePath);
   if (outputModifiedDate == 0)
-    bin2cpp::log(bin2cpp::LOG_WARNING, "Unable to get last modified date of file \'%s\'", iOutputFilePath.c_str());
+    logger::log(logger::LOG_WARNING, "Unable to get last modified date of file \'%s\'", iOutputFilePath.c_str());
   if (lastModifiedDate == outputModifiedDate)
     return SKIPPING;
 
@@ -353,7 +353,7 @@ bool processFile(const std::string & inputFile, const std::string & iOutputFileP
   FILE_UPDATE_MODE mode = getFileUpdateMode(inputFile, iOutputFilePath, overrideExisting);
 
   //writing message
-  bin2cpp::log(bin2cpp::LOG_INFO, "%s file \"%s\"...", getUpdateModeText(mode), iOutputFilePath.c_str());
+  logger::log(logger::LOG_INFO, "%s file \"%s\"...", getUpdateModeText(mode), iOutputFilePath.c_str());
   
   if (mode == SKIPPING)
     return true; //skipping is success
@@ -373,8 +373,8 @@ bool processFile(const std::string & inputFile, const std::string & iOutputFileP
   if (!result)
   {
     //there was an error generating file
-    bin2cpp::log(bin2cpp::LOG_ERROR, "%s", getErrorCodeDescription(APP_ERROR_UNABLETOCREATEOUTPUTFILES));
-    bin2cpp::log(bin2cpp::LOG_ERROR, "Embedding failed!");
+    logger::log(logger::LOG_ERROR, "%s", getErrorCodeDescription(APP_ERROR_UNABLETOCREATEOUTPUTFILES));
+    logger::log(logger::LOG_ERROR, "Embedding failed!");
   }
   return result;
 }
diff --git a/test/testfilegenerator.cpp b/test/testfilegenerator.cpp
@@ -84,74 +84,74 @@ int main(int argc, char **argv)
 
   //help
   std::string tmp;
-  if (bin2cpp::parseArgument("help", tmp, argc, argv))
+  if (cmdline::parseArgument("help", tmp, argc, argv))
   {
     printVersion();
     printUsage();
     return EXIT_NO_ERROR;
   }
 
   //version
-  if (bin2cpp::parseArgument("version", tmp, argc, argv))
+  if (cmdline::parseArgument("version", tmp, argc, argv))
   {
     printVersion();
     return EXIT_NO_ERROR;
   }
 
   //quiet
   std::string tmpQuiet;
-  if (bin2cpp::parseArgument("quiet", tmpQuiet, argc, argv))
+  if (cmdline::parseArgument("quiet", tmpQuiet, argc, argv))
   {
-    bin2cpp::setQuietMode(true);
+    logger::setQuietMode(true);
   }
 
   //file
-  if (!bin2cpp::parseArgument("file", file, argc, argv))
+  if (!cmdline::parseArgument("file", file, argc, argv))
   {
-    bin2cpp::log(bin2cpp::LOG_ERROR, "Missing 'file' argument!");
+    logger::log(logger::LOG_ERROR, "Missing 'file' argument!");
     printUsage();
     return MISSING_FILE;
   }
 
   //size
   int tmpSize = 0;
-  if (bin2cpp::parseArgument("size", tmpSize, argc, argv))
+  if (cmdline::parseArgument("size", tmpSize, argc, argv))
   {
     size = tmpSize;
     if (size <= 0)
     {
-      bin2cpp::log(bin2cpp::LOG_ERROR, "Invalid file size!");
+      logger::log(logger::LOG_ERROR, "Invalid file size!");
       return INVALID_FILE_SIZE;
     }
   }
 
   //seed
   int tmpSeed = 0;
-  if (bin2cpp::parseArgument("seed", tmpSeed, argc, argv))
+  if (cmdline::parseArgument("seed", tmpSeed, argc, argv))
   {
     seed = tmpSeed;
     if (seed < 0)
     {
-      bin2cpp::log(bin2cpp::LOG_ERROR, "Invalid seed value!");
+      logger::log(logger::LOG_ERROR, "Invalid seed value!");
       return INVALID_SEED;
     }
   }
 
   //skip
   int tmpSkip = 0;
-  if (bin2cpp::parseArgument("skip", tmpSkip, argc, argv))
+  if (cmdline::parseArgument("skip", tmpSkip, argc, argv))
   {
     skip = tmpSkip;
     if (skip < 0)
     {
-      bin2cpp::log(bin2cpp::LOG_ERROR, "Invalid skip value!");
+      logger::log(logger::LOG_ERROR, "Invalid skip value!");
       return INVALID_SKIP;
     }
   }
 
   //fill
   std::string tmpFill;
-  if (bin2cpp::parseArgument("fill", tmpFill, argc, argv))
+  if (cmdline::parseArgument("fill", tmpFill, argc, argv))
   {
     if (tmpFill == "sequential" ||
         tmpFill == "random" ||
@@ -162,21 +162,21 @@ int main(int argc, char **argv)
     }
     else
     {
-      bin2cpp::log(bin2cpp::LOG_ERROR, "Invalid fill parameter!");
+      logger::log(logger::LOG_ERROR, "Invalid fill parameter!");
       return INVALID_FILL_PARAMETER;
     }
   }
 
   //building info string
   std::string infostr;
   infostr << "Writing " << size << " bytes" << getSizeAdditionalInfo(size) << " of " << fill << " data into \'" << file << "\'.";
-  bin2cpp::log(bin2cpp::LOG_INFO, "%s", infostr.c_str());
+  logger::log(logger::LOG_INFO, "%s", infostr.c_str());
 
   //process with file generation
   FILE * f = fopen(file.c_str(), "wb");
   if (!f)
   {
-    bin2cpp::log(bin2cpp::LOG_ERROR, "Cannot create file '%s'!", file.c_str());
+    logger::log(logger::LOG_ERROR, "Cannot create file '%s'!", file.c_str());
     return 4;
   }
 

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`#include "argumentparser.h"`
`4`	`4`
`5`		`-namespace bin2cpp`
	`5`	`+namespace cmdline`
`6`	`6`	`{`
`7`	`7`	`bool parseArgument(const std::string & name, std::string & value, int argc, char **argv)`
`8`	`8`	`{`
`@@ -75,4 +75,4 @@ namespace bin2cpp`
`75`	`75`	`return false;`
`76`	`76`	`}`
`77`	`77`
`78`		`-}; //bin2cpp`
	`78`	`+}; //cmdline`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`	`#include <stdarg.h>`
`7`	`7`	`#include <shlobj.h>`
`8`	`8`
`9`		`-namespace bin2cpp`
	`9`	`+namespace logger`
`10`	`10`	`{`
`11`	`11`	`bool gQuietMode = false;`
`12`	`12`
`@@ -52,4 +52,4 @@ namespace bin2cpp`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`55`		`-}; //bin2cpp`
	`55`	`+}; //logger`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ int main(int argc, char* argv[])`
`117`	`117`	`{`
`118`	`118`	`//help`
`119`	`119`	`std::string dummy;`
`120`		`- if (bin2cpp::parseArgument("help", dummy, argc, argv))`
	`120`	`+ if (cmdline::parseArgument("help", dummy, argc, argv))`
`121`	`121`	`{`
`122`	`122`	`printHeader();`
`123`	`123`	`printUsage();`
`@@ -126,14 +126,14 @@ int main(int argc, char* argv[])`
`126`	`126`
`127`	`127`	`//noheader`
`128`	`128`	`bool noheader = false;`
`129`		`- if (bin2cpp::parseArgument("noheader", dummy, argc, argv))`
	`129`	`+ if (cmdline::parseArgument("noheader", dummy, argc, argv))`
`130`	`130`	`{`
`131`	`131`	`noheader = true;`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`//quiet`
`135`	`135`	`bool quiet = false;`
`136`		`- if (bin2cpp::parseArgument("quiet", dummy, argc, argv))`
	`136`	`+ if (cmdline::parseArgument("quiet", dummy, argc, argv))`
`137`	`137`	`{`
`138`	`138`	`quiet = true;`
`139`	`139`	`}`
`@@ -142,10 +142,10 @@ int main(int argc, char* argv[])`
`142`	`142`	`if (quiet)`
`143`	`143`	`noheader = true;`
`144`	`144`
`145`		`- bin2cpp::setQuietMode(quiet);`
	`145`	`+ logger::setQuietMode(quiet);`
`146`	`146`
`147`	`147`	`//version`
`148`		`- if (bin2cpp::parseArgument("version", dummy, argc, argv))`
	`148`	`+ if (cmdline::parseArgument("version", dummy, argc, argv))`
`149`	`149`	`{`
`150`	`150`	`if (!noheader)`
`151`	`151`	`printHeader();`
`@@ -161,34 +161,34 @@ int main(int argc, char* argv[])`
`161`	`161`	`std::string headerFilename;`
`162`	`162`	`std::string functionIdentifier;`
`163`	`163`
`164`		`- if (!bin2cpp::parseArgument("file", inputFile, argc, argv))`
	`164`	`+ if (!cmdline::parseArgument("file", inputFile, argc, argv))`
`165`	`165`	`{`
`166`	`166`	`APP_ERROR_CODES error = APP_ERROR_MISSINGARGUMENTS;`
`167`		`- bin2cpp::log(bin2cpp::LOG_ERROR, "%s (file)", getErrorCodeDescription(error));`
	`167`	`+ logger::log(logger::LOG_ERROR, "%s (file)", getErrorCodeDescription(error));`
`168`	`168`	`printUsage();`
`169`	`169`	`return error;`
`170`	`170`	`}`
`171`	`171`
`172`		`- if (!bin2cpp::parseArgument("output", outputFolder, argc, argv))`
	`172`	`+ if (!cmdline::parseArgument("output", outputFolder, argc, argv))`
`173`	`173`	`{`
`174`	`174`	`APP_ERROR_CODES error = APP_ERROR_MISSINGARGUMENTS;`
`175`		`- bin2cpp::log(bin2cpp::LOG_ERROR, "%s (output)", getErrorCodeDescription(error));`
	`175`	`+ logger::log(logger::LOG_ERROR, "%s (output)", getErrorCodeDescription(error));`
`176`	`176`	`printUsage();`
`177`	`177`	`return error;`
`178`	`178`	`}`
`179`	`179`
`180`		`- if (!bin2cpp::parseArgument("headerfile", headerFilename, argc, argv))`
	`180`	`+ if (!cmdline::parseArgument("headerfile", headerFilename, argc, argv))`
`181`	`181`	`{`
`182`	`182`	`APP_ERROR_CODES error = APP_ERROR_MISSINGARGUMENTS;`
`183`		`- bin2cpp::log(bin2cpp::LOG_ERROR, "%s (headerfile)", getErrorCodeDescription(error));`
	`183`	`+ logger::log(logger::LOG_ERROR, "%s (headerfile)", getErrorCodeDescription(error));`
`184`	`184`	`printUsage();`
`185`	`185`	`return error;`
`186`	`186`	`}`
`187`	`187`
`188`		`- if (!bin2cpp::parseArgument("identifier", functionIdentifier, argc, argv))`
	`188`	`+ if (!cmdline::parseArgument("identifier", functionIdentifier, argc, argv))`
`189`	`189`	`{`
`190`	`190`	`APP_ERROR_CODES error = APP_ERROR_MISSINGARGUMENTS;`
`191`		`- bin2cpp::log(bin2cpp::LOG_ERROR, "%s (identifier)", getErrorCodeDescription(error));`
	`191`	`+ logger::log(logger::LOG_ERROR, "%s (identifier)", getErrorCodeDescription(error));`
`192`	`192`	`printUsage();`
`193`	`193`	`return error;`
`194`	`194`	`}`
`@@ -206,27 +206,27 @@ int main(int argc, char* argv[])`
`206`	`206`	`std::string encodingStr;`
`207`	`207`
`208`	`208`	`size_t tmpChunkSize = 0;`
`209`		`- if (bin2cpp::parseArgument("chunksize", tmpChunkSize, argc, argv))`
	`209`	`+ if (cmdline::parseArgument("chunksize", tmpChunkSize, argc, argv))`
`210`	`210`	`{`
`211`	`211`	`chunkSize = tmpChunkSize;`
`212`	`212`	`}`
`213`	`213`
`214`		`- if (bin2cpp::parseArgument("override", dummy, argc, argv))`
	`214`	`+ if (cmdline::parseArgument("override", dummy, argc, argv))`
`215`	`215`	`{`
`216`	`216`	`overrideExisting = true;`
`217`	`217`	`}`
`218`	`218`
`219`		`- if (!bin2cpp::parseArgument("namespace", codeNamespace, argc, argv))`
	`219`	`+ if (!cmdline::parseArgument("namespace", codeNamespace, argc, argv))`
`220`	`220`	`{`
`221`	`221`	`codeNamespace = DEFAULT_NAMESPACE;`
`222`	`222`	`}`
`223`	`223`
`224`		`- if (!bin2cpp::parseArgument("baseclass", baseClass, argc, argv))`
	`224`	`+ if (!cmdline::parseArgument("baseclass", baseClass, argc, argv))`
`225`	`225`	`{`
`226`	`226`	`baseClass = DEFAULT_BASECLASSNAME;`
`227`	`227`	`}`
`228`	`228`
`229`		`- if (bin2cpp::parseArgument("encoding", encodingStr, argc, argv))`
	`229`	`+ if (cmdline::parseArgument("encoding", encodingStr, argc, argv))`
`230`	`230`	`{`
`231`	`231`	`if (uppercase(encodingStr) == "OCT")`
`232`	`232`	`encoding = IGenerator::CPP_ENCODER_OCT;`
`@@ -235,7 +235,7 @@ int main(int argc, char* argv[])`
`235`	`235`	`else`
`236`	`236`	`{`
`237`	`237`	`APP_ERROR_CODES error = APP_ERROR_MISSINGARGUMENTS;`
`238`		`- bin2cpp::log(bin2cpp::LOG_ERROR, "%s (encoding)", getErrorCodeDescription(error));`
	`238`	`+ logger::log(logger::LOG_ERROR, "%s (encoding)", getErrorCodeDescription(error));`
`239`	`239`	`printUsage();`
`240`	`240`	`return error;`
`241`	`241`	`}`
`@@ -252,7 +252,7 @@ int main(int argc, char* argv[])`
`252`	`252`	`bin2cpp::IGenerator * generator = NULL;`
`253`	`253`
`254`	`254`	`std::string generatorName;`
`255`		`- if (bin2cpp::parseArgument("generator", generatorName, argc, argv))`
	`255`	`+ if (cmdline::parseArgument("generator", generatorName, argc, argv))`
`256`	`256`	`{`
`257`	`257`	`if (generatorName == "segment")`
`258`	`258`	`{`
`@@ -271,7 +271,7 @@ int main(int argc, char* argv[])`
`271`	`271`	`if (generator == NULL)`
`272`	`272`	`{`
`273`	`273`	`APP_ERROR_CODES error = APP_ERROR_MISSINGARGUMENTS;`
`274`		`- bin2cpp::log(bin2cpp::LOG_ERROR, "%s, unknown values for 'generator' argument!", getErrorCodeDescription(error));`
	`274`	`+ logger::log(logger::LOG_ERROR, "%s, unknown values for 'generator' argument!", getErrorCodeDescription(error));`
`275`	`275`	`printUsage();`
`276`	`276`	`return error;`
`277`	`277`	`}`
`@@ -295,7 +295,7 @@ int main(int argc, char* argv[])`
`295`	`295`	`if (overrideExisting)`
`296`	`296`	`info << " overriding existing files";`
`297`	`297`	`info << "...";`
`298`		`- bin2cpp::log(bin2cpp::LOG_INFO, info.c_str());`
	`298`	`+ logger::log(logger::LOG_INFO, info.c_str());`
`299`	`299`
`300`	`300`	`//prepare output files path`
`301`	`301`	`std::string outputHeaderPath = outputFolder + "\\" + headerFilename;`
`@@ -340,7 +340,7 @@ FILE_UPDATE_MODE getFileUpdateMode(const std::string & inputFile, const std::str`
`340`	`340`	`uint64_t lastModifiedDate = getFileModifiedDate(inputFile);`
`341`	`341`	`uint64_t outputModifiedDate = getOutputFileModifiedDate(iOutputFilePath);`
`342`	`342`	`if (outputModifiedDate == 0)`
`343`		`- bin2cpp::log(bin2cpp::LOG_WARNING, "Unable to get last modified date of file \'%s\'", iOutputFilePath.c_str());`
	`343`	`+ logger::log(logger::LOG_WARNING, "Unable to get last modified date of file \'%s\'", iOutputFilePath.c_str());`
`344`	`344`	`if (lastModifiedDate == outputModifiedDate)`
`345`	`345`	`return SKIPPING;`
`346`	`346`
`@@ -353,7 +353,7 @@ bool processFile(const std::string & inputFile, const std::string & iOutputFileP`
`353`	`353`	`FILE_UPDATE_MODE mode = getFileUpdateMode(inputFile, iOutputFilePath, overrideExisting);`
`354`	`354`
`355`	`355`	`//writing message`
`356`		`- bin2cpp::log(bin2cpp::LOG_INFO, "%s file \"%s\"...", getUpdateModeText(mode), iOutputFilePath.c_str());`
	`356`	`+ logger::log(logger::LOG_INFO, "%s file \"%s\"...", getUpdateModeText(mode), iOutputFilePath.c_str());`
`357`	`357`
`358`	`358`	`if (mode == SKIPPING)`
`359`	`359`	`return true; //skipping is success`
`@@ -373,8 +373,8 @@ bool processFile(const std::string & inputFile, const std::string & iOutputFileP`
`373`	`373`	`if (!result)`
`374`	`374`	`{`
`375`	`375`	`//there was an error generating file`
`376`		`- bin2cpp::log(bin2cpp::LOG_ERROR, "%s", getErrorCodeDescription(APP_ERROR_UNABLETOCREATEOUTPUTFILES));`
`377`		`- bin2cpp::log(bin2cpp::LOG_ERROR, "Embedding failed!");`
	`376`	`+ logger::log(logger::LOG_ERROR, "%s", getErrorCodeDescription(APP_ERROR_UNABLETOCREATEOUTPUTFILES));`
	`377`	`+ logger::log(logger::LOG_ERROR, "Embedding failed!");`
`378`	`378`	`}`
`379`	`379`	`return result;`
`380`	`380`	`}`
Original file line number	Diff line number	Diff line change
`@@ -84,74 +84,74 @@ int main(int argc, char **argv)`
`84`	`84`
`85`	`85`	`//help`
`86`	`86`	`std::string tmp;`
`87`		`- if (bin2cpp::parseArgument("help", tmp, argc, argv))`
	`87`	`+ if (cmdline::parseArgument("help", tmp, argc, argv))`
`88`	`88`	`{`
`89`	`89`	`printVersion();`
`90`	`90`	`printUsage();`
`91`	`91`	`return EXIT_NO_ERROR;`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`//version`
`95`		`- if (bin2cpp::parseArgument("version", tmp, argc, argv))`
	`95`	`+ if (cmdline::parseArgument("version", tmp, argc, argv))`
`96`	`96`	`{`
`97`	`97`	`printVersion();`
`98`	`98`	`return EXIT_NO_ERROR;`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`//quiet`
`102`	`102`	`std::string tmpQuiet;`
`103`		`- if (bin2cpp::parseArgument("quiet", tmpQuiet, argc, argv))`
	`103`	`+ if (cmdline::parseArgument("quiet", tmpQuiet, argc, argv))`
`104`	`104`	`{`
`105`		`- bin2cpp::setQuietMode(true);`
	`105`	`+ logger::setQuietMode(true);`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`//file`
`109`		`- if (!bin2cpp::parseArgument("file", file, argc, argv))`
	`109`	`+ if (!cmdline::parseArgument("file", file, argc, argv))`
`110`	`110`	`{`
`111`		`- bin2cpp::log(bin2cpp::LOG_ERROR, "Missing 'file' argument!");`
	`111`	`+ logger::log(logger::LOG_ERROR, "Missing 'file' argument!");`
`112`	`112`	`printUsage();`
`113`	`113`	`return MISSING_FILE;`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`//size`
`117`	`117`	`int tmpSize = 0;`
`118`		`- if (bin2cpp::parseArgument("size", tmpSize, argc, argv))`
	`118`	`+ if (cmdline::parseArgument("size", tmpSize, argc, argv))`
`119`	`119`	`{`
`120`	`120`	`size = tmpSize;`
`121`	`121`	`if (size <= 0)`
`122`	`122`	`{`
`123`		`- bin2cpp::log(bin2cpp::LOG_ERROR, "Invalid file size!");`
	`123`	`+ logger::log(logger::LOG_ERROR, "Invalid file size!");`
`124`	`124`	`return INVALID_FILE_SIZE;`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`//seed`
`129`	`129`	`int tmpSeed = 0;`
`130`		`- if (bin2cpp::parseArgument("seed", tmpSeed, argc, argv))`
	`130`	`+ if (cmdline::parseArgument("seed", tmpSeed, argc, argv))`
`131`	`131`	`{`
`132`	`132`	`seed = tmpSeed;`
`133`	`133`	`if (seed < 0)`
`134`	`134`	`{`
`135`		`- bin2cpp::log(bin2cpp::LOG_ERROR, "Invalid seed value!");`
	`135`	`+ logger::log(logger::LOG_ERROR, "Invalid seed value!");`
`136`	`136`	`return INVALID_SEED;`
`137`	`137`	`}`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`//skip`
`141`	`141`	`int tmpSkip = 0;`
`142`		`- if (bin2cpp::parseArgument("skip", tmpSkip, argc, argv))`
	`142`	`+ if (cmdline::parseArgument("skip", tmpSkip, argc, argv))`
`143`	`143`	`{`
`144`	`144`	`skip = tmpSkip;`
`145`	`145`	`if (skip < 0)`
`146`	`146`	`{`
`147`		`- bin2cpp::log(bin2cpp::LOG_ERROR, "Invalid skip value!");`
	`147`	`+ logger::log(logger::LOG_ERROR, "Invalid skip value!");`
`148`	`148`	`return INVALID_SKIP;`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`//fill`
`153`	`153`	`std::string tmpFill;`
`154`		`- if (bin2cpp::parseArgument("fill", tmpFill, argc, argv))`
	`154`	`+ if (cmdline::parseArgument("fill", tmpFill, argc, argv))`
`155`	`155`	`{`
`156`	`156`	`if (tmpFill == "sequential" \|\|`
`157`	`157`	`tmpFill == "random" \|\|`
`@@ -162,21 +162,21 @@ int main(int argc, char **argv)`
`162`	`162`	`}`
`163`	`163`	`else`
`164`	`164`	`{`
`165`		`- bin2cpp::log(bin2cpp::LOG_ERROR, "Invalid fill parameter!");`
	`165`	`+ logger::log(logger::LOG_ERROR, "Invalid fill parameter!");`
`166`	`166`	`return INVALID_FILL_PARAMETER;`
`167`	`167`	`}`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`//building info string`
`171`	`171`	`std::string infostr;`
`172`	`172`	`infostr << "Writing " << size << " bytes" << getSizeAdditionalInfo(size) << " of " << fill << " data into \'" << file << "\'.";`
`173`		`- bin2cpp::log(bin2cpp::LOG_INFO, "%s", infostr.c_str());`
	`173`	`+ logger::log(logger::LOG_INFO, "%s", infostr.c_str());`
`174`	`174`
`175`	`175`	`//process with file generation`
`176`	`176`	`FILE * f = fopen(file.c_str(), "wb");`
`177`	`177`	`if (!f)`
`178`	`178`	`{`
`179`		`- bin2cpp::log(bin2cpp::LOG_ERROR, "Cannot create file '%s'!", file.c_str());`
	`179`	`+ logger::log(logger::LOG_ERROR, "Cannot create file '%s'!", file.c_str());`
`180`	`180`	`return 4;`
`181`	`181`	`}`
`182`	`182`