Properly implemented issue #20:

* Now using the input file's modified date to know if the output files is outdated.
* Implemented the same logic for header and source files:
  * If file does not exists, it is written.
  * If the override flag is specified, the file is overwrite.
  * If the file exists, the application looks if the file is up to date and update the file accordingly.
  * If not, then the file is untouched (skipped).
* Note that application does not return an error anymore when the file already exist.
* The application returns a success code for all modes: write, update, overwrite & skip. The application returns an error code is the application is unable to process the selected mode.

Author: end2endzone

.gitignore

@@ -23,3 +23,7 @@
 /msvc/TestCLI.testGenerators.actual.txt
 /msvc/TestCLI.testOverride.actual.txt
 /msvc/TestCommon.testFileModifiedDate.actual.txt
+/msvc/TestCLI.testNewFiles.actual.txt
+/msvc/TestCLI.testSkipping.actual.txt
+/msvc/TestCLI.testUpdating.actual.txt
+/msvc/TestCLI.testUpdatingFile.actual.txt

src/common.cpp

@@ -18,6 +18,13 @@
 #define stat _stat
 #endif
 
+#ifdef WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
+#endif
+#include <Windows.h>
+#endif
+
 namespace bin2cpp
 {
   template <class T>
@@ -552,4 +559,25 @@ namespace bin2cpp
     return parseValueT(str, oValue);
   }
 
+  bool isCppHeaderFile(const std::string & iPath)
+  {
+    std::string extension = getFileExtention(iPath);
+    if (extension == "h" || extension == "hpp")
+      return true;
+    return false;
+  }
+
+  bool isCppSourceFile(const std::string & iPath)
+  {
+    std::string extension = getFileExtention(iPath);
+    if (extension == "cpp" || extension == "cxx")
+      return true;
+    return false;
+  }
+
+  void sleep(const size_t & iTimeMs)
+  {
+    Sleep(iTimeMs);
+  }
+
 }; //bin2cpp

src/common.h

@@ -155,13 +155,15 @@ namespace bin2cpp
 
   ///<summary>
   ///Returns the modified date of the given file.
+  ///Note that the function returns the number of seconds elapsed since epoch since Jan 1st 1970.
   ///</summary>
   ///<param name="iPath">The valid path to a file.</param>
   ///<return>Returns the modified date of the given file.<return>
   uint64_t getFileModifiedDate(const std::string & iPath);
 
   ///<summary>
   ///Returns the modified date from an embedded file's c++ header/source file.
+  ///Note that the function returns the number of seconds elapsed since epoch since Jan 1st 1970.
   ///</summary>
   ///<param name="iPath">The valid path to a c++ header/source file.</param>
   ///<return>Returns the modified date from an embedded file's c++ header/source file.<return>
@@ -210,4 +212,24 @@ namespace bin2cpp
   ///<return>Returns true when the parsing is successful.<return>
   bool parseValue(const std::string& str, uint64_t & oValue);
 
+  ///<summary>
+  ///Determine if a given path is a c++ header file.
+  ///</summary>
+  ///<param name="iPath">An valid file path.</param>
+  ///<return>Returns true if iPath is a c++ header file. Returns false otherwise.<return>
+  bool isCppHeaderFile(const std::string & iPath);
+
+  ///<summary>
+  ///Determine if a given path is a c++ source file.
+  ///</summary>
+  ///<param name="iPath">An valid file path.</param>
+  ///<return>Returns true if iPath is a c++ source file. Returns false otherwise.<return>
+  bool isCppSourceFile(const std::string & iPath);
+
+  ///<summary>
+  ///Sleep the current thread by iTimeMs milliseconds.
+  ///</summary>
+  ///<param name="iTimeMs">The number of milliseconds to sleep.</param>
+  void sleep(const size_t & iTimeMs);
+
 }; //bin2cpp

src/main.cpp

@@ -215,13 +215,10 @@ int main(int argc, char* argv[])
   //prepare output files path
   std::string outputHeaderPath = outputFolder + "\\" + headerFilename;
   std::string outputCppPath = outputFolder + "\\" + headerFilename;         bin2cpp::strReplace(outputCppPath, ".h", ".cpp");
-  std::string cppFilename = headerFilename;                                 bin2cpp::strReplace(cppFilename, ".h", ".cpp");
-  
-  bin2cpp::ErrorCodes headerResult = bin2cpp::ErrorCodes::Success;
-  bin2cpp::ErrorCodes cppResult = bin2cpp::ErrorCodes::Success;
+  std::string cppFilename = headerFilename;                                 bin2cpp::strReplace(cppFilename, ".h", ".cpp");  
 
   //process files
-  headerResult = processFile(inputFile, generator, functionIdentifier, chunkSize, overrideExisting, outputHeaderPath);
+  bin2cpp::ErrorCodes headerResult = processFile(inputFile, generator, functionIdentifier, chunkSize, overrideExisting, outputHeaderPath);
   switch(headerResult)
   {
   case bin2cpp::ErrorCodes::Success:
@@ -232,7 +229,7 @@ int main(int argc, char* argv[])
     return headerResult;
   };
 
-  cppResult = processFile(inputFile, generator, functionIdentifier, chunkSize, overrideExisting, outputCppPath);
+  bin2cpp::ErrorCodes cppResult = processFile(inputFile, generator, functionIdentifier, chunkSize, overrideExisting, outputCppPath);
   switch(cppResult)
   {
   case bin2cpp::ErrorCodes::Success:
@@ -247,77 +244,85 @@ int main(int argc, char* argv[])
   return bin2cpp::ErrorCodes::Success;
 }
 
-bin2cpp::ErrorCodes processFile(const std::string & inputFile, bin2cpp::IGenerator * generator, const std::string & functionIdentifier, const size_t & chunkSize, bool overrideExisting, const std::string & iOutputFilePath)
+enum FILE_UPDATE_MODE
 {
-  uint64_t lastModifiedDate = getFileModifiedDate(iOutputFilePath);
-  std::string filename = getFilename(iOutputFilePath.c_str());
-  std::string extension = getFileExtention(iOutputFilePath);
+  WRITING,
+  UPDATING,
+  OVERWRITING,
+  SKIPPING,
+};
 
-  bin2cpp::ErrorCodes result = bin2cpp::ErrorCodes::Success;
+FILE_UPDATE_MODE getFileUpdateMode(const std::string & inputFile, const std::string & iOutputFilePath, bool overrideExisting)
+{
+  if (!bin2cpp::fileExists(iOutputFilePath.c_str()))
+    return WRITING;
+  //at this point, we know that the file exists
 
-  if (bin2cpp::fileExists(iOutputFilePath.c_str()))
+  if (overrideExisting)
+    return OVERWRITING;
+
+  //do not modify the output file if it is not out of date
+  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());
+  if (lastModifiedDate == outputModifiedDate)
+    return SKIPPING;
+
+  //file is out of date, update it
+  return UPDATING;
+}
+
+const char * getUpdateModeText(const FILE_UPDATE_MODE & iMode)
+{
+  switch(iMode)
   {
-    uint64_t outputModifiedDate = getOutputFileModifiedDate(iOutputFilePath);
-    bool outputFileOutdated = (outputModifiedDate == 0 || lastModifiedDate > outputModifiedDate);
-    if (outputFileOutdated)
-    {
-      //should we force override flag ?
-      if (overrideExisting)
-      {
-        //no problem, user has already choosen to update the output files.
-      }
-      else
-      {
-        //force overriding output files.
-        std::string message;
-        message << "Output file \'" << filename << "\' is out of date. Forcing override flag";
-        bin2cpp::log(bin2cpp::LOG_INFO, message.c_str());
-        overrideExisting = true;
-      }
-    }
-    else if (lastModifiedDate == outputModifiedDate)
-    {
-      //output file already up to date.
-      result = bin2cpp::ErrorCodes::OutputFilesSkipped;
-    }
-    else if (!overrideExisting)
-    {
-      //fail if not overriding output file
-      bin2cpp::ErrorCodes error = bin2cpp::ErrorCodes::OutputFileAlreadyExist;
-      bin2cpp::log(bin2cpp::LOG_ERROR, "%s (%s)", getErrorCodeDescription(error), iOutputFilePath.c_str());
-      return error;
-    }
-  }
+  case WRITING:
+    return "Writing";
+  case UPDATING:
+    return "Updating";
+  case OVERWRITING:
+    return "Overwriting";
+  case SKIPPING:
+    return "Skipping";
+  default:
+    return "Unknown";
+  };
+}
+
+bin2cpp::ErrorCodes processFile(const std::string & inputFile, bin2cpp::IGenerator * generator, const std::string & functionIdentifier, const size_t & chunkSize, bool overrideExisting, const std::string & iOutputFilePath)
+{
+  FILE_UPDATE_MODE mode = getFileUpdateMode(inputFile, iOutputFilePath, overrideExisting);
+
+  //writing message
+  bin2cpp::log(bin2cpp::LOG_INFO, "%s file \"%s\"...", getUpdateModeText(mode), iOutputFilePath.c_str());
+  
+  if (mode == SKIPPING)
+    return bin2cpp::ErrorCodes::OutputFilesSkipped;
 
   //generate file
-  if (result == bin2cpp::ErrorCodes::Success)
+  bin2cpp::ErrorCodes result = bin2cpp::ErrorCodes::Success;
+  if (isCppHeaderFile(iOutputFilePath))
   {
-    bin2cpp::log(bin2cpp::LOG_INFO, "Writing file \"%s\"...", iOutputFilePath.c_str());
-    if (extension == ".h")
-    {
-      //generate header
-      result = generator->createHeaderEmbededFile(inputFile.c_str(), iOutputFilePath.c_str(), functionIdentifier.c_str());
-    }
-    else
-    {
-      //generate cpp
-      result = generator->createCppEmbeddedFile(inputFile.c_str(), iOutputFilePath.c_str(), functionIdentifier.c_str(), chunkSize);
-    }
+    //generate header
+    result = generator->createHeaderEmbededFile(inputFile.c_str(), iOutputFilePath.c_str(), functionIdentifier.c_str());
   }
-  if (result == bin2cpp::ErrorCodes::Success)
+  else
   {
-    //OK
+    //generate cpp
+    result = generator->createCppEmbeddedFile(inputFile.c_str(), iOutputFilePath.c_str(), functionIdentifier.c_str(), chunkSize);
   }
-  else if (result == bin2cpp::ErrorCodes::OutputFilesSkipped)
+  if (result == bin2cpp::ErrorCodes::Success ||
+      result == bin2cpp::ErrorCodes::OutputFilesSkipped)
   {
-    bin2cpp::log(bin2cpp::LOG_WARNING, "%s", getErrorCodeDescription(result));
+    //OK
+    return bin2cpp::ErrorCodes::Success;
   }
   else
   {
+    //there was an error generating file
     bin2cpp::log(bin2cpp::LOG_ERROR, "%s", getErrorCodeDescription(result));
     bin2cpp::log(bin2cpp::LOG_ERROR, "Embedding failed!");
     return result;
   }
-  
-  return bin2cpp::ErrorCodes::Success;
 }