CMake/Source/CPack/cmCPackGeneratorFactory.cxx

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing for details.  */
#include "cmCPackGeneratorFactory.h"

#include <ostream>
#include <utility>

#include "IFW/cmCPackIFWGenerator.h"
#include "cmAlgorithms.h"
#include "cmCPack7zGenerator.h"
#ifdef HAVE_FREEBSD_PKG
#  include "cmCPackFreeBSDGenerator.h"
#endif
#include "cmCPackDebGenerator.h"
#include "cmCPackExternalGenerator.h"
#include "cmCPackGenerator.h"
#include "cmCPackLog.h"
#include "cmCPackNSISGenerator.h"
#include "cmCPackNuGetGenerator.h"
#include "cmCPackSTGZGenerator.h"
#include "cmCPackTGZGenerator.h"
#include "cmCPackTXZGenerator.h"
#include "cmCPackTarBZip2Generator.h"
#include "cmCPackTarCompressGenerator.h"
#include "cmCPackZIPGenerator.h"

#ifdef __APPLE__
#  include "cmCPackBundleGenerator.h"
#  include "cmCPackDragNDropGenerator.h"
#  include "cmCPackOSXX11Generator.h"
#  include "cmCPackPackageMakerGenerator.h"
#  include "cmCPackProductBuildGenerator.h"
#endif

#ifdef __CYGWIN__
#  include "cmCPackCygwinBinaryGenerator.h"
#  include "cmCPackCygwinSourceGenerator.h"
#endif

#if !defined(_WIN32) && !defined(__QNXNTO__) && !defined(__BEOS__) &&         \
  !defined(__HAIKU__)
#  include "cmCPackRPMGenerator.h"
#endif

#if defined(_WIN32) || (defined(__CYGWIN__) && defined(HAVE_LIBUUID))
#  include "WiX/cmCPackWIXGenerator.h"
#endif

cmCPackGeneratorFactory::cmCPackGeneratorFactory()
{
  if (cmCPackTGZGenerator::CanGenerate()) {
    this->RegisterGenerator("TGZ", "Tar GZip compression",
                            cmCPackTGZGenerator::CreateGenerator);
  }
  if (cmCPackTXZGenerator::CanGenerate()) {
    this->RegisterGenerator("TXZ", "Tar XZ compression",
                            cmCPackTXZGenerator::CreateGenerator);
  }
  if (cmCPackSTGZGenerator::CanGenerate()) {
    this->RegisterGenerator("STGZ", "Self extracting Tar GZip compression",
                            cmCPackSTGZGenerator::CreateGenerator);
  }
  if (cmCPackNSISGenerator::CanGenerate()) {
    this->RegisterGenerator("NSIS", "Null Soft Installer",
                            cmCPackNSISGenerator::CreateGenerator);
    this->RegisterGenerator("NSIS64", "Null Soft Installer (64-bit)",
                            cmCPackNSISGenerator::CreateGenerator64);
  }
  if (cmCPackIFWGenerator::CanGenerate()) {
    this->RegisterGenerator("IFW", "Qt Installer Framework",
                            cmCPackIFWGenerator::CreateGenerator);
  }
#ifdef __CYGWIN__
  if (cmCPackCygwinBinaryGenerator::CanGenerate()) {
    this->RegisterGenerator("CygwinBinary", "Cygwin Binary Installer",
                            cmCPackCygwinBinaryGenerator::CreateGenerator);
  }
  if (cmCPackCygwinSourceGenerator::CanGenerate()) {
    this->RegisterGenerator("CygwinSource", "Cygwin Source Installer",
                            cmCPackCygwinSourceGenerator::CreateGenerator);
  }
#endif

  if (cmCPackZIPGenerator::CanGenerate()) {
    this->RegisterGenerator("ZIP", "ZIP file format",
                            cmCPackZIPGenerator::CreateGenerator);
  }
  if (cmCPack7zGenerator::CanGenerate()) {
    this->RegisterGenerator("7Z", "7-Zip file format",
                            cmCPack7zGenerator::CreateGenerator);
  }
#if defined(_WIN32) || (defined(__CYGWIN__) && defined(HAVE_LIBUUID))
  if (cmCPackWIXGenerator::CanGenerate()) {
    this->RegisterGenerator("WIX", "MSI file format via WiX tools",
                            cmCPackWIXGenerator::CreateGenerator);
  }
#endif
  if (cmCPackTarBZip2Generator::CanGenerate()) {
    this->RegisterGenerator("TBZ2", "Tar BZip2 compression",
                            cmCPackTarBZip2Generator::CreateGenerator);
  }
  if (cmCPackTarCompressGenerator::CanGenerate()) {
    this->RegisterGenerator("TZ", "Tar Compress compression",
                            cmCPackTarCompressGenerator::CreateGenerator);
  }
  if (cmCPackDebGenerator::CanGenerate()) {
    this->RegisterGenerator("DEB", "Debian packages",
                            cmCPackDebGenerator::CreateGenerator);
  }
  if (cmCPackNuGetGenerator::CanGenerate()) {
    this->RegisterGenerator("NuGet", "NuGet packages",
                            cmCPackNuGetGenerator::CreateGenerator);
  }
  if (cmCPackExternalGenerator::CanGenerate()) {
    this->RegisterGenerator("External", "CPack External packages",
                            cmCPackExternalGenerator::CreateGenerator);
  }
#ifdef __APPLE__
  if (cmCPackDragNDropGenerator::CanGenerate()) {
    this->RegisterGenerator("DragNDrop", "Mac OSX Drag And Drop",
                            cmCPackDragNDropGenerator::CreateGenerator);
  }
  if (cmCPackBundleGenerator::CanGenerate()) {
    this->RegisterGenerator("Bundle", "Mac OSX bundle",
                            cmCPackBundleGenerator::CreateGenerator);
  }
  if (cmCPackPackageMakerGenerator::CanGenerate()) {
    this->RegisterGenerator("PackageMaker", "Mac OSX Package Maker installer",
                            cmCPackPackageMakerGenerator::CreateGenerator);
  }
  if (cmCPackOSXX11Generator::CanGenerate()) {
    this->RegisterGenerator("OSXX11", "Mac OSX X11 bundle",
                            cmCPackOSXX11Generator::CreateGenerator);
  }
  if (cmCPackProductBuildGenerator::CanGenerate()) {
    this->RegisterGenerator("productbuild", "Mac OSX pkg",
                            cmCPackProductBuildGenerator::CreateGenerator);
  }
#endif
#if !defined(_WIN32) && !defined(__QNXNTO__) && !defined(__BEOS__) &&         \
  !defined(__HAIKU__)
  if (cmCPackRPMGenerator::CanGenerate()) {
    this->RegisterGenerator("RPM", "RPM packages",
                            cmCPackRPMGenerator::CreateGenerator);
  }
#endif
#ifdef HAVE_FREEBSD_PKG
  if (cmCPackFreeBSDGenerator::CanGenerate()) {
    this->RegisterGenerator("FREEBSD", "FreeBSD pkg(8) packages",
                            cmCPackFreeBSDGenerator::CreateGenerator);
  }
#endif
}

cmCPackGeneratorFactory::~cmCPackGeneratorFactory()
{
  cmDeleteAll(this->Generators);
}

cmCPackGenerator* cmCPackGeneratorFactory::NewGenerator(
  const std::string& name)
{
  cmCPackGenerator* gen = this->NewGeneratorInternal(name);
  if (!gen) {
    return nullptr;
  }
  this->Generators.push_back(gen);
  gen->SetLogger(this->Logger);
  return gen;
}

cmCPackGenerator* cmCPackGeneratorFactory::NewGeneratorInternal(
  const std::string& name)
{
  cmCPackGeneratorFactory::t_GeneratorCreatorsMap::iterator it =
    this->GeneratorCreators.find(name);
  if (it == this->GeneratorCreators.end()) {
    return nullptr;
  }
  return (it->second)();
}

void cmCPackGeneratorFactory::RegisterGenerator(
  const std::string& name, const char* generatorDescription,
  CreateGeneratorCall* createGenerator)
{
  if (!createGenerator) {
    cmCPack_Log(this->Logger, cmCPackLog::LOG_ERROR,
                "Cannot register generator" << std::endl);
    return;
  }
  this->GeneratorCreators[name] = createGenerator;
  this->GeneratorDescriptions[name] = generatorDescription;
}