* Fixed issue #22: Modify IGenerator interface to use setters/getters.

* Renamed BaseGenerator::getFileHeading() to getHeaderTemplate()
* Renamed BaseGenerator::getSaveMethodImplementation() to getSaveMethodTemplate()

Author: end2endzone

CHANGES

@@ -11,6 +11,7 @@ Changes for 2.0:
 * Fixed issue #19: Add NSIS as a prerequisite in README and INSTALL
 * Fixed issue #20: Modify how 'override' argument is implemented
 * Fixed issue #21: Add a reference to source code location in generated files.
+* Fixed issue #22: Modify IGenerator interface to use setters/getters.
 
 Changes for 1.4:
 

src/ArrayGenerator.cpp

@@ -22,15 +22,15 @@ namespace bin2cpp
     return "array";
   }
 
-  bool ArrayGenerator::createCppSourceFile(const char * iInputFilename, const char * iCppFilePath, const char * iFunctionIdentifier, size_t iChunkSize, const char * iNamespace, const char * iBaseClass)
+  bool ArrayGenerator::createCppSourceFile(const char * iCppFilePath)
   {
     //check if input file exists
-    FILE * input = fopen(iInputFilename, "rb");
+    FILE * input = fopen(mInputFile.c_str(), "rb");
     if (!input)
       return false;
 
     //Uppercase function identifier
-    std::string functionIdentifier = iFunctionIdentifier;
+    std::string functionIdentifier = mFunctionIdentifier;
     functionIdentifier[0] = (char)toupper(functionIdentifier[0]);
 
     //Build header and cpp file path
@@ -49,43 +49,43 @@ namespace bin2cpp
 
     //determine file properties
     long fileSize = getFileSize(input);
-    std::string filename = getFilename(iInputFilename);
+    std::string filename = getFilename(mInputFile.c_str());
 
     //Build class name
     std::string className;
     className.append(functionIdentifier.c_str());
     className.append("File");
 
     //Build function 
-    std::string getterFunctionName = getGetterFunctionName(functionIdentifier.c_str());
+    std::string getterFunctionName = getGetterFunctionName();
 
     //write cpp file heading
-    fprintf(cpp, "%s", getFileHeading(iInputFilename).c_str());
+    fprintf(cpp, "%s", getHeaderTemplate().c_str());
     fprintf(cpp, "#include \"%s\"\n", headerFilename.c_str() );
     fprintf(cpp, "#include <stdio.h> //for FILE\n");
     fprintf(cpp, "#include <string> //for memcpy\n");
-    fprintf(cpp, "namespace %s\n", iNamespace);
+    fprintf(cpp, "namespace %s\n", mNamespace.c_str());
     fprintf(cpp, "{\n");
-    fprintf(cpp, "  class %s : public virtual %s::%s\n", className.c_str(), iNamespace, iBaseClass);
+    fprintf(cpp, "  class %s : public virtual %s::%s\n", className.c_str(), mNamespace.c_str(), mBaseClass.c_str());
     fprintf(cpp, "  {\n");
     fprintf(cpp, "  public:\n");
     fprintf(cpp, "    %s() {}\n", className.c_str());
     fprintf(cpp, "    ~%s() {}\n", className.c_str());
     fprintf(cpp, "    virtual size_t getSize() const { return %d; }\n", fileSize);
-    fprintf(cpp, "    virtual const char * getFilename() const { return \"%s\"; }\n", getFilename(iInputFilename).c_str());
+    fprintf(cpp, "    virtual const char * getFilename() const { return \"%s\"; }\n", getFilename(mInputFile.c_str()).c_str());
     fprintf(cpp, "    virtual const char * getBuffer() const\n");
     fprintf(cpp, "    {\n");
     fprintf(cpp, "      static const unsigned char buffer[] = {\n");
 
     //create buffer for each chunks from input buffer
     int numLinePrinted = 0;
-    unsigned char * buffer = new unsigned char[iChunkSize];
+    unsigned char * buffer = new unsigned char[mChunkSize];
     while(!feof(input))
     {
       //read a chunk of the file
-      size_t readSize = fread(buffer, 1, iChunkSize, input);
+      size_t readSize = fread(buffer, 1, mChunkSize, input);
 
-      bool isLastChunk = !(readSize == iChunkSize);
+      bool isLastChunk = !(readSize == mChunkSize);
 
       if (readSize > 0)
       {
@@ -113,10 +113,10 @@ namespace bin2cpp
     //write cpp file footer
     fprintf(cpp, "      return (const char *)buffer;\n");
     fprintf(cpp, "    }\n");
-    fprintf(cpp, "%s", getSaveMethodImplementation().c_str());
+    fprintf(cpp, "%s", getSaveMethodTemplate().c_str());
     fprintf(cpp, "  };\n");
-    fprintf(cpp, "  const %s & %s() { static %s _instance; return _instance; }\n", iBaseClass, getterFunctionName.c_str(), className.c_str());
-    fprintf(cpp, "}; //%s\n", iNamespace);
+    fprintf(cpp, "  const %s & %s() { static %s _instance; return _instance; }\n", mBaseClass.c_str(), getterFunctionName.c_str(), className.c_str());
+    fprintf(cpp, "}; //%s\n", mNamespace.c_str());
 
     fclose(input);
     fclose(cpp);

src/ArrayGenerator.h

@@ -15,7 +15,7 @@ namespace bin2cpp
     ArrayGenerator();
     virtual ~ArrayGenerator();
     virtual const char * getName() const;
-    virtual bool createCppSourceFile(const char * iInputFilename, const char * iCppFilePath, const char * iFunctionIdentifier, size_t iChunkSize, const char * iNamespace, const char * iBaseClass);
+    virtual bool createCppSourceFile(const char * iCppFilePath);
   };
 
 }; //bin2cpp

src/BaseGenerator.cpp

@@ -16,10 +16,68 @@ namespace bin2cpp
   {
   }
 
-  std::string BaseGenerator::getGetterFunctionName(const char * iFunctionIdentifier)
+  void BaseGenerator::setInputFile(const char * iPath)
+  {
+    if (iPath)
+      mInputFile = iPath;
+  }
+
+  const char * BaseGenerator::getInputFile() const
+  {
+    return mInputFile.c_str();
+  }
+
+  void BaseGenerator::setFunctionIdentifier(const char * iFunctionIdentifier)
+  {
+    if (iFunctionIdentifier)
+      mFunctionIdentifier = iFunctionIdentifier;
+  }
+
+  const char * BaseGenerator::getFunctionIdentifier() const
+  {
+    return mFunctionIdentifier.c_str();
+  }
+
+  void BaseGenerator::setChunkSize(size_t iChunkSize)
+  {
+    mChunkSize = iChunkSize;
+  }
+
+  size_t BaseGenerator::getChunkSize() const
+  {
+    return mChunkSize;
+  }
+
+  void BaseGenerator::setNamespace(const char * iName)
+  {
+    if (iName)
+      mNamespace = iName;
+  }
+
+  const char * BaseGenerator::getNamespace() const
+  {
+    return mNamespace.c_str();
+  }
+
+  void BaseGenerator::setBaseClass(const char * iName)
+  {
+    if (iName)
+      mBaseClass = iName;
+  }
+
+  const char * BaseGenerator::getBaseClass() const
+  {
+    return mBaseClass.c_str();
+  }
+
+  //-------------------------------
+  //protected methods
+  //-------------------------------
+
+  std::string BaseGenerator::getGetterFunctionName()
   {
     //Uppercase function identifier
-    std::string functionIdentifier = iFunctionIdentifier;
+    std::string functionIdentifier = mFunctionIdentifier;
     functionIdentifier[0] = (char)toupper(functionIdentifier[0]);
 
     std::string getter;
@@ -45,10 +103,10 @@ namespace bin2cpp
     return cppPath;
   }
 
-  std::string BaseGenerator::getFileHeading(const char * iInputFilename)
+  std::string BaseGenerator::getHeaderTemplate()
   {
-    std::string filename = getFilename(iInputFilename);
-    uint64_t lastModifiedDate = getFileModifiedDate(iInputFilename);
+    std::string filename = getFilename(mInputFile.c_str());
+    uint64_t lastModifiedDate = getFileModifiedDate(mInputFile);
 
     std::string header;
     header << 
@@ -62,7 +120,7 @@ namespace bin2cpp
     return header;
   }
 
-  std::string BaseGenerator::getSaveMethodImplementation()
+  std::string BaseGenerator::getSaveMethodTemplate()
   {
     std::string output;
     output << "    virtual bool save(const char * iFilename) const\n";
@@ -78,21 +136,21 @@ namespace bin2cpp
     return output;
   }
 
-  bool BaseGenerator::createCppHeaderFile(const char * iInputFilename, const char * iHeaderFilePath, const char * iFunctionIdentifier, size_t iChunkSize, const char * iNamespace, const char * iBaseClass)
+  bool BaseGenerator::createCppHeaderFile(const char * iHeaderFilePath)
   {
     FILE * header = fopen(iHeaderFilePath, "w");
     if (!header)
       return false;
 
-    std::string headercomments = getFileHeading(iInputFilename);
+    std::string headercomments = getHeaderTemplate();
     fprintf(header, "%s", headercomments.c_str());
     fprintf(header, "#pragma once\n");
     fprintf(header, "#include <stddef.h>\n");
-    fprintf(header, "namespace %s\n", iNamespace);
+    fprintf(header, "namespace %s\n", mNamespace.c_str());
     fprintf(header, "{\n");
     fprintf(header, "  #ifndef BIN2CPP_EMBEDDEDFILE_CLASS\n");
     fprintf(header, "  #define BIN2CPP_EMBEDDEDFILE_CLASS\n");
-    fprintf(header, "  class %s\n", iBaseClass);
+    fprintf(header, "  class %s\n", mBaseClass.c_str());
     fprintf(header, "  {\n");
     fprintf(header, "  public:\n");
     fprintf(header, "    virtual size_t getSize() const = 0;\n");
@@ -101,8 +159,8 @@ namespace bin2cpp
     fprintf(header, "    virtual bool save(const char * iFilename) const = 0;\n");
     fprintf(header, "  };\n");
     fprintf(header, "  #endif\n");
-    fprintf(header, "  const %s & %s();\n", iBaseClass, getGetterFunctionName(iFunctionIdentifier).c_str());
-    fprintf(header, "}; //%s\n", iNamespace);
+    fprintf(header, "  const %s & %s();\n", mBaseClass.c_str(), getGetterFunctionName().c_str());
+    fprintf(header, "}; //%s\n", mNamespace.c_str());
 
     fclose(header);
 

src/BaseGenerator.h

@@ -14,15 +14,34 @@ namespace bin2cpp
     BaseGenerator();
     virtual ~BaseGenerator();
 
+    //IGenerator methods
+    virtual void setInputFile(const char * iPath);
+    virtual const char * getInputFile() const;
+    virtual void setFunctionIdentifier(const char * iFunctionIdentifier);
+    virtual const char * getFunctionIdentifier() const;
+    virtual void setChunkSize(size_t iChunkSize);
+    virtual size_t getChunkSize() const;
+    virtual void setNamespace(const char * iName);
+    virtual const char * getNamespace() const;
+    virtual void setBaseClass(const char * iName);
+    virtual const char * getBaseClass() const;
+
     //same header file for all generators
-    virtual bool createCppHeaderFile(const char * iInputFilename, const char * iHeaderFilePath, const char * iFunctionIdentifier, size_t iChunkSize, const char * iNamespace, const char * iBaseClass);
+    virtual bool createCppHeaderFile(const char * iHeaderFilePath);
 
   protected:
-    virtual std::string getGetterFunctionName(const char * iFunctionIdentifier);
+    virtual std::string getGetterFunctionName();
     virtual std::string getHeaderFilePath(const char * iCppFilePath);
     virtual std::string getCppFilePath(const char * iHeaderFilePath);
-    virtual std::string getFileHeading(const char * iInputFilename);
-    virtual std::string getSaveMethodImplementation();
+    virtual std::string getHeaderTemplate();
+    virtual std::string getSaveMethodTemplate();
+
+    //attributes
+    std::string mInputFile;
+    std::string mFunctionIdentifier;
+    size_t mChunkSize;
+    std::string mNamespace;
+    std::string mBaseClass;
   };
 
 }; //bin2cpp

src/IGenerator.h

@@ -15,29 +15,80 @@ namespace bin2cpp
     ///<returns>Returns the name of the generator</returns>
     virtual const char * getName() const = 0;
 
+    ///<summary>
+    ///Defines the path of the binary input file.
+    ///</summary>
+    ///<param name="iPath">The path of the input file (resource) to embeded as a C++ source code.</param>
+    virtual void setInputFile(const char * iPath) = 0;
+
+    ///<summary>
+    ///Provides the path of the binary input file.
+    ///</summary>
+    ///<returns>Returns the path of the binary input file. Returns an empty string if not defined.</returns>
+    virtual const char * getInputFile() const = 0;
+
+    ///<summary>
+    ///Defines the unique identifier name for the File class getter function.
+    ///</summary>
+    ///<param name="iFunctionIdentifier">The unique identifier name for the File class getter function.</param>
+    virtual void setFunctionIdentifier(const char * iFunctionIdentifier) = 0;
+
+    ///<summary>
+    ///Provides the unique identifier name for the File class getter function.
+    ///</summary>
+    ///<returns>Returns the unique identifier name for the File class getter function. Returns an empty string if not defined.</returns>
+    virtual const char * getFunctionIdentifier() const = 0;
+
+    ///<summary>
+    ///Defines the size in bytes of each chunk of data.
+    ///</summary>
+    ///<param name="iChunkSize">The size in bytes of each chunk of data.</param>
+    virtual void setChunkSize(size_t iChunkSize) = 0;
+
+    ///<summary>
+    ///Provides the size in bytes of each chunk of data.
+    ///</summary>
+    ///<returns>Returns the unique identifier name for the File class getter function. Returns an empty string if not defined.</returns>
+    virtual size_t getChunkSize() const = 0;
+
+    ///<summary>
+    ///Defines the namespace of the generated code.
+    ///</summary>
+    ///<param name="iName">The name of the namespace of the generated code.</param>
+    virtual void setNamespace(const char * iName) = 0;
+
+    ///<summary>
+    ///Provides the namespace of the generated code.
+    ///</summary>
+    ///<returns>Returns the name of the namespace of the generated code. Returns an empty string if not defined.</returns>
+    virtual const char * getNamespace() const = 0;
+
+    ///<summary>
+    ///Defines the base class of the generated code.
+    ///</summary>
+    ///<param name="iName">The name of the base class of the generated code.</param>
+    virtual void setBaseClass(const char * iName) = 0;
+
+    ///<summary>
+    ///Provides the base class of the generated code.
+    ///</summary>
+    ///<returns>Returns the name of the base class of the generated code. Returns an empty string if not defined.</returns>
+    virtual const char * getBaseClass() const = 0;
+
     ///<summary>
     ///Creates a header file for embedding a given file into C++ source code.
     ///</summary>
-    ///<param name="iInputFilename">The path of the input file (resource) to embeded as a C++ source code.</param>
     ///<param name="iHeaderFilePath">The path of the header file (*.h) that is used for getting access to the functions.</param>
-    ///<param name="iFunctionIdentifier">The unique identifier name for each data accessor functions.</param>
-    ///<param name="iChunkSize">The size in bytes of each chunk of data.</param>
-    ///<param name="iNamespace">The namespace of the generated source code.</param>
-    ///<param name="iBaseClass">The name of the interface for embedded files.</param>
     ///<returns>Returns true when the file was created. Returns false otherwise.</returns>
-    virtual bool createCppHeaderFile(const char * iInputFilename, const char * iHeaderFilePath, const char * iFunctionIdentifier, size_t iChunkSize, const char * iNamespace, const char * iBaseClass) = 0;
+    virtual bool createCppHeaderFile(const char * iHeaderFilePath) = 0;
 
     ///<summary>
     ///Creates a cpp source file for embedding a given file into C++ source code.
     ///</summary>
-    ///<param name="iInputFilename">The path of the input file (resource) to embeded as a C++ source code.</param>
     ///<param name="iCppFilePath">The path of the source file (*.cpp) that is used for getting access to the functions.</param>
-    ///<param name="iFunctionIdentifier">The unique identifier name for each data accessor functions.</param>
-    ///<param name="iChunkSize">The size in bytes of each chunk of data.</param>
-    ///<param name="iNamespace">The namespace of the generated source code.</param>
-    ///<param name="iBaseClass">The name of the interface for embedded files.</param>
     ///<returns>Returns true when the file was created. Returns false otherwise.</returns>
-    virtual bool createCppSourceFile(const char * iInputFilename, const char * iCppFilePath, const char * iFunctionIdentifier, size_t iChunkSize, const char * iNamespace, const char * iBaseClass) = 0;
+    virtual bool createCppSourceFile(const char * iCppFilePath) = 0;
+
   };
 
 }; //bin2cpp