cet Namespace Reference

Namespaces
	_
	detail
	sqlite

Classes
class	base_converter
class	BasicPluginFactory
struct	bit_size
	struct bit_size<U>. More...
struct	bit_size< U, true >
class	cpu_timer
class	crc32
class	CRC32Calculator
struct	default_clone
struct	default_copy
class	exempt_ptr
class	filepath_first_absolute_or_lookup_with_dot
class	filepath_lookup
class	filepath_lookup_after1
class	filepath_lookup_nonabsolute
class	filepath_maker
class	HorizontalRule
class	includer
class	LibraryManager
class	lookup_policy_selector
class	map_vector
class	map_vector_key
class	maybe_ref
class	MD5Digest
struct	MD5Result
struct	name_of
struct	name_of< bool >
struct	name_of< char >
struct	name_of< double >
struct	name_of< float >
struct	name_of< int >
struct	name_of< long >
struct	name_of< long double >
struct	name_of< long long >
struct	name_of< short >
struct	name_of< signed char >
struct	name_of< std::istream >
struct	name_of< std::nullptr_t >
struct	name_of< std::ostream >
struct	name_of< std::string >
struct	name_of< T & >
struct	name_of< T * >
struct	name_of< T const >
struct	name_of< T const volatile >
struct	name_of< T volatile >
struct	name_of< T[N]>
struct	name_of< unsigned char >
struct	name_of< unsigned int >
struct	name_of< unsigned long >
struct	name_of< unsigned long long >
struct	name_of< unsigned short >
struct	name_of< void >
struct	no_delete
class	nybbler
class	ostream_handle
struct	path_tag_t
class	PluginFactory
struct	PluginTypeDeducer
struct	PluginTypeDeducer< art::EmptyEventTimestampPlugin >
struct	PluginTypeDeducer< art::FileCatalogMetadataPlugin >
struct	PluginTypeDeducer< art::ResultsProducer >
struct	PluginTypeDeducer< cettest::TestPluginBase >
struct	PluginTypeDeducer< mf::service::ELdestination >
class	propagate_const
class	registry
class	registry_via_id
class	search_path
class	sha1
class	simple_stats
class	value_ptr

Typedefs
using	no_tag = char(&)[1]
using	yes_tag = char(&)[2]
using	n = std::void_t< T >
template<typename T , typename U , typename R = void>
using	enable_if_same_t = std::enable_if_t< std::is_same_v< T, U >, R >
template<typename FT , FT f, typename R = void>
using	enable_if_function_exists_t = enable_if_same_t< FT, decltype(f), R >

Functions
std::string	bold_fontify (std::string const &s)
bool	canonical_number (std::string const &value, std::string &result)
std::string	escape (std::string const &str)
std::string	unescape (std::string const &str)
bool	is_single_quoted_string (std::string const &str)
bool	is_double_quoted_string (std::string const &str)
bool	is_quoted_string (std::string const &str)
bool	canonical_string (std::string const &str, std::string &result)
std::string	canonical_string (std::string const &str)
std::string::size_type	column_width (std::vector< std::string > const &)
template<class FwdCont , class Func >
auto	for_all (FwdCont &, Func)
template<class FwdCont , class Func >
auto	for_all (FwdCont const &, Func)
template<class FwdCont , class FwdIter >
auto	copy_all (FwdCont &, FwdIter)
template<class FwdCont , class FwdIter >
auto	copy_all (FwdCont const &, FwdIter)
template<class FwdCont , class FwdIter , class Pred >
auto	copy_if_all (FwdCont &, FwdIter, Pred)
template<class FwdCont , class FwdIter , class Pred >
auto	copy_if_all (FwdCont const &, FwdIter, Pred)
template<class FwdCont , class Datum >
auto	find_in_all (FwdCont &, Datum const &)
template<class FwdCont , class Datum >
auto	find_in_all (FwdCont const &, Datum const &)
template<class FwdCont , class Datum >
bool	search_all (FwdCont const &, Datum const &)
template<class FwdCont , class Datum >
bool	binary_search_all (FwdCont const &, Datum const &)
template<class FwdCont , class Datum >
auto	lower_bound_all (FwdCont &, Datum const &)
template<class FwdCont , class Datum >
auto	lower_bound_all (FwdCont const &, Datum const &)
template<class FwdCont , class Datum , class Pred >
auto	lower_bound_all (FwdCont &, Datum const &, Pred)
template<class FwdCont , class Datum , class Pred >
auto	lower_bound_all (FwdCont const &, Datum const &, Pred)
template<class RandCont >
void	sort_all (RandCont &)
template<class RandCont , class Pred >
void	sort_all (RandCont &, Pred)
template<class RandCont >
void	stable_sort_all (RandCont &)
template<class RandCont , class Pred >
void	stable_sort_all (RandCont &, Pred)
template<class Container , class OutputIt , class UnaryOp >
auto	transform_all (Container &, OutputIt, UnaryOp)
template<class Container , class OutputIt , class UnaryOp >
auto	transform_all (Container const &, OutputIt, UnaryOp)
template<class Container1 , class Container2 , class OutputIt , class BinaryOp >
auto	transform_all (Container1 &, Container2 &, OutputIt, BinaryOp)
template<class Container1 , class Container2 , class OutputIt , class BinaryOp >
auto	transform_all (Container1 const &, Container2 const &, OutputIt, BinaryOp)
template<class FwdCont , class Func >
void	for_all_with_index (FwdCont &, Func)
template<class FwdCont , class Func >
void	for_all_with_index (FwdCont const &, Func)
template<class E >
void	swap (exempt_ptr< E > &, exempt_ptr< E > &) noexcept
template<class E >
constexpr exempt_ptr< E >	make_exempt_ptr (E *) noexcept
template<class E >
constexpr bool	operator== (exempt_ptr< E >, exempt_ptr< E >) noexcept
template<class E >
constexpr bool	operator!= (exempt_ptr< E >, exempt_ptr< E >) noexcept
template<class E >
constexpr bool	operator== (exempt_ptr< E >, std::nullptr_t) noexcept
template<class E >
constexpr bool	operator!= (exempt_ptr< E >, std::nullptr_t) noexcept
template<class E >
constexpr bool	operator== (std::nullptr_t, exempt_ptr< E >) noexcept
template<class E >
constexpr bool	operator!= (std::nullptr_t, exempt_ptr< E >) noexcept
template<class E >
constexpr bool	operator< (exempt_ptr< E >, exempt_ptr< E >)
template<class E >
constexpr bool	operator> (exempt_ptr< E >, exempt_ptr< E >)
template<class E >
constexpr bool	operator<= (exempt_ptr< E >, exempt_ptr< E >)
template<class E >
constexpr bool	operator>= (exempt_ptr< E >, exempt_ptr< E >)
bool	file_exists (std::string const &qualified_filename)
bool	is_absolute_filepath (std::string const &qualified_filename)
bool	is_relative_filepath (std::string const &qualified_filename)
std::string	getenv (std::string const &name)
std::string	getenv (std::string const &name, std::nothrow_t)
template<typename PTR_T >
PTR_T	hard_cast (void *src)
template<typename PTR_T >
void	hard_cast (void *src, PTR_T &dest)
template<class T >
std::enable_if_t< std::is_arithmetic_v< T >, T >	hypot (T x, T y)
template<class T >
std::enable_if_t< std::is_arithmetic_v< T >, T >	unchecked_hypot (T x, T y)
template<class T >
std::enable_if_t< std::is_arithmetic_v< T >, T >	checked_hypot (T x, T y)
void	include (std::istream &in, std::string &result)
void	include (std::istream &in, std::string const &search_path_arg, std::string &result)
void	loadable_libraries (std::ostream &os, std::string const &spec, std::string const &suffix)
std::string	lpad (std::string const &pad_me, std::string::size_type wanted_size, char char_to_pad_with= ' ')
bool	operator== (map_vector_key const &, map_vector_key const &) noexcept
bool	operator!= (map_vector_key const &, map_vector_key const &) noexcept
bool	operator< (map_vector_key const &, map_vector_key const &) noexcept
bool	operator> (map_vector_key const &, map_vector_key const &) noexcept
bool	operator<= (map_vector_key const &, map_vector_key const &) noexcept
bool	operator>= (map_vector_key const &, map_vector_key const &) noexcept
std::ostream &	operator<< (std::ostream &, map_vector_key const &)
template<class T >
void	swap (maybe_ref< T > &, maybe_ref< T > &)
template<class T >
bool	operator== (maybe_ref< T > const &left, maybe_ref< T > const &right)
template<class T >
std::ostream &	operator<< (std::ostream &os, maybe_ref< T > const &item)
void	set_to_default (MD5Result &val)
bool	operator== (MD5Result const &a, MD5Result const &b)
bool	operator< (MD5Result const &a, MD5Result const &b)
bool	operator!= (MD5Result const &a, MD5Result const &b)
std::ostream &	operator<< (std::ostream &os, MD5Result const &r)
constexpr char const *	os_libpath ()
ostream_handle	select_stream (std::string const &filename, std::ostream &default_os)
boost::program_options::variables_map	parsed_program_options (int argc, char **argv, boost::program_options::options_description const &desc, boost::program_options::positional_options_description const &pos={})
constexpr char const *	plugin_libpath ()
template<unsigned N, class T >
constexpr T	pow (T x)
template<class T >
constexpr T	square (T x)
template<class T >
constexpr T	cube (T x)
template<class T >
constexpr T	fourth (T x)
template<class T >
constexpr T	diff_of_squares (T x, T y)
template<class T >
constexpr T	sum_of_squares (T x, T y)
template<class T >
constexpr T	sum_of_squares (T x, T y, T z)
template<typename T >
T &	get_underlying (propagate_const< T > &)
template<typename T >
T const &	get_underlying (propagate_const< T > const &)
bool	replace_all (std::string &in, std::string const &from, std::string const &to)
	Replace all occurrences of from in string with to. More...
std::string	rpad (std::string const &pad_me, std::string::size_type wanted_size, char char_to_pad_with= ' ')
std::ostream &	operator<< (std::ostream &os, search_path const &p)
std::string	shlib_prefix ()
std::string	shlib_suffix ()
template<class charT , class traits >
std::basic_ostream< charT, traits > &	operator<< (std::basic_ostream< charT, traits > &, simple_stats const &)
template<class OutIter >
void	split (std::string const &s, char c, OutIter dest)
template<class Pred , class OutIter >
void	split_if (std::string const &s, Pred is_sep, OutIter dest)
std::vector< std::string >	split_by_regex (std::string const &str, std::regex const &reDelimSet)
std::vector< std::string >	split_by_regex (std::string const &str, std::string const &delimSet)
void	split_path (std::string const &path, std::vector< std::string > &components)
std::ostream &	boost_test_print_type (std::ostream &os, value_ptr< int > const p)
std::string &	trim_right (std::string &source, std::string const &t=" ")
std::string &	trim_left (std::string &source, std::string const &t=" ")
std::string &	trim (std::string &source, std::string const &t=" ")
std::string	trim_right_copy (std::string source, std::string const &t=" ")
std::string	trim_left_copy (std::string source, std::string const &t=" ")
std::string	trim_copy (std::string source, std::string const &t=" ")
template<class E , class C , class D >
void	swap (value_ptr< E, C, D > &, value_ptr< E, C, D > &) noexcept
template<class E , class C , class D >
bool	operator== (value_ptr< E, C, D > const &, value_ptr< E, C, D > const &)
template<class E , class C , class D >
bool	operator!= (value_ptr< E, C, D > const &, value_ptr< E, C, D > const &)
template<class E , class C , class D >
bool	operator== (value_ptr< E, C, D > const &, std::nullptr_t const &)
template<class E , class C , class D >
bool	operator!= (value_ptr< E, C, D > const &, std::nullptr_t const &)
template<class E , class C , class D >
bool	operator== (std::nullptr_t const &, value_ptr< E, C, D > const &)
template<class E , class C , class D >
bool	operator!= (std::nullptr_t const &, value_ptr< E, C, D > const &)
template<class E , class C , class D >
bool	operator< (value_ptr< E, C, D > const &, value_ptr< E, C, D > const &)
template<class E , class C , class D >
bool	operator> (value_ptr< E, C, D > const &, value_ptr< E, C, D > const &)
template<class E , class C , class D >
bool	operator<= (value_ptr< E, C, D > const &, value_ptr< E, C, D > const &)
template<class E , class C , class D >
bool	operator>= (value_ptr< E, C, D > const &, value_ptr< E, C, D > const &)

Variables
template<class U >
constexpr std::size_t	bit_size_v = bit_size<U>::value
template<typename T >
std::string const &	PluginTypeDeducer_v = PluginTypeDeducer<T>::value
path_tag_t const	path_tag

Typedef Documentation

template<typename FT , FT f, typename R = void>

using cet::enable_if_function_exists_t = typedef enable_if_same_t<FT, decltype(f), R>

Definition at line 46 of file metaprogramming.h.

template<typename T , typename U , typename R = void>

using cet::enable_if_same_t = typedef std::enable_if_t<std::is_same_v<T, U>, R>

Definition at line 43 of file metaprogramming.h.

using cet::n = typedef std::void_t<T>

Definition at line 28 of file metaprogramming.h.

using cet::no_tag = typedef char (&)[1]

Definition at line 10 of file metaprogramming.h.

using cet::yes_tag = typedef char (&)[2]

Definition at line 11 of file metaprogramming.h.

Function Documentation

template<class FwdCont , class Datum >

bool cet::binary_search_all ( FwdCont const &  s, Datum const &  d  )

inline

Definition at line 199 of file container_algorithms.h.

{
  using std::cbegin;
  using std::cend;
  return std::binary_search(cbegin(s), cend(s), d);
}

std::string cet::bold_fontify ( std::string const &  s )

inline

Definition at line 8 of file bold_fontify.h.

  {
    return "\033[1m" + s + "\033[0m";
  }

std::ostream& cet::boost_test_print_type	(	std::ostream &	os,
		value_ptr< int > const	p
	)

Definition at line 16 of file value_ptr_test.cc.

  {
    return os << p.get();
  }

bool cet::canonical_number	(	std::string const &	value,
		std::string &	result
	)

Definition at line 20 of file canonical_number.cc.

                                                                   {
  std::string::const_iterator it = value.begin();
  std::string::const_iterator const end = value.end();

  // 0x or 0X leaded hex number
  if (value.size() > 2 && value[0] == '0' && toupper(value[1]) == 'X') {
    it += 2;

    // extract the whole part
    static std::string const hexallowed("0123456789ABCDEFabcdef");
    std::string hex;
    for (; it != end && hexallowed.find(*it) != std::string::npos; ++it)
      hex.append(1, toupper(*it));

    // consumed all?
    if (it != end)
      return false;

    // convert to decimal
    std::string dec;
    try {
      dec = base_converter::hex_to_dec(hex);
    }
    catch (...) {
      return false;
    }

    // canonical form for the unsigned decimal number
    return canonical_number(dec, result);
  }

  // 0b or 0B leaded binary numbers
  if (value.size() > 2 && value[0] == '0' && toupper(value[1]) == 'B') {
    it += 2;

    // extract the whole part
    static std::string const binallowed("01");
    std::string bin;
    for (; it != end && binallowed.find(*it) != std::string::npos; ++it)
      bin.append(1, *it);

    // consumed all?
    if (it != end)
      return false;

    // convert to decimal
    std::string dec;
    try {
      dec = base_converter::bin_to_dec(bin);
    }
    catch (...) {
      return false;
    }

    // canonical form for the unsigned decimal number
    return canonical_number(dec, result);
  }

  // extract sign, if any
  std::string sign(*it == '-' ? "-" : "");
  if (*it == '+' || *it == '-')
    ++it;

  // extract optional whole part
  std::string whole;
  for (; it != end && std::isdigit(*it); ++it)
    whole.append(1, *it);

  // extract fraction part
  std::string fraction;
  if (it != end && *it == '.') {
    while (++it != end && std::isdigit(*it))
      fraction.append(1, *it);
  }

  // exponent part
  std::string exponent;
  if (it != end && (*it == 'E' || *it == 'e')) {
    if (++it == end)
      return false;
    if (*it == '+' || *it == '-') {
      exponent = *it;
      if (++it == end)
        return false;
    }
    for (; it != end && std::isdigit(*it); ++it)
      exponent.append(1, *it);
  }

  // consumed everything?
  if (it != end)
    return false;

  // require at least one digit
  std::string digits = whole + fraction;
  if (digits.empty())
    return false;
  std::size_t ndig = digits.size();

  // calculate exponent as if decimal point were at left
  long exp = std::atoi(exponent.c_str()) + whole.size();

  // discard trailing zeroes
  while (ndig > 1 && digits[ndig - 1] == '0')
    digits.erase(--ndig, 1);
  // discard leading zeroes
  for (; ndig > 1 && digits[0] == '0'; --exp, --ndig)
    digits.erase(0, 1);

  // produce result
  if (digits == "0") {
    result.append(digits);
    return true;
  }
  result.append(sign);
  if (long(ndig) <= exp && exp <= 6L) { // non-neg exp < e6?
    result.append(digits).append(exp - ndig, '0');
  } else {
    if (ndig > 1)
      digits.insert(digits.begin() + 1, '.');
    --exp;
    result.append(digits);
    if (exp != 0) {
      result.append(1, 'e').append(std::to_string(exp));
    }
  }
  return true;
}
catch (...) {
  return false;
} // canonical_number()

bool cet::canonical_string ( std::string const &  str, std::string &  result  )

inline

Definition at line 58 of file canonical_string.h.

                                                               {
  bool success = false;
  if (!s.empty()) {
    result.append(canonical_string(s));
    success = true;
  }
  return success;
}
catch (...) {
  return false;
} // canonical_string()

std::string cet::canonical_string

(

std::string const &

str

)

Definition at line 85 of file canonical_string.cc.

{
  std::string result;
  if (!s.empty()) {
    std::string value;
    if (is_double_quoted_string(s)) {
      value = cet::unescape(s.substr(1, s.size() - 2));
    } else if (is_single_quoted_string(s)) {
      value = s.substr(1, s.size() - 2);
    } else {
      value = s;
    }

    result.append(1, '"').append(cet::escape(value)).append(1, '"');
  }
  return result;
}

template<class T >

std::enable_if_t< std::is_arithmetic_v< T >, T > cet::checked_hypot	(	T	x,
		T	y
	)

Definition at line 43 of file hypot.h.

{

  if (std::isinf(x) || std::isinf(y))
    return std::numeric_limits<T>::infinity();
  else if (std::isnan(x) || std::isnan(y))
    return std::numeric_limits<T>::quiet_NaN();
  else
    return unchecked_hypot(x, y);

} // checked_hypot<>(,)

std::string::size_type cet::column_width

(

std::vector< std::string > const &

v

)

Definition at line 6 of file column_width.cc.

{
  if (v.empty())
    return 0ull;

  auto max_elem =
    std::max_element(v.begin(), v.end(), [](auto const& a, auto const& b) {
      return a.size() < b.size();
    });
  return max_elem->size();
}

template<class FwdCont , class FwdIter >

auto cet::copy_all ( FwdCont &  s, FwdIter  it  )

inline

Definition at line 132 of file container_algorithms.h.

{
  using std::begin;
  using std::end;
  return std::copy(begin(s), end(s), it);
}

template<class FwdCont , class FwdIter >

auto cet::copy_all ( FwdCont const &  s, FwdIter  it  )

inline

Definition at line 141 of file container_algorithms.h.

{
  using std::cbegin;
  using std::cend;
  return std::copy(cbegin(s), cend(s), it);
}

template<class FwdCont , class FwdIter , class Pred >

auto cet::copy_if_all ( FwdCont &  s, FwdIter  it, Pred  p  )

inline

Definition at line 151 of file container_algorithms.h.

{
  using std::cbegin;
  using std::cend;
  return std::copy_if(begin(s), end(s), it, p);
}

template<class FwdCont , class FwdIter , class Pred >

auto cet::copy_if_all ( FwdCont const &  s, FwdIter  it, Pred  p  )

inline

Definition at line 160 of file container_algorithms.h.

{
  using std::cbegin;
  using std::cend;
  return std::copy_if(cbegin(s), cend(s), it, p);
}

template<class T >

constexpr T cet::cube

(

T

x

)

Definition at line 27 of file pow.h.

  {
    return pow<3u>(x);
  }

template<class T >

constexpr T cet::diff_of_squares	(	T	x,
		T	y
	)

Definition at line 132 of file pow.h.

{
  return (x + y) * (x - y);
}

std::string cet::escape

(

std::string const &

str

)

Definition at line 16 of file canonical_string.cc.

{
  std::string result;
  for (std::string::const_iterator it = str.begin(), e = str.end(); it != e;
       ++it) {
    switch (*it) {
    case '\"':
      result.append("\\\"");
      break;
    case '\'':
      result.append("\\\'");
      break;
    case '\\':
      result.append("\\\\");
      break;
    case '\n':
      result.append("\\n");
      break;
    case '\t':
      result.append("\\t");
      break;
    default:
      if (std::isprint(*it))
        result.append(1, *it);
      else
        throw cet::exception("unprintable character");
    }
  }
  return result;
} // escape()

bool cet::file_exists

(

std::string const &

qualified_filename

)

Definition at line 14 of file filesystem.cc.

{
  struct stat file_info;
  return 0 == stat(qualified_filename.c_str(), &file_info);
}

template<class FwdCont , class Datum >

auto cet::find_in_all ( FwdCont &  s, Datum const &  d  )

inline

Definition at line 170 of file container_algorithms.h.

{
  using std::begin;
  using std::end;
  return std::find(begin(s), end(s), d);
}

template<class FwdCont , class Datum >

auto cet::find_in_all ( FwdCont const &  s, Datum const &  d  )

inline

Definition at line 179 of file container_algorithms.h.

{
  using std::cbegin;
  using std::cend;
  return std::find(cbegin(s), cend(s), d);
}

template<class FwdCont , class Func >

auto cet::for_all ( FwdCont &  s, Func  f  )

inline

Definition at line 90 of file container_algorithms.h.

{
  using std::begin;
  using std::end;
  return std::for_each(begin(s), end(s), f);
}

template<class FwdCont , class Func >

auto cet::for_all ( FwdCont const &  s, Func  f  )

inline

Definition at line 99 of file container_algorithms.h.

{
  using std::cbegin;
  using std::cend;
  return std::for_each(cbegin(s), cend(s), f);
}

template<class FwdCont , class Func >

void cet::for_all_with_index ( FwdCont &  s, Func  f  )

inline

Definition at line 109 of file container_algorithms.h.

{
  std::size_t i{};
  for (auto& e : s) {
    f(i, e);
    ++i;
  }
}

template<class FwdCont , class Func >

void cet::for_all_with_index ( FwdCont const &  s, Func  f  )

inline

Definition at line 120 of file container_algorithms.h.

{
  std::size_t i{};
  for (auto const& e : s) {
    f(i, e);
    ++i;
  }
}

template<class T >

constexpr T cet::fourth

(

T

x

)

Definition at line 33 of file pow.h.

  {
    return pow<4u>(x);
  }

template<typename T >

T & cet::get_underlying

(

propagate_const< T > &

iP

)

Definition at line 99 of file propagate_const.h.

  {
    return iP.m_value;
  }

template<typename T >

T const & cet::get_underlying

(

propagate_const< T > const &

iP

)

Definition at line 105 of file propagate_const.h.

  {
    return iP.m_value;
  }

std::string cet::getenv

(

std::string const &

name

)

Definition at line 15 of file getenv.cc.

{
  char const* p = std::getenv(name.c_str());
  if (p == nullptr) {
    throw cet::exception{"getenv"}
      << "Can't find an environment variable named \"" << name << '\"';
  }
  return p;
}

std::string cet::getenv	(	std::string const &	name,
		std::nothrow_t
	)

Definition at line 26 of file getenv.cc.

{
  char const* p = std::getenv(name.c_str());
  if (p == nullptr) {
    p = "";
  }
  return p;
}

template<typename PTR_T >

PTR_T cet::hard_cast ( void *  src )

inline

Definition at line 19 of file hard_cast.h.

{
  PTR_T dest;
  hard_cast(src, dest);
  return dest;
}

template<typename PTR_T >

void cet::hard_cast ( void *  src, PTR_T &  dest  )

inline

Definition at line 28 of file hard_cast.h.

{
  memcpy(&dest, &src, sizeof(PTR_T));
}

template<class T >

std::enable_if_t< std::is_arithmetic_v< T >, T > cet::hypot ( T  x, T  y  )

inline

Definition at line 60 of file hypot.h.

{
  return checked_hypot(x, y);
}

void cet::include	(	std::istream &	in,
		std::string &	result
	)

Definition at line 63 of file include.cc.

{
  if (!in)
    throw include_exception{cant_read};

  for (auto& line : getlines(in)) {
    if (line.find(include_lit) != 0) { // ordinary line
      result.append(line).append(1, '\n');
      continue;
    }
    trim_right(line, "\t\r");
    if (line.end()[-1] != '\"') // #include is missing trailing quote
      throw include_exception{malformed} << line;

    std::string const fname{
      line.substr(include_sz, line.size() - include_sz - 1)};
    std::ifstream f{fname.c_str(), std::ios_base::in};
    if (!f)
      throw include_exception{cant_open} << fname;
    include(f, result);
  } // for

} // include()

void cet::include	(	std::istream &	in,
		std::string const &	search_path_arg,
		std::string &	result
	)

Definition at line 90 of file include.cc.

{
  cet::search_path const paths{search_path_arg};

  if (!in)
    throw include_exception(cant_read);

  for (auto const& line : getlines(in)) {
    if (line.find(include_lit) != 0) { // ordinary line
      result.append(line).append(1, '\n');
      continue;
    }

    if (line.end()[-1] != '\"') // #include is missing its trailing quote
      throw include_exception(malformed) << line;

    std::string const fname{
      line.substr(include_sz, line.size() - include_sz - 1)};

    if (is_absolute_filepath(fname)) {
      std::ifstream f{fname.c_str(), std::ios_base::in};
      if (!f)
        throw include_exception(cant_open) << fname;
      include(f, search_path_arg, result);
    } else {
      std::ifstream f{paths.find_file(fname).c_str(), std::ios_base::in};
      if (!f) {
        throw include_exception(cant_open)
          << fname << "\nusing path: " << paths;
      }
      include(f, search_path_arg, result);
    }
  } // for

} // include()

bool cet::is_absolute_filepath

(

std::string const &

qualified_filename

)

Definition at line 23 of file filesystem.cc.

{
  return qualified_filename[0] == '/';
}

bool cet::is_double_quoted_string ( std::string const &  str )

inline

Definition at line 46 of file canonical_string.h.

{
  return detail::is_quoted_string(str, '"');
}

bool cet::is_quoted_string ( std::string const &  str )

inline

Definition at line 52 of file canonical_string.h.

{
  return is_single_quoted_string(str) || is_double_quoted_string(str);
}

bool cet::is_relative_filepath

(

std::string const &

qualified_filename

)

Definition at line 29 of file filesystem.cc.

{
  return !is_absolute_filepath(qualified_filename);
}

bool cet::is_single_quoted_string ( std::string const &  str )

inline

Definition at line 40 of file canonical_string.h.

{
  return detail::is_quoted_string(str, '\'');
}

void cet::loadable_libraries	(	std::ostream &	os,
		std::string const &	spec,
		std::string const &	suffix
	)

Definition at line 30 of file loadable_libraries.cc.

{
  cet::LibraryManager const lm{suffix, pattern(spec + ".*")};
  auto const& libs = getLibraries(lm);

  std::string str{};
  for (auto const& lib : libs) {
    auto const& libspecs = lm.getSpecsByPath(lib);
    if (libspecs.first.find(spec) == 0) {
      str += libspecs.first;
      str += '\n';
    }
    // Not all libraries have a long spec.
    if (!libspecs.second.empty() && libspecs.second.find(spec) == 0) {
      str += libspecs.second;
      str += '\n';
    }
  }
  os << str;
}

template<class FwdCont , class Datum >

auto cet::lower_bound_all ( FwdCont &  s, Datum const &  d  )

inline

Definition at line 209 of file container_algorithms.h.

{
  using std::begin;
  using std::end;
  return std::lower_bound(begin(s), end(s), d);
}

template<class FwdCont , class Datum >

auto cet::lower_bound_all ( FwdCont const &  s, Datum const &  d  )

inline

Definition at line 218 of file container_algorithms.h.

{
  using std::cbegin;
  using std::cend;
  return std::lower_bound(cbegin(s), cend(s), d);
}

template<class FwdCont , class Datum , class Pred >

auto cet::lower_bound_all ( FwdCont &  s, Datum const &  d, Pred  p  )

inline

Definition at line 227 of file container_algorithms.h.

{
  using std::begin;
  using std::end;
  return std::lower_bound(begin(s), end(s), d, p);
}

template<class FwdCont , class Datum , class Pred >

auto cet::lower_bound_all ( FwdCont const &  s, Datum const &  d, Pred  p  )

inline

Definition at line 236 of file container_algorithms.h.

{
  using std::cbegin;
  using std::cend;
  return std::lower_bound(cbegin(s), cend(s), d, p);
}

std::string cet::lpad	(	std::string const &	pad_me,
		std::string::size_type	wanted_size,
		char	char_to_pad_with = ' '
	)

Definition at line 10 of file lpad.cc.

{
  if (wanted_size <= s.size())
    return s; // already long enough

  std::string result(wanted_size - s.size(), char_to_pad_with);
  return result.append(s);

} // lpad()

template<class E >

constexpr exempt_ptr<E> cet::make_exempt_ptr ( E *  )

noexcept

bool cet::operator!= ( map_vector_key const &  k1, map_vector_key const &  k2  )

inlinenoexcept

Definition at line 309 of file map_vector.h.

{
  return k1.asInt() != k2.asInt();
}

bool cet::operator!= ( MD5Result const &  a, MD5Result const &  b  )

inline

Definition at line 44 of file MD5Digest.h.

  {
    return !(a == b);
  }

template<class E >

constexpr bool cet::operator!= ( exempt_ptr< E >  x, exempt_ptr< E >  y  )

noexcept

Definition at line 218 of file exempt_ptr.h.

{
  return !operator==(x, y);
}

template<class E >

constexpr bool cet::operator!= ( exempt_ptr< E >  x, std::nullptr_t  y  )

noexcept

Definition at line 232 of file exempt_ptr.h.

{
  return !operator==(x, y);
}

template<class E >

constexpr bool cet::operator!= ( std::nullptr_t  x, exempt_ptr< E >  y  )

noexcept

Definition at line 246 of file exempt_ptr.h.

{
  return !operator==(x, y);
}

template<class E , class C , class D >

bool cet::operator!=	(	value_ptr< E, C, D > const &	x,
		value_ptr< E, C, D > const &	y
	)

Definition at line 352 of file value_ptr.h.

{
  return !operator==(x, y);
}

template<class E , class C , class D >

bool cet::operator!=	(	value_ptr< E, C, D > const &	x,
		std::nullptr_t const &	y
	)

Definition at line 366 of file value_ptr.h.

{
  return !operator==(x, y);
}

template<class E , class C , class D >

bool cet::operator!=	(	std::nullptr_t const &	x,
		value_ptr< E, C, D > const &	y
	)

Definition at line 380 of file value_ptr.h.

{
  return !operator==(x, y);
}

bool cet::operator< ( map_vector_key const &  k1, map_vector_key const &  k2  )

inlinenoexcept

Definition at line 315 of file map_vector.h.

{
  return k1.asInt() < k2.asInt();
}

template<class E >

constexpr bool cet::operator<	(	exempt_ptr< E >	x,
		exempt_ptr< E >	y
	)

Definition at line 256 of file exempt_ptr.h.

{
  using CT = std::common_type_t<typename exempt_ptr<E>::pointer,
                                typename exempt_ptr<E>::pointer>;
  return std::less<CT>{}(x.get(), y.get());
}

bool cet::operator<	(	MD5Result const &	a,
		MD5Result const &	b
	)

Definition at line 109 of file MD5Digest.cc.

  {
    return std::lexicographical_compare(
      a.bytes, a.bytes + sizeof(a.bytes), b.bytes, b.bytes + sizeof(b.bytes));
  }

template<class E , class C , class D >

bool cet::operator<	(	value_ptr< E, C, D > const &	x,
		value_ptr< E, C, D > const &	y
	)

Definition at line 390 of file value_ptr.h.

{
  using CT = std::common_type_t<typename value_ptr<E, C, D>::pointer,
                                typename value_ptr<E, C, D>::pointer>;
  return std::less<CT>{}(x.get(), y.get());
}

std::ostream & cet::operator<< ( std::ostream &  os, cet::map_vector_key const &  key  )

inline

Definition at line 342 of file map_vector.h.

{
  return os << key.asInt();
}

ostream & cet::operator<<	(	std::ostream &	os,
		search_path const &	p
	)

Definition at line 171 of file search_path.cc.

{
  auto const sz = path.size();
  if (sz == 0)
    return os;
  os << path[0];
  for (size_t k{1}; k != sz; ++k) {
    os << ":" << path[k];
  }
  return os;
}

template<class T >

std::ostream & cet::operator<< ( std::ostream &  os, maybe_ref< T > const &  item  )

inline

Definition at line 127 of file maybe_ref.h.

{
  os << &item.ref();
  return os;
}

std::ostream& cet::operator<< ( std::ostream &  os, MD5Result const &  r  )

inline

Definition at line 50 of file MD5Digest.h.

  {
    os << r.toString();
    return os;
  }

template<class charT , class traits >

std::basic_ostream< charT, traits > & cet::operator<<	(	std::basic_ostream< charT, traits > &	os,
		simple_stats const &	stats
	)

Definition at line 95 of file simple_stats.h.

{
  return os << "( " << stats.size() << ", " << stats.mean() << " +/- "
            << stats.err_mean() << ", " << stats.rms() << " +/- "
            << stats.err_rms() << ", " << stats.min() << " " << stats.max()
            << " )";
}

bool cet::operator<= ( map_vector_key const &  k1, map_vector_key const &  k2  )

inlinenoexcept

Definition at line 327 of file map_vector.h.

{
  return k1.asInt() <= k2.asInt();
}

template<class E >

constexpr bool cet::operator<=	(	exempt_ptr< E >	x,
		exempt_ptr< E >	y
	)

Definition at line 272 of file exempt_ptr.h.

{
  return !(y < x);
}

template<class E , class C , class D >

bool cet::operator<=	(	value_ptr< E, C, D > const &	x,
		value_ptr< E, C, D > const &	y
	)

Definition at line 406 of file value_ptr.h.

{
  return !(y < x);
}

bool cet::operator== ( map_vector_key const &  k1, map_vector_key const &  k2  )

inlinenoexcept

Definition at line 303 of file map_vector.h.

{
  return k1.asInt() == k2.asInt();
}

template<class T >

bool cet::operator== ( maybe_ref< T > const &  left, maybe_ref< T > const &  right  )

inline

Definition at line 120 of file maybe_ref.h.

{
  return (&left.ref()) == (&right.ref());
}

template<class E >

constexpr bool cet::operator== ( exempt_ptr< E >  x, exempt_ptr< E >  y  )

noexcept

Definition at line 211 of file exempt_ptr.h.

{
  return x.get() == y.get();
}

template<class E >

constexpr bool cet::operator== ( exempt_ptr< E >  x, std::nullptr_t  y  )

noexcept

Definition at line 225 of file exempt_ptr.h.

{
  return x.get() == y;
}

template<class E >

constexpr bool cet::operator== ( std::nullptr_t  x, exempt_ptr< E >  y  )

noexcept

Definition at line 239 of file exempt_ptr.h.

{
  return x == y.get();
}

template<class E , class C , class D >

bool cet::operator==	(	value_ptr< E, C, D > const &	x,
		value_ptr< E, C, D > const &	y
	)

Definition at line 345 of file value_ptr.h.

{
  return x.get() == y.get();
}

template<class E , class C , class D >

bool cet::operator==	(	value_ptr< E, C, D > const &	x,
		std::nullptr_t const &	y
	)

Definition at line 359 of file value_ptr.h.

{
  return x.get() == y;
}

bool cet::operator==	(	MD5Result const &	a,
		MD5Result const &	b
	)

Definition at line 103 of file MD5Digest.cc.

  {
    return std::equal(a.bytes, a.bytes + sizeof(a.bytes), b.bytes);
  }

template<class E , class C , class D >

bool cet::operator==	(	std::nullptr_t const &	x,
		value_ptr< E, C, D > const &	y
	)

Definition at line 373 of file value_ptr.h.

{
  return x == y.get();
}

bool cet::operator> ( map_vector_key const &  k1, map_vector_key const &  k2  )

inlinenoexcept

Definition at line 321 of file map_vector.h.

{
  return k1.asInt() > k2.asInt();
}

template<class E >

constexpr bool cet::operator>	(	exempt_ptr< E >	x,
		exempt_ptr< E >	y
	)

Definition at line 265 of file exempt_ptr.h.

{
  return y < x;
}

template<class E , class C , class D >

bool cet::operator>	(	value_ptr< E, C, D > const &	x,
		value_ptr< E, C, D > const &	y
	)

Definition at line 399 of file value_ptr.h.

{
  return y < x;
}

bool cet::operator>= ( map_vector_key const &  k1, map_vector_key const &  k2  )

inlinenoexcept

Definition at line 333 of file map_vector.h.

{
  return k1.asInt() >= k2.asInt();
}

template<class E >

constexpr bool cet::operator>=	(	exempt_ptr< E >	x,
		exempt_ptr< E >	y
	)

Definition at line 279 of file exempt_ptr.h.

{
  return !(x < y);
}

template<class E , class C , class D >

bool cet::operator>=	(	value_ptr< E, C, D > const &	x,
		value_ptr< E, C, D > const &	y
	)

Definition at line 413 of file value_ptr.h.

{
  return !(x < y);
}

constexpr char const * cet::os_libpath ( )

inline

Definition at line 12 of file os_libpath.h.

{
#if __linux__
  return "LD_LIBRARY_PATH";
#elif __APPLE__ && __MACH__
  return "DYLD_LIBRARY_PATH";
#else
#error Unknown operating system
#endif
}

boost::program_options::variables_map cet::parsed_program_options	(	int	argc,
		char **	argv,
		boost::program_options::options_description const &	desc,
		boost::program_options::positional_options_description const &	pos = {}
	)

constexpr char const * cet::plugin_libpath ( )

inline

Definition at line 12 of file plugin_libpath.h.

{
  return "CET_PLUGIN_PATH";
}

template<unsigned N, class T >

constexpr T cet::pow

(

T

x

)

Definition at line 72 of file pow.h.

{
  return detail::pow<N, T>()(x);
}

bool cet::replace_all	(	std::string &	in,
		std::string const &	from,
		std::string const &	to
	)

Replace all occurrences of from in string with to.

Returns

true if anything has been done to in.

Parameters

[in,out]	in	The string to be manipulated.
[in]	from	The string to be replaced.
[in]	to	The replacement of from.

Definition at line 4 of file replace_all.cc.

{
  bool result = false;
  auto const rep_length = from.size();
  auto const skip_length = to.size();
  std::string::size_type pos = 0;
  while ((pos = in.find(from, pos)) != std::string::npos) {
    result = true;
    in.replace(pos, rep_length, to);
    pos += skip_length;
  }
  return result;
}

std::string cet::rpad	(	std::string const &	pad_me,
		std::string::size_type	wanted_size,
		char	char_to_pad_with = ' '
	)

Definition at line 10 of file rpad.cc.

{
  if (wanted_size <= s.size())
    return s; // already long enough

  std::string result(s);
  return result.append(wanted_size - s.size(), char_to_pad_with);

} // rpad()

template<class FwdCont , class Datum >

bool cet::search_all ( FwdCont const &  s, Datum const &  d  )

inline

Definition at line 189 of file container_algorithms.h.

{
  using std::cbegin;
  using std::cend;
  return std::find(cbegin(s), cend(s), d) != s.end();
}

ostream_handle cet::select_stream ( std::string const &  filename, std::ostream &  default_os  )

inline

Definition at line 89 of file ostream_handle.h.

  {
    return empty(filename) ? ostream_handle{default_os} :
                             ostream_handle{filename};
  }

void cet::set_to_default

(

MD5Result &

val

)

Definition at line 22 of file MD5Digest.cc.

  {
    val.bytes[0] = 0xd4;
    val.bytes[1] = 0x1d;
    val.bytes[2] = 0x8c;
    val.bytes[3] = 0xd9;
    val.bytes[4] = 0x8f;
    val.bytes[5] = 0x00;
    val.bytes[6] = 0xb2;
    val.bytes[7] = 0x04;
    val.bytes[8] = 0xe9;
    val.bytes[9] = 0x80;
    val.bytes[10] = 0x09;
    val.bytes[11] = 0x98;
    val.bytes[12] = 0xec;
    val.bytes[13] = 0xf8;
    val.bytes[14] = 0x42;
    val.bytes[15] = 0x7e;
  }

std::string cet::shlib_prefix

(

)

std::string cet::shlib_suffix

(

)

template<class RandCont >

void cet::sort_all ( RandCont &  s )

inline

Definition at line 246 of file container_algorithms.h.

{
  using std::begin;
  using std::end;
  std::sort(begin(s), end(s));
}

template<class RandCont , class Pred >

void cet::sort_all ( RandCont &  s, Pred  p  )

inline

Definition at line 255 of file container_algorithms.h.

{
  using std::begin;
  using std::end;
  std::sort(begin(s), end(s), p);
}

template<class OutIter >

void cet::split	(	std::string const &	s,
		char	c,
		OutIter	dest
	)

Definition at line 35 of file split.h.

{
  split_if(s, [c](char x) { return x == c; }, dest);
}

std::vector< std::string > cet::split_by_regex	(	std::string const &	str,
		std::regex const &	reDelimSet
	)

Definition at line 8 of file split_by_regex.cc.

  {
    std::vector<std::string> tokens;
    std::copy(
      std::sregex_token_iterator(str.begin(), str.end(), reDelimSet, -1),
      std::sregex_token_iterator{},
      std::back_inserter(tokens));
    return tokens;
  }

std::vector< std::string > cet::split_by_regex	(	std::string const &	str,
		std::string const &	delimSet
	)

Definition at line 19 of file split_by_regex.cc.

  {
    std::regex const tmpRegex{delimSet};
    return split_by_regex(str, tmpRegex);
  }

template<class Pred , class OutIter >

void cet::split_if	(	std::string const &	s,
		Pred	is_sep,
		OutIter	dest
	)

Definition at line 44 of file split.h.

{
  auto const e = s.cend();
  auto const is_not_sep = [is_sep](auto const c) { return !is_sep(c); };
  auto const new_boi = [is_not_sep, &e](auto const si) {
    return std::find_if(si, e, is_not_sep);
  };
  // invariant:  we've found all items in [b..boi)
  // e is an arbitrary value to use as the initializer
  for (typename std::remove_const<decltype(e)>::type boi = new_boi(s.cbegin()),
                                                     eoi = e;
       boi != e;
       boi = new_boi(eoi)) // advance to next non-separator
  {
    // find end of current item:
    eoi = std::find_if(boi, e, is_sep);

    // copy the item formed from characters in [boi..eoi):
    *dest = std::string(boi, eoi);
    ++dest;
  } // for

} // split_if<>()

void cet::split_path	(	std::string const &	path,
		std::vector< std::string > &	components
	)

Definition at line 13 of file split_path.cc.

{
  if (path.empty())
    components.clear();
  else
    boost::algorithm::split(components, path, boost::algorithm::is_any_of(":"));
}

template<class T >

constexpr T cet::square

(

T

x

)

Definition at line 21 of file pow.h.

  {
    return pow<2u>(x);
  }

template<class RandCont >

void cet::stable_sort_all ( RandCont &  s )

inline

Definition at line 265 of file container_algorithms.h.

{
  using std::begin;
  using std::end;
  std::stable_sort(begin(s), end(s));
}

template<class RandCont , class Pred >

void cet::stable_sort_all ( RandCont &  s, Pred  p  )

inline

Definition at line 274 of file container_algorithms.h.

{
  using std::begin;
  using std::end;
  std::stable_sort(begin(s), end(s), p);
}

template<class T >

constexpr T cet::sum_of_squares	(	T	x,
		T	y
	)

Definition at line 139 of file pow.h.

{
  return square(x) + square(y);
}

template<class T >

constexpr T cet::sum_of_squares	(	T	x,
		T	y,
		T	z
	)

Definition at line 146 of file pow.h.

{
  return square(x) + square(y) + square(z);
}

template<class T >

void cet::swap ( maybe_ref< T > &  r1, maybe_ref< T > &  r2  )

inline

Definition at line 113 of file maybe_ref.h.

{
  r1.swap(r2);
}

template<class E >

void cet::swap ( exempt_ptr< E > &  x, exempt_ptr< E > &  y  )

inlinenoexcept

Definition at line 191 of file exempt_ptr.h.

{
  x.swap(y);
}

template<class E , class C , class D >

void cet::swap ( value_ptr< E, C, D > &  x, value_ptr< E, C, D > &  y  )

noexcept

Definition at line 335 of file value_ptr.h.

{
  x.swap(y);
}

template<class Container , class OutputIt , class UnaryOp >

auto cet::transform_all ( Container &  in, OutputIt  out, UnaryOp  unary_op  )

inline

Definition at line 284 of file container_algorithms.h.

{
  using std::begin;
  using std::end;
  return std::transform(begin(in), end(in), out, unary_op);
}

template<class Container , class OutputIt , class UnaryOp >

auto cet::transform_all ( Container const &  in, OutputIt  out, UnaryOp  unary_op  )

inline

Definition at line 293 of file container_algorithms.h.

{
  using std::cbegin;
  using std::cend;
  return std::transform(cbegin(in), cend(in), out, unary_op);
}

template<class Container1 , class Container2 , class OutputIt , class BinaryOp >

auto cet::transform_all ( Container1 &  in1, Container2 &  in2, OutputIt  out, BinaryOp  binary_op  )

inline

Definition at line 302 of file container_algorithms.h.

{
  using std::begin;
  using std::end;
  return std::transform(begin(in1), end(in1), begin(in2), out, binary_op);
}

template<class Container1 , class Container2 , class OutputIt , class BinaryOp >

auto cet::transform_all ( Container1 const &  in1, Container2 const &  in2, OutputIt  out, BinaryOp  binary_op  )

inline

Definition at line 314 of file container_algorithms.h.

{
  using std::cbegin;
  using std::cend;
  return std::transform(cbegin(in1), cend(in1), cbegin(in2), out, binary_op);
}

std::string & cet::trim ( std::string &  source, std::string const &  t = " "  )

inline

Definition at line 45 of file trim.h.

{
  return trim_right(source, t), trim_left(source, t);
}

std::string cet::trim_copy ( std::string  source, std::string const &  t = " "  )

inline

Definition at line 66 of file trim.h.

{
  return trim(source, t);
}

std::string & cet::trim_left ( std::string &  source, std::string const &  t = " "  )

inline

Definition at line 39 of file trim.h.

{
  return source.erase(0, source.find_first_not_of(t));
}

std::string cet::trim_left_copy ( std::string  source, std::string const &  t = " "  )

inline

Definition at line 60 of file trim.h.

{
  return trim_left(source, t);
}

std::string & cet::trim_right ( std::string &  source, std::string const &  t = " "  )

inline

Definition at line 33 of file trim.h.

{
  return source.erase(1 + source.find_last_not_of(t));
}

std::string cet::trim_right_copy ( std::string  source, std::string const &  t = " "  )

inline

Definition at line 54 of file trim.h.

{
  return trim_right(source, t);
}

template<class T >

std::enable_if_t< std::is_arithmetic_v< T >, T > cet::unchecked_hypot ( T  x, T  y  )

inline

Definition at line 33 of file hypot.h.

{
  return std::hypot(x, y);
}

std::string cet::unescape

(

std::string const &

str

)

Definition at line 50 of file canonical_string.cc.

{
  std::string result;
  for (std::string::const_iterator it = str.begin(), e = str.end(); it != e;
       ++it) {
    char ch = *it;
    if (ch == '\\' && it != e - 1) {
      switch (*++it) {
      case '\"':
        ch = '\"';
        break;
      case '\'':
        ch = '\'';
        break;
      case '\\':
        ch = '\\';
        break;
      case 'n':
        ch = '\n';
        break;
      case 't':
        ch = '\t';
        break;
      default:
        throw cet::exception("unknown escape: \\") << *it;
      }
    }
    result.append(1, ch);
  }
  return result;
} // unescape()

Variable Documentation

template<class U >

constexpr std::size_t cet::bit_size_v = bit_size<U>::value

Definition at line 26 of file bit_manipulation.h.

cet::path_tag_t const cet::path_tag

Definition at line 60 of file search_path.cc.

template<typename T >

std::string const& cet::PluginTypeDeducer_v = PluginTypeDeducer<T>::value

Definition at line 49 of file PluginTypeDeducer.h.