RCU Namespace Reference

This module defines a variety of assert style macros. More...

Namespaces
namespace	Check
namespace	Shell

Classes
struct	Message
class	UnitTestDir

Enumerations
enum	MessageType {   MESSAGE_REGULAR , MESSAGE_WARNING , MESSAGE_ERROR , MESSAGE_EXCEPTION ,   MESSAGE_ABORT , MESSAGE_UNSPECIFIED }

Functions
void	hadd (const std::string &output_file, const std::vector< std::string > &input_files, unsigned max_files=0)
	effects: perform the hadd functionality guarantee: basic failures: out of memory III failures: i/o errors
bool	SetDirectory (TObject *object, TDirectory *directory)
	effects: set the directory this object is associated with returns: whether the object type actively knows its directory, otherwise this is a no-op guarantee: strong failures: directory add errors requires: object != 0 rationale: this is mainly meant to allow calling SetDirectory(0) on arbitrary objects, but it also tries to do the right thing when adding objects to a directory.
std::string	substitute (std::string_view str, std::string_view pattern, std::string_view with)
	effects: substitute all occurences of "pattern" with "with" in the string "str" returns: the substituted string guarantee: out of memory II requires: !pattern.empty()
bool	match_expr (const std::regex &expr, std::string_view str)
	returns: whether we can match the entire string with the regular expression guarantee: strong failures: out of memory II
std::string	glob_to_regexp (std::string_view glob)
	returns: a string that is the regular expression equivalent of the given glob expression guarantee: strong failures: out of memory II

Detailed Description

This module defines a variety of assert style macros.

This module defines a class that manages a temporary directory for unit tests.

This module defines macros for reporting errors.

Author

Nils Krumnack

Nils Krumnack This module defines a variety of assert style macros for different situations, i.e. macros that test whether a particular condition has been met and that trigger an error if the condition is not met. The exact error behavior depends on the configuration options as well as the macro called. The main distinction is the purpose of the test: RCU_REQUIRE: checks on the arguments to a function RCU_PROVIDE: checks on the results of a function RCU_ASSERT: checks that happen in the middle of a function RCU_INVARIANT: checks that happen in the invariant test These can be further modified using postfixes: _SLOW: tests that are in the critical path of a program _SOFT: tests that are expected to fail in correctly implemented programs, i.e. should trigger an exception 2: tests that have a textual description of the condition 0: tests that always fail Furthermore there are also invariant tests in here (calling MyClass::testInvariant()): RCU_READ_INVARIANT: an invariant is read, but not modified RCU_CHANGE_INVARIANT: an invariant is read and modified RCU_NEW_INVARIANT: an invariant has been newly established RCU_DESTROY_INVARIANT: an invariant is about to be decomissioned

Enumeration Type Documentation

MessageType

enum RCU::MessageType

Enumerator
MESSAGE_REGULAR	description: print a regular message
MESSAGE_WARNING	description: print a warning
MESSAGE_ERROR	description: print an error
MESSAGE_EXCEPTION	description: send out an exception
MESSAGE_ABORT	description: print and abort
MESSAGE_UNSPECIFIED	description: unspecified message type

Definition at line 16 of file MessageType.h.

  {
    MESSAGE_REGULAR,

    MESSAGE_WARNING,

    MESSAGE_ERROR,

    MESSAGE_EXCEPTION,

    MESSAGE_ABORT,

    MESSAGE_UNSPECIFIED
  };

Function Documentation

glob_to_regexp()

std::string RCU::glob_to_regexp

(

std::string_view

glob

)

returns: a string that is the regular expression equivalent of the given glob expression guarantee: strong failures: out of memory II

Definition at line 35 of file StringUtil.cxx.

  {
    std::string result;
    result.reserve(glob.size() * 2);
 
    for (char c : glob)
    {
      switch (c) 
      {
        case '*': 
          result += ".*"; 
          break;
        case '?': 
          result += '.'; 
          break;
        case '^': case '$': case '+': case '.': case '\\': 
        case '(': case ')': case '[': case ']': case '{': case '}': case '|':
          result += '\\';
          result += c;
          break;
        default:
          result += c;
          break;
      }
    }
    return result;
  }

hadd()

void RCU::hadd	(	const std::string &	output_file,
		const std::vector< std::string > &	input_files,
		unsigned	max_files )

effects: perform the hadd functionality guarantee: basic failures: out of memory III failures: i/o errors

Definition at line 29 of file hadd.cxx.

  {
    using namespace msgRootCoreUtils;
 
    if (input_files.size() == 1)
    {
      // if there is only one input file, create a symlink instead of merging
      std::filesystem::create_symlink (input_files.front(), output_file);
      return;
    }
 
    TFileMerger merger (false, false);
 
    merger.SetMsgPrefix ("rcu_hadd");
    merger.SetPrintLevel (98);
 
    if (max_files > 0)
    {
      merger.SetMaxOpenedFiles (max_files);
    }
 
    if (!merger.OutputFile (output_file.c_str(), false, 1) )
    {
      throw std::runtime_error ("error opening target file: " + output_file);
    }
 
    for (const std::string& input : input_files)
    {
      if (!merger.AddFile (input.c_str()))
      {
        throw std::runtime_error ("error adding input file: " + input);
      }
    }
    merger.SetNotrees (false);
 
    bool status = merger.Merge();
 
    if (status)
    {
      ANA_MSG_INFO ("merged " << merger.GetMergeList()->GetEntries() << " input files into " << output_file);
    } else
    {
      throw std::runtime_error ("hadd failure during the merge");
    }
  }

match_expr()

bool RCU::match_expr	(	const std::regex &	expr,
		std::string_view	str )

returns: whether we can match the entire string with the regular expression guarantee: strong failures: out of memory II

Definition at line 30 of file StringUtil.cxx.

  {
    return std::regex_match(str.begin(), str.end(), expr);
  }

SetDirectory()

bool RCU::SetDirectory	(	TObject *	object,
		TDirectory *	directory )

effects: set the directory this object is associated with returns: whether the object type actively knows its directory, otherwise this is a no-op guarantee: strong failures: directory add errors requires: object != 0 rationale: this is mainly meant to allow calling SetDirectory(0) on arbitrary objects, but it also tries to do the right thing when adding objects to a directory.

For the most part it is a workaround for TH1 objects keeping track of which directory they belong to.

Definition at line 25 of file RootUtils.cxx.

  {
    RCU_ASSERT (object != nullptr);
 
    TH1 *const hist = dynamic_cast<TH1*>(object);
    if (hist)
    {
      hist->SetDirectory (directory);
      return true;
    }
 
    TEfficiency *const efficiency = dynamic_cast<TEfficiency*>(object);
    if (efficiency)
    {
      efficiency->SetDirectory (directory);
      return true;
    }
 
    TTree *const tree = dynamic_cast<TTree*>(object);
    if (tree)
    {
      tree->SetDirectory (directory);
      return true;
    }
 
    return false;
  }

substitute()

std::string RCU::substitute	(	std::string_view	str,
		std::string_view	pattern,
		std::string_view	with )

effects: substitute all occurences of "pattern" with "with" in the string "str" returns: the substituted string guarantee: out of memory II requires: !pattern.empty()

Definition at line 14 of file StringUtil.cxx.

  {
    if (pattern.empty())
      throw std::runtime_error ("substitute: pattern must not be empty");
 
    std::string result(str);
    std::string::size_type pos = 0;
    
    while ((pos = result.find(pattern, pos)) != std::string::npos) {
      result.replace(pos, pattern.size(), with);
      pos += with.size();
    }
    return result;
  }