WareSrcFactory.hpp

Go to the documentation of this file.

/*
 
  This file is part of OpenFLUID software
  Copyright(c) 2007, INRA - Montpellier SupAgro
 
 
 == GNU General Public License Usage ==
 
  OpenFLUID is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  OpenFLUID is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with OpenFLUID. If not, see <http://www.gnu.org/licenses/>.
 
 
 == Other Usage ==
 
  Other Usage means a use of OpenFLUID that is inconsistent with the GPL
  license, and requires a written agreement between You and INRA.
  Licensees for Other Usage of OpenFLUID may use this file in accordance
  with the terms contained in the written agreement between You and INRA.
 
 */
 
 
/**
 @file WareSrcFactory.hpp
 @brief Header of ...
 
 @author Aline LIBRES <aline.libres@gmail.com>
 */
 
 
#ifndef __OPENFLUID_WARESDEV_WARESRCFACTORY_HPP__
#define __OPENFLUID_WARESDEV_WARESRCFACTORY_HPP__
 
 
#include <QDir>
 
#include <openfluid/dllexport.hpp>
#include <openfluid/builderext/BuilderExtensionSignature.hpp>
#include <openfluid/waresdev/WareSrcManager.hpp>
#include <openfluid/ware/SimulatorSignature.hpp>
 
 
namespace openfluid { namespace waresdev {
 
 
class OPENFLUID_API WareSrcFactory
{
  public:
 
    struct Replacements
    {
      private:
 
        QList<openfluid::builderext::ExtensionMode> BextMode_Data;
 
        QStringList BextCategory_Data;
        
        QStringList Sim2docMode_Data;
 
      public:
 
        QString ClassName;
        
        QString RootCppFilename;
        
        QString RootHppFilename;
        
        QString HppHeaderGuard;
        
        QString LinkUID;
        
        bool ParamsUiEnabled;
        
        QString ParamsUiClassname;
        
        QString ParamsUiRootCppFilename;
        
        QString ParamsUiRootHppFilename;
        
        QString ParamsUiHeaderGuard;
        
        QString ParamsUiComment;
        
        QString SignatureInfos;
        
        int Sim2docModeIndex;
        
        bool Sim2docInstall;
        
        QString SimulatorSignatureData;
        
        QString SimulatorInitCode;
        
        QString SimulatorRunCode;
        
        QString SimulatorSchedulingReturn;
        
        int BuilderExtModeIndex;
        
        int BuilderExtCategoryIndex;
        
        QString BuilderExtMenuText;
 
 
        Replacements() :
            ParamsUiEnabled(false), ParamsUiClassname("ParamsUiWidget"), ParamsUiRootCppFilename(""),
            ParamsUiRootHppFilename("ParamsUiWidget.hpp"), ParamsUiComment("//"), Sim2docModeIndex(0),
            Sim2docInstall(false), BuilderExtModeIndex(-1), BuilderExtCategoryIndex(0)
        {
          BextMode_Data << openfluid::builderext::MODE_MODAL << openfluid::builderext::MODE_MODELESS
                        << openfluid::builderext::MODE_WORKSPACE;
 
          BextCategory_Data << "openfluid::builderext::CAT_SPATIAL" << "openfluid::builderext::CAT_MODEL"
                            << "openfluid::builderext::CAT_RESULTS" << "openfluid::builderext::CAT_OTHER";
 
          Sim2docMode_Data << "ON" << "AUTO" << "OFF";
        }
 
        static QStringList getBuilderExtTypeTexts()
        {
          QStringList BextMode_Texts;
          BextMode_Texts << QObject::tr("Modal") << QObject::tr("Modeless") << QObject::tr("Workspace");
          return BextMode_Texts;
        }
 
        static QStringList getBuilderExtCategoryTexts()
        {
          QStringList BextCategory_Texts;
          BextCategory_Texts << QObject::tr("Spatial domain") << QObject::tr("Model") << QObject::tr("Results")
                             << QObject::tr("Other");
          return BextCategory_Texts;
        }
 
        static QStringList getSim2docModeTexts()
        {
          QStringList Sim2docMode_Texts;
          Sim2docMode_Texts << QObject::tr("On - sim2doc must be run manually")
                            << QObject::tr("Auto - sim2doc is automatically run")
                            << QObject::tr("Off - sim2doc is disabled");
          return Sim2docMode_Texts;
        }
 
        openfluid::builderext::ExtensionMode getBuilderExtType() const
        {
          return BextMode_Data.value(BuilderExtModeIndex, openfluid::builderext::MODE_UNKNOWN);
        }
 
        QString getBuilderExtCategory() const
        {
          return BextCategory_Data.value(BuilderExtCategoryIndex, "");
        }
 
        QString getSim2docMode() const
        {
          return Sim2docMode_Data.value(Sim2docModeIndex, "");
        }
 
        QString getParamsUiEnabled() const
        {
          return ParamsUiEnabled ? "ON" : "OFF";
        }
 
        QString getSim2docInstall() const
        {
          return Sim2docInstall ? "OFF" : "ON";
        }
 
    };
 
 
  private:
 
    QDir m_SharedTemplatesDir;
 
    QDir m_TypedTemplatesDir;
 
    QDir m_WareTypeDir;
 
    QString m_WareId;
 
    bool copyTemplateToNewFile(const QString& TemplatePath, const QString& NewFileName, QString& NewFilePath,
                               QString& ErrMsg);
 
    bool replaceInFile(const Replacements& R, const QString& NewFilePath, QString& ErrMsg);
 
  public:
 
    WareSrcFactory(openfluid::ware::WareType Type);
 
    ~WareSrcFactory();
 
    void setWareId(const QString& Id);
 
    /**
      Creates a CMakeLists file in the ware directory, from the CMakeLists file template of the ware type.
      @param NewFilePath A QString that will be filled with the absolute path of the created file
      @param ErrMsg A QString that will be filled with error messages if the file creation fails
      @return bool False if the file creation fails, true otherwise
    */
    bool createCMakeListsFile(const Replacements& R, QString& NewFilePath, QString& ErrMsg);
 
    /**
      Creates a wareshub.json file in the ware directory, from the (shared) Json file template.
      @param NewFilePath A QString that will be filled with the absolute path of the created file
      @param ErrMsg A QString that will be filled with error messages if the file creation fails
      @return bool False if the file creation fails, true otherwise
    */
    bool createJsonFile(QString& NewFilePath, QString& ErrMsg);
 
    /**
      Creates a main cpp file in the ware directory, from the source file template of the ware type,
      depending on the builder extension type (set to TYPE_UNKNOWN means it is not a Builder extension).
      @param R Replacements struct containing the replacements to perform
      @param NewFilePath A QString that will be filled with the absolute path of the created file
      @param ErrMsg A QString that will be filled with error messages if the file creation fails
      @return bool False if the file creation fails, true otherwise
    */
    bool createCppFile(const Replacements& R, QString& NewFilePath, QString& ErrMsg);
 
    /**
      Creates a main hpp file in the ware directory, from the header file template of the ware type
      depending on the builder extension type (set to TYPE_UNKNOWN means it is not a Builder extension).
      @param R Replacements struct containing the replacements to perform
      @param NewFilePath A QString that will be filled with the absolute path of the created file
      @param ErrMsg A QString that will be filled with error messages if the file creation fails
      @return bool False if the file creation fails, true otherwise
    */
    bool createHppFile(const Replacements& R, QString& NewFilePath, QString& ErrMsg);
 
    /**
      Creates a ui-parameterization cpp file in the ware directory,
      from the ui-parameterization source file template of the ware type.
      @param R Replacements struct containing the replacements to perform
      @param NewFilePath A QString that will be filled with the absolute path of the created file
      @param ErrMsg A QString that will be filled with error messages if the file creation fails
      @return bool False if the file creation fails, true otherwise
    */
    bool createParamUiCppFile(const Replacements& R, QString& NewFilePath, QString& ErrMsg);
 
    /**
      Creates a ui-parameterization hpp file in the ware directory,
      from the ui-parameterization header file template of the ware type.
      @param R Replacements struct containing the replacements to perform
      @param NewFilePath A QString that will be filled with the absolute path of the created file
      @param ErrMsg A QString that will be filled with error messages if the file creation fails
      @return bool False if the file creation fails, true otherwise
    */
    bool createParamUiHppFile(const Replacements& R, QString& NewFilePath, QString& ErrMsg);
 
    /**
      Creates a Cmake.in.config file in the ware directory, from the Cmake.in.config file template of the ware type.
      @param R Replacements struct containing the replacements to perform
      @param NewFilePath A QString that will be filled with the absolute path of the created file
      @param ErrMsg A QString that will be filled with error messages if the file creation fails
      @return bool False if the file creation fails, true otherwise
    */
    bool createCmakeConfigFile(const Replacements& R, QString& NewFilePath, QString& ErrMsg);
 
    static QRegExp getCppFilenameRegExp(QString& Tooltip, bool IsHpp = false);
 
    static QRegExp getClassnameRegExp(QString& Tooltip);
 
    static QRegExp getWareIdRegExp(QString& Tooltip);
 
    static QString getHeaderGuard(const QString& HppFilename);
 
    static QString getHppFilename(const QString& CppFilename);
 
    static QString getSimulatorSignatureInfos(const openfluid::ware::SimulatorSignature& Signature);
 
    static QString getSimulatorSignatureData(const openfluid::ware::SimulatorSignature& Signature);
 
    static QString getSimulatorInitCode(const openfluid::ware::SimulatorSignature& Signature);
 
    static QString getSimulatorRunCode(const openfluid::ware::SimulatorSignature& Signature);
 
    static QString getSimulatorSchedulingReturn(const openfluid::ware::SimulatorSignature& Signature);
 
};
 
 
} }  // namespaces
 
 
#endif /* __OPENFLUID_WARESDEV_WARESRCFACTORY_HPP__ */