cet::lookup_policy_selector Class Reference

#include <filepath_maker.h>

Public Member Functions
std::unique_ptr< filepath_maker >	select (std::string const &spec, std::string paths) const
std::string	help_message () const

Static Private Member Functions
static constexpr auto	none () noexcept
static constexpr auto	all () noexcept
static constexpr auto	nonabsolute () noexcept
static constexpr auto	after1 () noexcept
static constexpr auto	permissive () noexcept

Detailed Description

Definition at line 111 of file filepath_maker.h.

Member Function Documentation

static constexpr auto cet::lookup_policy_selector::after1 ( )

inlinestaticprivatenoexcept

Definition at line 134 of file filepath_maker.h.

  {
    return "after1";
  }

static constexpr auto cet::lookup_policy_selector::all ( )

inlinestaticprivatenoexcept

Definition at line 124 of file filepath_maker.h.

  {
    return "all";
  }

std::string cet::lookup_policy_selector::help_message

(

)

const

Definition at line 143 of file filepath_maker.cc.

{
  using namespace std::string_literals;
  std::map<std::string, std::vector<std::string>> policies;
  policies.emplace(none(), std::vector{"No lookup is done for any files."s});
  policies.emplace(
    all(),
    std::vector{"Lookup is performed for all files presented to the filepath-"s,
                "making object."s});
  policies.emplace(
    nonabsolute(),
    std::vector{"Lookup is performed only for files that are not absolute--"s,
                "i.e. file names not beginning with the '/' character."s});
  policies.emplace(
    after1(),
    std::vector{"No lookup for the first file, and only lookup is performed"s,
                "for all subsequent files."s});
  policies.emplace(
    permissive(),
    std::vector{
      "The first file can be an absolute path, a path relative to '.',"s,
      "or a path that can be looked up; all subsequent files must be"s,
      "looked up.  This is the policy used by the art framework; it is"s,
      "sometimes referred to as the first-absolute-or-lookup-with-dot"s,
      "policy."s});
  std::string result{"\nThe following file-lookup policies are supported:\n"};
  for (auto const& [name, description] : policies) {
    result += "\n  '";
    result += name;
    result += "'\n";
    for (auto const& line : description) {
      result += "     ";
      result += line;
      result += '\n';
    }
  }
  result += '\n';
  return result;
}

static constexpr auto cet::lookup_policy_selector::nonabsolute ( )

inlinestaticprivatenoexcept

Definition at line 129 of file filepath_maker.h.

  {
    return "nonabsolute";
  }

static constexpr auto cet::lookup_policy_selector::none ( )

inlinestaticprivatenoexcept

Definition at line 119 of file filepath_maker.h.

  {
    return "none";
  }

static constexpr auto cet::lookup_policy_selector::permissive ( )

inlinestaticprivatenoexcept

Definition at line 139 of file filepath_maker.h.

  {
    return "permissive";
  }

std::unique_ptr< filepath_maker > cet::lookup_policy_selector::select	(	std::string const &	spec,
		std::string	paths
	)		const

Definition at line 108 of file filepath_maker.cc.

{
  if (policy == none()) {
    return std::make_unique<filepath_maker>();
  }

  if (policy == all()) {
    return std::make_unique<filepath_lookup>(move(env_or_paths));
  }

  if (policy == nonabsolute()) {
    return std::make_unique<filepath_lookup_nonabsolute>(move(env_or_paths));
  }

  if (policy == after1()) {
    return std::make_unique<filepath_lookup_after1>(move(env_or_paths));
  }

  if (policy == permissive()) {
    auto search_paths = cet::getenv(env_or_paths);
    if (empty(search_paths)) {
      // 'env_or_paths' is not environment variable; assume it's a
      // list of colon-delimited paths.
      search_paths = env_or_paths;
    }
    return std::make_unique<filepath_first_absolute_or_lookup_with_dot>(
      move(search_paths));
  }

  throw cet::exception("Configuration")
    << "An unsupported file-lookup policy was selected.";
}

---

The documentation for this class was generated from the following files:

• cetlib/cetlib/filepath_maker.h
• cetlib/cetlib/filepath_maker.cc