| /* Distributed under the OSI-approved BSD 3-Clause License. See accompanying |
| file Copyright.txt or https://cmake.org/licensing for details. */ |
| #ifndef cmCPackGenerator_h |
| #define cmCPackGenerator_h |
| |
| #include <cmConfigure.h> |
| |
| #include "cmCPackComponentGroup.h" |
| #include "cmObject.h" |
| #include "cmSystemTools.h" |
| #include "cmTypeMacro.h" |
| |
| #include <map> |
| #include <sstream> |
| #include <string> |
| #include <vector> |
| |
| class cmCPackLog; |
| class cmInstalledFile; |
| class cmMakefile; |
| |
| #define cmCPackTypeMacro(klass, superclass) \ |
| cmTypeMacro(klass, superclass); \ |
| static cmCPackGenerator* CreateGenerator() { return new klass; } \ |
| class cmCPackTypeMacro_UseTrailingSemicolon |
| |
| #define cmCPackLogger(logType, msg) \ |
| do { \ |
| std::ostringstream cmCPackLog_msg; \ |
| cmCPackLog_msg << msg; \ |
| this->Logger->Log(logType, __FILE__, __LINE__, \ |
| cmCPackLog_msg.str().c_str()); \ |
| } while (0) |
| |
| #ifdef cerr |
| #undef cerr |
| #endif |
| #define cerr no_cerr_use_cmCPack_Log |
| |
| #ifdef cout |
| #undef cout |
| #endif |
| #define cout no_cout_use_cmCPack_Log |
| |
| /** \class cmCPackGenerator |
| * \brief A superclass of all CPack Generators |
| * |
| */ |
| class cmCPackGenerator : public cmObject |
| { |
| public: |
| cmTypeMacro(cmCPackGenerator, cmObject); |
| /** |
| * If verbose then more information is printed out |
| */ |
| void SetVerbose(bool val) |
| { |
| this->GeneratorVerbose = |
| val ? cmSystemTools::OUTPUT_MERGE : cmSystemTools::OUTPUT_NONE; |
| } |
| |
| /** |
| * Returns true if the generator may work on this system. |
| * Rational: |
| * Some CPack generator may run on some host and may not on others |
| * (with the same system) because some tools are missing. If the tool |
| * is missing then CPack won't activate (in the CPackGeneratorFactory) |
| * this particular generator. |
| */ |
| static bool CanGenerate() { return true; } |
| |
| /** |
| * Do the actual whole package processing. |
| * Subclass may redefine it but its usually enough |
| * to redefine @ref PackageFiles, because in fact |
| * this method do call: |
| * - PrepareName |
| * - clean-up temp dirs |
| * - InstallProject (with the appropriate method) |
| * - prepare list of files and/or components to be package |
| * - PackageFiles |
| * - Copy produced packages at the expected place |
| * @return 0 if error. |
| */ |
| virtual int DoPackage(); |
| |
| /** |
| * Initialize generator |
| */ |
| int Initialize(const std::string& name, cmMakefile* mf); |
| |
| /** |
| * Construct generator |
| */ |
| cmCPackGenerator(); |
| ~cmCPackGenerator() CM_OVERRIDE; |
| |
| //! Set and get the options |
| void SetOption(const std::string& op, const char* value); |
| void SetOptionIfNotSet(const std::string& op, const char* value); |
| const char* GetOption(const std::string& op) const; |
| std::vector<std::string> GetOptions() const; |
| bool IsSet(const std::string& name) const; |
| bool IsOn(const std::string& name) const; |
| |
| //! Set the logger |
| void SetLogger(cmCPackLog* log) { this->Logger = log; } |
| |
| //! Display verbose information via logger |
| void DisplayVerboseOutput(const char* msg, float progress); |
| |
| bool ReadListFile(const char* moduleName); |
| |
| protected: |
| /** |
| * Prepare common used names by inspecting |
| * several CPACK_xxx var values. |
| */ |
| int PrepareNames(); |
| |
| /** |
| * Install the project using appropriate method. |
| */ |
| int InstallProject(); |
| |
| int CleanTemporaryDirectory(); |
| |
| cmInstalledFile const* GetInstalledFile(std::string const& name) const; |
| |
| virtual const char* GetOutputExtension() { return ".cpack"; } |
| virtual const char* GetOutputPostfix() { return CM_NULLPTR; } |
| |
| /** |
| * Prepare requested grouping kind from CPACK_xxx vars |
| * CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE |
| * CPACK_COMPONENTS_IGNORE_GROUPS |
| * or |
| * CPACK_COMPONENTS_ONE_PACKAGE_PER_GROUP |
| * @return 1 on success 0 on failure. |
| */ |
| virtual int PrepareGroupingKind(); |
| |
| /** |
| * Some CPack generators may prefer to have |
| * CPack install all components belonging to the same |
| * [component] group to be install in the same directory. |
| * The default behavior is to install each component in |
| * a separate directory. |
| * @param[in] componentName the name of the component to be installed |
| * @return the name suffix the generator wants for the specified component |
| * default is "componentName" |
| */ |
| virtual std::string GetComponentInstallDirNameSuffix( |
| const std::string& componentName); |
| |
| /** |
| * CPack specific generator may mangle CPACK_PACKAGE_FILE_NAME |
| * with CPACK_COMPONENT_xxxx_<NAME>_DISPLAY_NAME if |
| * CPACK_<GEN>_USE_DISPLAY_NAME_IN_FILENAME is ON. |
| * @param[in] initialPackageFileName the initial package name to be mangled |
| * @param[in] groupOrComponentName the name of the group/component |
| * @param[in] isGroupName true if previous name refers to a group, |
| * false otherwise |
| */ |
| virtual std::string GetComponentPackageFileName( |
| const std::string& initialPackageFileName, |
| const std::string& groupOrComponentName, bool isGroupName); |
| |
| /** |
| * Package the list of files and/or components which |
| * has been prepared by the beginning of DoPackage. |
| * @pre the @ref toplevel has been filled-in |
| * @pre the list of file @ref files has been populated |
| * @pre packageFileNames contains at least 1 entry |
| * @post packageFileNames may have been updated and contains |
| * the list of packages generated by the specific generator. |
| */ |
| virtual int PackageFiles(); |
| virtual const char* GetInstallPath(); |
| virtual const char* GetPackagingInstallPrefix(); |
| |
| virtual std::string FindTemplate(const char* name); |
| virtual bool ConfigureFile(const char* inName, const char* outName, |
| bool copyOnly = false); |
| virtual bool ConfigureString(const std::string& input, std::string& output); |
| virtual int InitializeInternal(); |
| |
| //! Run install commands if specified |
| virtual int InstallProjectViaInstallCommands( |
| bool setDestDir, const std::string& tempInstallDirectory); |
| virtual int InstallProjectViaInstallScript( |
| bool setDestDir, const std::string& tempInstallDirectory); |
| virtual int InstallProjectViaInstalledDirectories( |
| bool setDestDir, const std::string& tempInstallDirectory); |
| virtual int InstallProjectViaInstallCMakeProjects( |
| bool setDestDir, const std::string& tempInstallDirectory); |
| |
| /** |
| * The various level of support of |
| * CPACK_SET_DESTDIR used by the generator. |
| */ |
| enum CPackSetDestdirSupport |
| { |
| /* the generator works with or without it */ |
| SETDESTDIR_SUPPORTED, |
| /* the generator works best if automatically handled */ |
| SETDESTDIR_INTERNALLY_SUPPORTED, |
| /* no official support, use at your own risk */ |
| SETDESTDIR_SHOULD_NOT_BE_USED, |
| /* officially NOT supported */ |
| SETDESTDIR_UNSUPPORTED |
| }; |
| |
| /** |
| * Does the CPack generator support CPACK_SET_DESTDIR? |
| * The default legacy value is 'SETDESTDIR_SUPPORTED' generator |
| * have to override it in order change this. |
| * @return CPackSetDestdirSupport |
| */ |
| virtual enum CPackSetDestdirSupport SupportsSetDestdir() const; |
| |
| /** |
| * Does the CPack generator support absolute path |
| * in INSTALL DESTINATION? |
| * The default legacy value is 'true' generator |
| * have to override it in order change this. |
| * @return true if supported false otherwise |
| */ |
| virtual bool SupportsAbsoluteDestination() const; |
| |
| /** |
| * Does the CPack generator support component installation?. |
| * Some Generators requires the user to set |
| * CPACK_<GENNAME>_COMPONENT_INSTALL in order to make this |
| * method return true. |
| * @return true if supported, false otherwise |
| */ |
| virtual bool SupportsComponentInstallation() const; |
| /** |
| * Does the currently running generator want a component installation. |
| * The generator may support component installation but he may |
| * be requiring monolithic install using CPACK_MONOLITHIC_INSTALL. |
| * @return true if component installation is supported and wanted. |
| */ |
| virtual bool WantsComponentInstallation() const; |
| virtual cmCPackInstallationType* GetInstallationType( |
| const std::string& projectName, const std::string& name); |
| virtual cmCPackComponent* GetComponent(const std::string& projectName, |
| const std::string& name); |
| virtual cmCPackComponentGroup* GetComponentGroup( |
| const std::string& projectName, const std::string& name); |
| |
| cmSystemTools::OutputOption GeneratorVerbose; |
| std::string Name; |
| |
| std::string InstallPath; |
| |
| /** |
| * The list of package file names. |
| * At beginning of DoPackage the (generic) generator will populate |
| * the list of desired package file names then it will |
| * call the redefined method PackageFiles which is may |
| * either use this set of names (usually on entry there should be |
| * only a single name) or update the vector with the list |
| * of created package file names. |
| */ |
| std::vector<std::string> packageFileNames; |
| |
| /** |
| * The directory where all the files to be packaged reside. |
| * If the installer support components there will be one |
| * sub-directory for each component. In those directories |
| * one will find the file belonging to the specified component. |
| */ |
| std::string toplevel; |
| |
| /** |
| * The complete list of files to be packaged. |
| * This list will be populated by DoPackage before |
| * PackageFiles is called. |
| */ |
| std::vector<std::string> files; |
| |
| std::map<std::string, cmCPackInstallationType> InstallationTypes; |
| /** |
| * The set of components. |
| * If component installation is supported then this map |
| * contains the component specified in CPACK_COMPONENTS_ALL |
| */ |
| std::map<std::string, cmCPackComponent> Components; |
| std::map<std::string, cmCPackComponentGroup> ComponentGroups; |
| |
| /** |
| * If components are enabled, this enum represents the different |
| * ways of mapping components to package files. |
| */ |
| enum ComponentPackageMethod |
| { |
| /* one package for all components */ |
| ONE_PACKAGE, |
| /* one package for each component */ |
| ONE_PACKAGE_PER_COMPONENT, |
| /* one package for each group, |
| * with left over components in their own package */ |
| ONE_PACKAGE_PER_GROUP, |
| UNKNOWN_COMPONENT_PACKAGE_METHOD |
| }; |
| |
| /** |
| * The component package method |
| * The default is ONE_PACKAGE_PER_GROUP, |
| * and generators may override the default |
| * before PrepareGroupingKind() is called. |
| */ |
| ComponentPackageMethod componentPackageMethod; |
| |
| cmCPackLog* Logger; |
| |
| private: |
| cmMakefile* MakefileMap; |
| }; |
| |
| #endif |