cmFindPackageCommand.h 5.58 KB
Newer Older
1 2
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing for details.  */
3 4 5
#ifndef cmFindPackageCommand_h
#define cmFindPackageCommand_h

6
#include <cmConfigure.h>
7

8 9 10 11 12 13
#include <cm_kwiml.h>
#include <map>
#include <set>
#include <string>
#include <vector>

14 15
#include "cmFindCommon.h"

16 17 18
class cmCommand;
class cmExecutionStatus;
class cmSearchPath;
19 20 21 22 23 24

/** \class cmFindPackageCommand
 * \brief Load settings from an external project.
 *
 * cmFindPackageCommand
 */
25
class cmFindPackageCommand : public cmFindCommon
26 27
{
public:
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
  /*! A sorting order strategy to be applied to recovered package folders (see
   * FIND_PACKAGE_SORT_ORDER)*/
  enum /*class*/ SortOrderType
  {
    None,
    Name_order,
    Natural
  };
  /*! A sorting direction to be applied to recovered package folders (see
   * FIND_PACKAGE_SORT_DIRECTION)*/
  enum /*class*/ SortDirectionType
  {
    Asc,
    Dec
  };

  /*! sorts a given list of string based on the input sort parameters */
  static void Sort(std::vector<std::string>::iterator begin,
                   std::vector<std::string>::iterator end, SortOrderType order,
                   SortDirectionType dir);

49 50
  cmFindPackageCommand();

51 52 53
  /**
   * This is a virtual constructor for the command.
   */
54
  cmCommand* Clone() CM_OVERRIDE { return new cmFindPackageCommand; }
55 56 57 58 59

  /**
   * This is called when the command is first encountered in
   * the CMakeLists.txt file.
   */
60 61
  bool InitialPass(std::vector<std::string> const& args,
                   cmExecutionStatus& status) CM_OVERRIDE;
62

Andy Cedilnik's avatar
Andy Cedilnik committed
63 64 65
  /**
   * This determines if the command is invoked when in script mode.
   */
66
  bool IsScriptable() const CM_OVERRIDE { return true; }
Andy Cedilnik's avatar
Andy Cedilnik committed
67

68 69 70
  /**
   * The name of the command as specified in CMakeList.txt.
   */
71
  std::string GetName() const CM_OVERRIDE { return "find_package"; }
72 73

private:
74 75 76 77
  class PathLabel : public cmFindCommon::PathLabel
  {
  protected:
    PathLabel();
78

79
  public:
80 81 82 83
    PathLabel(const std::string& label)
      : cmFindCommon::PathLabel(label)
    {
    }
84 85 86 87 88 89 90 91 92
    static PathLabel UserRegistry;
    static PathLabel Builds;
    static PathLabel SystemRegistry;
  };

  // Add additional search path labels and groups not present in the
  // parent class
  void AppendSearchPathGroups();

93
  void AppendSuccessInformation();
94
  void AppendToFoundProperty(bool found);
95
  void SetModuleVariables(const std::string& components);
96
  bool FindModule(bool& found);
97
  void AddFindDefinition(const std::string& var, const char* val);
98
  void RestoreFindDefinitions();
99
  bool HandlePackageMode();
100
  bool FindConfig();
101 102 103
  bool FindPrefixedConfig();
  bool FindFrameworkConfig();
  bool FindAppBundleConfig();
104 105 106 107 108
  enum PolicyScopeRule
  {
    NoPolicyScope,
    DoPolicyScope
  };
109
  bool ReadListFile(const char* f, PolicyScopeRule psr);
110
  void StoreVersionFound();
111

112
  void ComputePrefixes();
113 114 115 116 117 118 119 120
  void FillPrefixesCMakeEnvironment();
  void FillPrefixesCMakeVariable();
  void FillPrefixesSystemEnvironment();
  void FillPrefixesUserRegistry();
  void FillPrefixesSystemRegistry();
  void FillPrefixesCMakeSystemVariable();
  void FillPrefixesUserGuess();
  void FillPrefixesUserHints();
121
  void LoadPackageRegistryDir(std::string const& dir, cmSearchPath& outPaths);
122 123
  void LoadPackageRegistryWinUser();
  void LoadPackageRegistryWinSystem();
124
  void LoadPackageRegistryWin(bool user, unsigned int view,
125
                              cmSearchPath& outPaths);
126
  bool CheckPackageRegistryEntry(const std::string& fname,
127
                                 cmSearchPath& outPaths);
128 129 130
  bool SearchDirectory(std::string const& dir);
  bool CheckDirectory(std::string const& dir);
  bool FindConfigFile(std::string const& dir, std::string& file);
131
  bool CheckVersion(std::string const& config_file);
132 133
  bool CheckVersionFile(std::string const& version_file,
                        std::string& result_version);
134 135 136 137 138 139
  bool SearchPrefix(std::string const& prefix);
  bool SearchFrameworkPrefix(std::string const& prefix_in);
  bool SearchAppBundlePrefix(std::string const& prefix_in);

  friend class cmFindPackageFileList;

140 141 142 143 144
  struct OriginalDef
  {
    bool exists;
    std::string value;
  };
145
  std::map<std::string, OriginalDef> OriginalDefs;
146

147 148 149
  std::string Name;
  std::string Variable;
  std::string Version;
150 151 152
  unsigned int VersionMajor;
  unsigned int VersionMinor;
  unsigned int VersionPatch;
153
  unsigned int VersionTweak;
154
  unsigned int VersionCount;
155
  bool VersionExact;
156 157
  std::string FileFound;
  std::string VersionFound;
158 159 160
  unsigned int VersionFoundMajor;
  unsigned int VersionFoundMinor;
  unsigned int VersionFoundPatch;
161
  unsigned int VersionFoundTweak;
162
  unsigned int VersionFoundCount;
Brad King's avatar
Brad King committed
163
  KWIML_INT_uint64_t RequiredCMakeVersion;
164 165
  bool Quiet;
  bool Required;
166
  bool UseConfigFiles;
167
  bool UseFindModules;
168
  bool NoUserRegistry;
169
  bool NoSystemRegistry;
170
  bool DebugMode;
171
  bool UseLib32Paths;
172
  bool UseLib64Paths;
Steven Newbury's avatar
Steven Newbury committed
173
  bool UseLibx32Paths;
174
  bool PolicyScope;
175
  std::string LibraryArchitecture;
176 177
  std::vector<std::string> Names;
  std::vector<std::string> Configs;
178
  std::set<std::string> IgnoredPaths;
179

180 181 182 183 184
  /*! the selected sortOrder (None by default)*/
  SortOrderType SortOrder;
  /*! the selected sortDirection (Asc by default)*/
  SortDirectionType SortDirection;

185 186 187 188
  struct ConfigFileInfo
  {
    std::string filename;
    std::string version;
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203

    bool operator<(ConfigFileInfo const& rhs) const
    {
      return this->filename < rhs.filename;
    }

    bool operator==(ConfigFileInfo const& rhs) const
    {
      return this->filename == rhs.filename;
    }

    bool operator!=(ConfigFileInfo const& rhs) const
    {
      return !(*this == rhs);
    }
204
  };
205
  std::vector<ConfigFileInfo> ConsideredConfigs;
206 207 208
};

#endif