Source/cmInstallRuntimeDependencySet.h

   1 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   2    file Copyright.txt or https://cmake.org/licensing for details.  */
   3 #pragma once
   4
   5 #include <map>
   6 #include <set>
   7 #include <string>
   8 #include <vector>
   9
  10 #include <cm/memory>
  11 #include <cm/string_view>
  12 #include <cmext/string_view>
  13
  14 class cmGeneratorTarget;
  15 class cmInstallImportedRuntimeArtifactsGenerator;
  16 class cmInstallTargetGenerator;
  17
  18 class cmInstallRuntimeDependencySet
  19 {
  20 public:
  21   cmInstallRuntimeDependencySet(std::string name = "");
  22
  23   cmInstallRuntimeDependencySet(const cmInstallRuntimeDependencySet&) = delete;
  24   cmInstallRuntimeDependencySet& operator=(
  25     const cmInstallRuntimeDependencySet&) = delete;
  26
  27   cm::string_view GetName() const { return this->Name; }
  28
  29   cm::string_view GetDisplayName() const
  30   {
  31     if (this->Name.empty()) {
  32       return "<anonymous>"_s;
  33     }
  34     return this->Name;
  35   }
  36
  37   class Item
  38   {
  39   public:
  40     virtual ~Item() = default;
  41
  42     virtual std::string GetItemPath(const std::string& config) const = 0;
  43
  44     virtual void AddPostExcludeFiles(
  45       const std::string& /*config*/, std::set<std::string>& /*files*/,
  46       cmInstallRuntimeDependencySet* /*set*/) const
  47     {
  48     }
  49   };
  50
  51   class TargetItem : public Item
  52   {
  53   public:
  54     TargetItem(cmInstallTargetGenerator* target)
  55       : Target(target)
  56     {
  57     }
  58
  59     std::string GetItemPath(const std::string& config) const override;
  60
  61     void AddPostExcludeFiles(
  62       const std::string& config, std::set<std::string>& files,
  63       cmInstallRuntimeDependencySet* set) const override;
  64
  65   private:
  66     cmInstallTargetGenerator* Target;
  67   };
  68
  69   class ImportedTargetItem : public Item
  70   {
  71   public:
  72     ImportedTargetItem(cmInstallImportedRuntimeArtifactsGenerator* target)
  73       : Target(target)
  74     {
  75     }
  76
  77     std::string GetItemPath(const std::string& config) const override;
  78
  79   private:
  80     cmInstallImportedRuntimeArtifactsGenerator* Target;
  81   };
  82
  83   void AddExecutable(std::unique_ptr<Item> executable);
  84   void AddLibrary(std::unique_ptr<Item> library);
  85   void AddModule(std::unique_ptr<Item> module);
  86   bool AddBundleExecutable(std::unique_ptr<Item> bundleExecutable);
  87
  88   void AddExecutable(cmInstallTargetGenerator* executable)
  89   {
  90     this->AddExecutable(cm::make_unique<TargetItem>(executable));
  91   }
  92
  93   void AddLibrary(cmInstallTargetGenerator* library)
  94   {
  95     this->AddLibrary(cm::make_unique<TargetItem>(library));
  96   }
  97
  98   void AddModule(cmInstallTargetGenerator* module)
  99   {
 100     this->AddModule(cm::make_unique<TargetItem>(module));
 101   }
 102
 103   bool AddBundleExecutable(cmInstallTargetGenerator* bundleExecutable)
 104   {
 105     return this->AddBundleExecutable(
 106       cm::make_unique<TargetItem>(bundleExecutable));
 107   }
 108
 109   void AddExecutable(cmInstallImportedRuntimeArtifactsGenerator* executable)
 110   {
 111     this->AddExecutable(cm::make_unique<ImportedTargetItem>(executable));
 112   }
 113
 114   void AddLibrary(cmInstallImportedRuntimeArtifactsGenerator* library)
 115   {
 116     this->AddLibrary(cm::make_unique<ImportedTargetItem>(library));
 117   }
 118
 119   void AddModule(cmInstallImportedRuntimeArtifactsGenerator* module)
 120   {
 121     this->AddModule(cm::make_unique<ImportedTargetItem>(module));
 122   }
 123
 124   bool AddBundleExecutable(
 125     cmInstallImportedRuntimeArtifactsGenerator* bundleExecutable)
 126   {
 127     return this->AddBundleExecutable(
 128       cm::make_unique<ImportedTargetItem>(bundleExecutable));
 129   }
 130
 131   const std::vector<std::unique_ptr<Item>>& GetExecutables() const
 132   {
 133     return this->Executables;
 134   }
 135
 136   const std::vector<std::unique_ptr<Item>>& GetLibraries() const
 137   {
 138     return this->Libraries;
 139   }
 140
 141   const std::vector<std::unique_ptr<Item>>& GetModules() const
 142   {
 143     return this->Modules;
 144   }
 145
 146   Item* GetBundleExecutable() const { return this->BundleExecutable; }
 147
 148   bool Empty() const
 149   {
 150     return this->Executables.empty() && this->Libraries.empty() &&
 151       this->Modules.empty();
 152   }
 153
 154 private:
 155   std::string Name;
 156   std::vector<std::unique_ptr<Item>> Executables;
 157   std::vector<std::unique_ptr<Item>> Libraries;
 158   std::vector<std::unique_ptr<Item>> Modules;
 159   Item* BundleExecutable = nullptr;
 160
 161   std::map<const cmGeneratorTarget*, std::set<const cmGeneratorTarget*>>
 162     TargetDepends;
 163 };