RCU Namespace Reference

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

Namespaces
namespace	Check
namespace	Shell

Classes
class	ExceptionMsg
struct	Message
class	UnitTestDir

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

Functions
void	check_root_version ()
	effects: check whether we are using a consistent root version guarantee: strong failures: version missmatch
void	disable_root_version_check ()
	effects: disable the root version check guarantee: no-fail
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
std::string	locate (const std::string &locations)
	effects: find the file with the given name from a list of locations separated by "::".
void	send_message (const char *package, const char *file, unsigned line, MessageType type, const char *msg)
void	send_message (const char *package, const char *file, unsigned line, MessageType type, const std::string &msg)
void	send_message (const char *package, const char *file, unsigned line, MessageType type, const TString &msg)
void	send_message_abort (const char *package, const char *file, unsigned line, MessageType type, const char *msg)
void	send_message_abort (const char *package, const char *file, unsigned line, MessageType type, const std::string &msg)
void	send_message_abort (const char *package, const char *file, unsigned line, MessageType type, const TString &msg)
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 rationale: I am returning a TString instead of an std::string, so that this can be passed directly into regexp

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.

This module provides a lot of global definitions, forward declarations and includes that are used by all modules.

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 18 of file MessageType.h.

  {
    MESSAGE_REGULAR,

    MESSAGE_WARNING,

    MESSAGE_ERROR,

    MESSAGE_EXCEPTION,

    MESSAGE_ABORT,

    MESSAGE_UNSPECIFIED
  };

Function Documentation

check_root_version()

void RCU::check_root_version

(

)

effects: check whether we are using a consistent root version guarantee: strong failures: version missmatch

Definition at line 31 of file CheckRootVersion.cxx.

  {
    if (checked)
      return;
    if (gROOT->GetVersionCode() != Int_t(ROOT_VERSION_CODE))
    {
      std::cout
    << "root version used is not compatible with the one used for\n"
    << "compilation.  please load either the correct root version, or\n"
    << "recompile with the new version\n\n"
    << "alternatively deactivate this check using:\n"
    << "#include <RootCoreUtils/CheckRootVersion.hh>\n"
    << "  RCU::disable_root_version_check()\n"
    << std::flush;
      std::abort ();
    }
    checked = true;
  }

disable_root_version_check()

void RCU::disable_root_version_check

(

)

effects: disable the root version check guarantee: no-fail

Definition at line 52 of file CheckRootVersion.cxx.

  {
    checked = true;
  }

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 rationale: I am returning a TString instead of an std::string, so that this can be passed directly into regexp

Definition at line 34 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 28 of file hadd.cxx.

  {
    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) )
    {
      RCU_THROW_MSG ("error opening target file: " + output_file);
    }
 
    for (std::vector<std::string>::const_iterator input = input_files.begin(),
       end = input_files.end(); input != end; ++ input)
    {
      if (!merger.AddFile (input->c_str()))
      {
    RCU_THROW_MSG ("error adding input file: " + *input);
      }         
    }
    merger.SetNotrees (false);
 
    bool status = merger.Merge();
 
    if (status)
    {
      std::ostringstream msg;
      msg << "merged " << merger.GetMergeList()->GetEntries()
      << " input files into " << output_file;
      RCU_PRINT_MSG (msg.str());
    } else
    {
      RCU_THROW_MSG ("hadd failure during the merge");
    }
  }

locate()

std::string RCU::locate

(

const std::string &

locations

)

effects: find the file with the given name from a list of locations separated by "::".

the list may contain either files or URLs starting with "http://". URLs will be downloaded into the data/ directory, where they will stay permanently. returns: the path in the local filesystem guarantee: strong failures: out of memory III failures: inconsistent file names failures: download errors rationale: depending on where you are executing your code, you may or may not have access to /cvmfs where important data files are kept. this mechanism allows to pick it up from various alternate places.

Definition at line 25 of file Locate.cxx.

  {
    std::deque<std::string> files;
    {
      std::string::size_type pos = 0, pos2 = 0;
      while ((pos2 = locations.find ("::", pos)) != std::string::npos)
      {
    files.push_back (locations.substr (pos, pos2 - pos));
    pos = pos2 + 2;
      }
      files.push_back (locations.substr (pos));
    }
    std::string name;
    {
      for (std::deque<std::string>::const_iterator file = files.begin(),
         end = files.end(); file != end; ++ file)
      {
    std::string::size_type split = file->rfind ('/');
    if (split == std::string::npos)
      RCU_THROW_MSG ("file name " + *file + " does not contain a \"/\"");
    std::string myname = file->substr (split + 1);
    if (myname.empty())
      RCU_THROW_MSG ("file name " + *file + " should not end with a \"/\"");
    if (name.empty())
      name = std::move(myname);
    else if (name != myname)
      RCU_THROW_MSG ("inconsistent file names " + name + " and " + myname);
      }
    }
    RCU_ASSERT (!name.empty());
 
    files.push_front ("$ROOTCOREBIN/data/RootCoreUtils/download/" + name);
    for (std::deque<std::string>::iterator file = files.begin(),
       end = files.end(); file != end; ++ file)
    {
      TString myfile = *file;
      gSystem->ExpandPathName (myfile);
      *file = myfile.Data();
    }
 
    for (std::deque<std::string>::const_iterator file = files.begin(),
       end = files.end(); file != end; ++ file)
    {
      if (file->find ("http://") == 0)
      {
    try
    {
      Shell::exec ("$ROOTCOREDIR/scripts/download.sh " + Shell::quote (*file) + " " + Shell::quote (files[0]));
      return files[0];
    } catch (...)
    {
      // rationale: ignoring all exceptions, since we might have
      //   more locations to try
    }
      } else
      {
    if (gSystem->AccessPathName (file->c_str()) == 0)
    {
      return *file;
    }
      }
    }
    RCU_THROW_MSG ("failed to find file at " + locations);
    return ""; // compiler dummy
  }

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 29 of file StringUtil.cxx.

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

send_message() [1/3]

void RCU::send_message	(	const char *	package,
		const char *	file,
		unsigned	line,
		MessageType	type,
		const char *	msg )

Definition at line 24 of file PrintMsg.cxx.

  {
    Message message;
    message.package = package;
    message.file = file;
    message.line = line;
    message.type = type;
    message.message = msg;
    message.send ();
  }

send_message() [2/3]

void RCU::send_message	(	const char *	package,
		const char *	file,
		unsigned	line,
		MessageType	type,
		const std::string &	msg )

Definition at line 38 of file PrintMsg.cxx.

  {
    send_message (package, file, line, type, msg.c_str());
  }

send_message() [3/3]

void RCU::send_message	(	const char *	package,
		const char *	file,
		unsigned	line,
		MessageType	type,
		const TString &	msg )

Definition at line 46 of file PrintMsg.cxx.

  {
    send_message (package, file, line, type, msg.Data());
  }

send_message_abort() [1/3]

void RCU::send_message_abort	(	const char *	package,
		const char *	file,
		unsigned	line,
		MessageType	type,
		const char *	msg )

Definition at line 54 of file PrintMsg.cxx.

  {
    Message message;
    message.package = package;
    message.file = file;
    message.line = line;
    message.type = type;
    message.message = msg;
    message.send ();
    RCU_ASSERT0 ("shouldn't get here");
    std::abort ();
  }

send_message_abort() [2/3]

void RCU::send_message_abort	(	const char *	package,
		const char *	file,
		unsigned	line,
		MessageType	type,
		const std::string &	msg )

Definition at line 70 of file PrintMsg.cxx.

  {
    send_message_abort (package, file, line, type, msg.c_str());
  }

send_message_abort() [3/3]

void RCU::send_message_abort	(	const char *	package,
		const char *	file,
		unsigned	line,
		MessageType	type,
		const TString &	msg )

Definition at line 78 of file PrintMsg.cxx.

  {
    send_message_abort (package, file, line, type, msg.Data());
  }

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 != 0);
 
    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.

  {
    RCU_REQUIRE(!pattern.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;
  }