asg::detail Namespace Reference

Enumerations
enum	AnaToolHandleMode {   AnaToolHandleMode::EMPTY, AnaToolHandleMode::CREATE_PRIVATE, AnaToolHandleMode::CREATE_SHARED, AnaToolHandleMode::RETRIEVE_SHARED,   AnaToolHandleMode::USER }
	the mode with which an AnaToolHandle object is initialized More...

Functions
void	throw_check_fail (const std::string &str)
	throw an error for a failed check More...
bool	matchesRegex (const std::string &regex, const std::string &str)
	return whether str matches regex More...
StatusCode	hasPropertiesInCatalogue (const std::string &toolName)
StatusCode	addPropertyToCatalogue (const std::string &toolName, const std::string &propertyName, const std::string &propertyValue)
StatusCode	removePropertyFromCatalogue (const std::string &toolName, const std::string &propertyName)
StatusCode	toolExists (const std::string &fullName, interfaceType_t *&tool)
StatusCode	factoryExists (const std::string &type)
StatusCode	copyPropertiesInCatalogue (const std::string &fromTool, const std::string &toTool)
StatusCode	readToolConfig (AsgToolConfig &config, const std::string &toolName)
StatusCode	packStringMap (const std::map< std::string, std::string > &value, std::string &result)
StatusCode	packStringVector (const std::vector< std::string > &value, std::string &result)
StatusCode	packStringSingle (const std::string &value, std::string &result)
StatusCode	unpackStringSingle (const std::string &value, std::string &result)
StatusCode	unpackStringVector (const std::string &value, std::vector< std::string > &result)
StatusCode	unpackStringMap (const std::string &value, std::map< std::string, std::string > &result)

Enumeration Type Documentation

AnaToolHandleMode

enum asg::detail::AnaToolHandleMode

strong

the mode with which an AnaToolHandle object is initialized

Enumerator
EMPTY	do not create a tool this can be either explicitly an empty tool handle set by the user, or an AnaToolHandle that was never configured in the first place.
CREATE_PRIVATE	create a private tool normally
CREATE_SHARED	create a shared tool normally
RETRIEVE_SHARED	retrieve a shared tool
USER	retrieve a tool from the user tool handle this can still refer to a tool handle that is empty, though usually it will point to an actual tool

Definition at line 45 of file AnaToolHandle.h.

    {
      EMPTY,
 
      CREATE_PRIVATE,
 
      CREATE_SHARED,
 
      RETRIEVE_SHARED,
 
      USER
    };

Function Documentation

addPropertyToCatalogue()

StatusCode asg::detail::addPropertyToCatalogue	(	const std::string &	toolName,
		const std::string &	propertyName,
		const std::string &	propertyValue
	)

Definition at line 210 of file AnaToolHandle.cxx.

                                                                                                                                  {
//std::cout << "Adding " << toolName << " ." << propertyName << " = " << propertyValue << std::endl;
      ServiceHandle<Gaudi::Interfaces::IOptionsSvc> joSvc("JobOptionsSvc","AnaToolHandle");
      //check if propertyName contains '.' . If it does, then assume settng a property of a private tool, so adjust toolname
      joSvc->set( toolName + "." + propertyName, propertyValue );
      if(joSvc.release().isFailure()) return StatusCode::FAILURE;
      return StatusCode::SUCCESS;
   }

copyPropertiesInCatalogue()

StatusCode asg::detail::copyPropertiesInCatalogue	(	const std::string &	fromTool,
		const std::string &	toTool
	)

Definition at line 253 of file AnaToolHandle.cxx.

                                                                                              {
      using namespace msgToolHandle;
      //this method copies any properties assigned to 'fromTool' to 'toTool'
      //purpose of this is because python joboptions will set joboptions properties using the name of the handle
      //but we would like the name of the property (in declareProperty) to be used for anatoolhandles instead, in the case of private tools
//std::cout << "copy : " << fromTool << " -> " << toTool << std::endl;
      if(fromTool == toTool) return StatusCode::SUCCESS; //nothing to do
 
      ServiceHandle<Gaudi::Interfaces::IOptionsSvc> joSvc("JobOptionsSvc","AnaToolHandle");
      auto fromProps = joSvc->items(std::regex ("^" + fromTool));
      for(auto& prop : fromProps) {
        std::get<0>(prop).replace (0, fromTool.size(), toTool);
        joSvc->set( std::get<0>(prop) , std::get<1>(prop) );
      }
      if(joSvc.release().isFailure()) return StatusCode::FAILURE;
      return StatusCode::SUCCESS;
   }

factoryExists()

StatusCode asg::detail::factoryExists

(

const std::string &

type

)

Definition at line 246 of file AnaToolHandle.cxx.

                                                     {
      using Gaudi::PluginService::Details::Registry;
      Registry &reg = Registry::instance();
      if(reg.getInfo(type).library=="unknown") return StatusCode::FAILURE;
      return StatusCode::SUCCESS;
   }

hasPropertiesInCatalogue()

StatusCode asg::detail::hasPropertiesInCatalogue

(

const std::string &

toolName

)

Definition at line 194 of file AnaToolHandle.cxx.

                                                                    {
      ServiceHandle<Gaudi::Interfaces::IOptionsSvc> svc("JobOptionsSvc","AnaToolHandle");
      if( svc.retrieve().isFailure() ) return StatusCode::FAILURE;
      auto props = svc->items(std::regex("^" + toolName + "\\."));
      StatusCode out = StatusCode::FAILURE;
      for (auto& prop : svc->items())
      {
        if (std::get<0>(prop).substr (0, toolName.size()) == toolName &&
            std::get<0>(prop)[toolName.size()] == '.')
          out = StatusCode::SUCCESS;
      }
      svc.release().ignore();
      //delete props;
      return out;
   }

matchesRegex()

bool asg::detail::matchesRegex	(	const std::string &	regex,
		const std::string &	str
	)

return whether str matches regex

Guarantee

strong

Failures

out of memory II
expression error

Definition at line 25 of file Control/AthToolSupport/AsgTesting/Root/UnitTest.cxx.

    {
      return regex_search (str, std::regex (regex));
    }

packStringMap()

StatusCode asg::detail::packStringMap	(	const std::map< std::string, std::string > &	value,
		std::string &	result
	)

Definition at line 273 of file TProperty.cxx.

    {
      std::string myresult;
      for (const auto& subvalue : value)
      {
    if (!myresult.empty())
      myresult += ",";
    myresult += quoteString (subvalue.first) + ":" + quoteString (subvalue.second);
      }
      result = "{" + std::move (myresult) + "}";
      return StatusCode::SUCCESS;
    }

packStringSingle()

StatusCode asg::detail::packStringSingle	(	const std::string &	value,
		std::string &	result
	)

Definition at line 305 of file TProperty.cxx.

    {
      if (value.find ("\\") == std::string::npos)
      {
        if (value.find ("\'") == std::string::npos)
        {
          result = "\'" + value + "\'";
          return StatusCode::SUCCESS;
        }
        if (value.find ("\"") == std::string::npos)
        {
          result = "\"" + value + "\"";
          return StatusCode::SUCCESS;
        }
      }
      char quote = '\'';
      if (value.find ("\'") != std::string::npos &&
          value.find ("\"") == std::string::npos)
        quote = '\"';
      result = quote;
      for (char ch : value)
      {
        if (ch == quote || ch == '\\')
          result += '\\';
        result += ch;
      }
      result += quote;
      return StatusCode::SUCCESS;
    }

packStringVector()

StatusCode asg::detail::packStringVector	(	const std::vector< std::string > &	value,
		std::string &	result
	)

Definition at line 289 of file TProperty.cxx.

    {
      std::string myresult;
      for (const auto& subvalue : value)
      {
    if (!myresult.empty())
      myresult += ",";
    myresult += quoteString (subvalue);
      }
      result = "[" + std::move (myresult) + "]";
      return StatusCode::SUCCESS;
    }

readToolConfig()

StatusCode asg::detail::readToolConfig	(	AsgToolConfig &	config,
		const std::string &	toolName
	)

Definition at line 272 of file AnaToolHandle.cxx.

                                                                                {
     using namespace msgToolHandle;
     //this method copies any properties assigned to tool with 'toolName' to 'config'
     ServiceHandle<Gaudi::Interfaces::IOptionsSvc> joSvc("JobOptionsSvc","AnaToolHandle");
     decltype(auto) fromProps = joSvc->items(std::regex ("^" + toolName));
     for(const auto& prop : fromProps) {
       if (std::get<0>(prop) == toolName)
       {
         config.setTypeAndName (std::get<1>(prop));
       } else
       {
         config.setPropertyFromString (std::get<0>(prop).substr (toolName.size()+1) , std::get<1>(prop));
       }
     }
     ANA_CHECK (joSvc.release());
     return StatusCode::SUCCESS;
   }

removePropertyFromCatalogue()

StatusCode asg::detail::removePropertyFromCatalogue	(	const std::string &	toolName,
		const std::string &	propertyName
	)

Definition at line 221 of file AnaToolHandle.cxx.

                                                                                                      {
      ServiceHandle<Gaudi::Interfaces::IOptionsSvc> joSvc("JobOptionsSvc","AnaToolHandle");
      //check if propertyName contains '.' . If it does, then assume settng a property of a private tool, so adjust toolname
      std::string theToolName = toolName; std::string thePropertyName=propertyName;
      std::string::size_type dotLocation = thePropertyName.find_last_of('.');
      if(dotLocation != std::string::npos) {
         theToolName = toolName + "." + thePropertyName.substr(0,dotLocation);
         thePropertyName = thePropertyName.substr(dotLocation+1,thePropertyName.length()-dotLocation);
      }
      joSvc->pop( theToolName + "." + thePropertyName );
      if(joSvc.release().isFailure()) return StatusCode::FAILURE;
      return StatusCode::SUCCESS;
   }

throw_check_fail()

void asg::detail::throw_check_fail

(

const std::string &

str

)

throw an error for a failed check

the main reason to have a separate function for this is to cut down on the number of includes in the header file.

Definition at line 27 of file Control/AthToolSupport/AsgMessaging/Root/MessageCheck.cxx.

    {
      throw std::runtime_error (str);
    }

toolExists()

StatusCode asg::detail::toolExists	(	const std::string &	fullName,
		interfaceType_t *&	tool
	)

Definition at line 234 of file AnaToolHandle.cxx.

                                                                               {
      ServiceHandle<IToolSvc> toolSvc("ToolSvc","AnaToolHandle");
      toolSvc.retrieve().ignore();
      auto tools = toolSvc->getTools();
      StatusCode out(StatusCode::FAILURE);
      for(auto atool : tools) {
         if(atool && atool->name() == fullName) {out=StatusCode::SUCCESS;tool=atool;break;}
      }
      toolSvc.release().ignore();
      return out;
   }

unpackStringMap()

StatusCode asg::detail::unpackStringMap	(	const std::string &	value,
		std::map< std::string, std::string > &	result
	)

Definition at line 489 of file TProperty.cxx.

    {
      using namespace asg::msgProperty;
 
      std::vector<Token> tokenTree;
      {
        std::vector<Token> tokenList;
        ANA_CHECK (make_token_list (value, tokenList));
        auto iterator = tokenList.begin();
        ANA_CHECK (make_token_tree (iterator, tokenList.end(), tokenTree, false));
      }
 
      if (tokenTree.size() != 1 ||
          tokenTree[0].m_type != TokenType::SUBGROUP ||
          tokenTree[0].m_subtokens[0].m_type != TokenType::MAP_OPEN)
      {
        ANA_MSG_ERROR ("failed to recognize value as map: " << value);
        return StatusCode::FAILURE;
      }
 
      // note that this loop avoids the first and last token,
      // i.e. "{" and "}"
      for (std::size_t index = 1;
           index < tokenTree[0].m_subtokens.size()-1; ++ index)
      {
        Token& mytoken = tokenTree[0].m_subtokens[index];
        switch (index % 4)
        {
        case 0:
          if (mytoken.m_type != TokenType::COMMA)
          {
            ANA_MSG_ERROR ("unexpected token " << mytoken.m_raw);
            return StatusCode::FAILURE;
          }
          break;
        case 1:
          if (mytoken.m_type == TokenType::COMMA ||
              mytoken.m_type == TokenType::MAP_SEPARATOR)
          {
            ANA_MSG_ERROR ("unexpected token " << mytoken.m_raw);
            return StatusCode::FAILURE;
          }
          break;
        case 2:
          if (mytoken.m_type != TokenType::MAP_SEPARATOR)
          {
            ANA_MSG_ERROR ("unexpected token " << mytoken.m_raw);
            return StatusCode::FAILURE;
          }
          break;
        case 3:
          if (mytoken.m_type == TokenType::COMMA ||
              mytoken.m_type == TokenType::MAP_SEPARATOR)
          {
            ANA_MSG_ERROR ("unexpected token " << mytoken.m_raw);
            return StatusCode::FAILURE;
          }
          Token& keytoken = tokenTree[0].m_subtokens[index-2];
          result.emplace (keytoken.m_raw, mytoken.m_raw);
          break;
        }
      }
      if (tokenTree[0].m_subtokens.size() > 2 &&
          tokenTree[0].m_subtokens.size()%4 != 1)
      {
        ANA_MSG_ERROR ("unexpected token " << tokenTree[0].m_subtokens.back().m_raw);
        return StatusCode::FAILURE;
      }
      return StatusCode::SUCCESS;
    }

unpackStringSingle()

StatusCode asg::detail::unpackStringSingle	(	const std::string &	value,
		std::string &	result
	)

Definition at line 339 of file TProperty.cxx.

    {
      using namespace asg::msgProperty;
 
      // special case: we don't have a quote, use string verbatim
      if (value.find ('\'') == std::string::npos &&
          value.find ('"') == std::string::npos)
      {
        result = value;
        return StatusCode::SUCCESS;
      }
 
      std::vector<Token> tokens;
      ANA_CHECK (make_token_list (value, tokens));
      assert (!tokens.empty());
      if (tokens.front().m_type == TokenType::SPACE)
      {
        tokens.erase (tokens.begin());
        assert (!tokens.empty());
      }
      if (tokens.back().m_type == TokenType::SPACE)
      {
        tokens.erase (tokens.begin() + (tokens.size() - 1));
        assert (!tokens.empty());
      }
      if (tokens[0].m_type != TokenType::STRING)
      {
        ANA_MSG_ERROR ("string property didn't start with a quote: " << value);
        return StatusCode::FAILURE;
      }
      if (tokens.size() > 1)
      {
        ANA_MSG_ERROR ("extra text beyond quoted string: " << value);
        return StatusCode::FAILURE;
      }
      result.swap (tokens[0].m_cooked);
      return StatusCode::SUCCESS;
    }

unpackStringVector()

StatusCode asg::detail::unpackStringVector	(	const std::string &	value,
		std::vector< std::string > &	result
	)

Definition at line 381 of file TProperty.cxx.

    {
      using namespace asg::msgProperty;
 
      std::vector<std::string> myresult;
 
      std::vector<Token> tokens;
      ANA_CHECK (make_token_list (value, tokens));
 
      bool done = false;
      unsigned level = 0;
      std::string subresult;
      for (auto& token : tokens)
      {
        if (token.m_type == TokenType::LIST_OPEN)
          ++ level;
        if (level > 1)
        {
          subresult += token.m_raw;
        } else if (level == 0)
        {
          if (token.m_type != TokenType::SPACE)
          {
            if (done)
            {
              ANA_MSG_ERROR ("vector property does not end with ']': " << value);
              return StatusCode::FAILURE;
            } else
            {
              ANA_MSG_ERROR ("vector property does not begin with '[': " << value);
              return StatusCode::FAILURE;
            }
          }
        } else switch (token.m_type)
        {
        case TokenType::MAP_SEPARATOR:
        case TokenType::MAP_OPEN:
        case TokenType::MAP_CLOSE:
        case TokenType::SUBGROUP:
          // not handling this (for now).  if it comes up I fix it,
          // but for now this would be more of a distraction.
          ANA_MSG_ERROR ("(currently) unsupported token in vector: " << token.m_raw);
          return StatusCode::FAILURE;
        case TokenType::SPACE:
          break;
        case TokenType::STRING:
        case TokenType::NUMBER:
          if (!subresult.empty())
          {
            ANA_MSG_ERROR ("invalid entry in vector: " << subresult << token.m_raw);
            return StatusCode::FAILURE;
          }
          subresult = std::move (token.m_raw);
          break;
        case TokenType::COMMA:
          if (subresult.empty())
          {
            ANA_MSG_ERROR ("comma not preceded by value: " << value);
            return StatusCode::FAILURE;
          }
          myresult.push_back (std::move (subresult));
          subresult.clear ();
          break;
        case TokenType::LIST_OPEN:
          if (done)
          {
            ANA_MSG_ERROR ("vector property does not begin with '[': " << value);
            return StatusCode::FAILURE;
          }
          break;
        case TokenType::LIST_CLOSE:
          if (!subresult.empty())
          {
            myresult.push_back (std::move (subresult));
            subresult.clear ();
          } else
          {
            if (!myresult.empty())
            {
              ANA_MSG_ERROR ("vector property has ',' before ']': " << value);
              return StatusCode::FAILURE;
            }
          }
          done = true;
          break;
        }
        if (token.m_type == TokenType::LIST_CLOSE)
        {
          if (level == 0)
          {
            ANA_MSG_ERROR ("extra ']' in vector: " << value);
            return StatusCode::FAILURE;
          }
          -- level;
        }
      }
      if (!done)
      {
        ANA_MSG_ERROR ("did not find a vector in the string");
        return StatusCode::FAILURE;
      }
      result.swap (myresult);
      return StatusCode::SUCCESS;
    }