CxxUtils/Root/ClassName.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "CxxUtils/ClassName.h"
#include <cassert>
 
 
namespace CxxUtils {
 
 

ClassName::ExcBadClassName::ExcBadClassName (const std::string& name)
  : std::runtime_error ("ExcBadClassName: Malformed class name: `" +
                        name + "'")
{
}
 

ClassName::ExcMissingVariable::ExcMissingVariable (const std::string& var)
  : std::runtime_error ("ExcMissingVariable: Variable `" + var +
                        "' referenced in substitution but not present "
                        "in matches map.")
{
}
 

size_t ClassName::Rules::size() const
{
  return m_rules.size();
}
 

void ClassName::Rules::add (const ClassName& pattern,
                            const ClassName& replacement)
{
  m_rules.insert (std::make_pair (pattern.name(),
                                  std::make_pair (pattern, replacement)));
}
 

void ClassName::Rules::add (ClassName&& pattern,
                            ClassName&& replacement)
{
  std::string name = pattern.name();
  m_rules.insert (std::make_pair (name,
                                  std::make_pair (std::move(pattern),
                                                  std::move(replacement))));
}
 

bool ClassName::Rules::applyTo (ClassName& cn) const
{
  bool ret = false;
  rulemap_t::const_iterator it = m_rules.find (cn.name());
  while (it != m_rules.end() && it->first == cn.name()) {
    ClassName::match_t matches;
    if (cn.match (it->second.first, matches)) {
      bool const_save = cn.isConst();
      cn = it->second.second.substCopy (matches);
      if (const_save) {
        cn.setConst();
      }
      ret = true;
    }
    ++it;
  }
  return ret;
}
 

std::string ClassName::Rules::apply (const std::string& name) const
{
  return ClassName::applyRules (name, *this);
}
 

ClassName::ClassName ()
  : m_const(false)
{
}
 

ClassName::ClassName (const char* name)
  : m_const(false)
{
  std::string sname = name;
  std::string::size_type pos = 0;
  parse (sname, pos);
  skipSpaces (sname, pos);
  if (pos != sname.size())
    throw ExcBadClassName (sname);
}
 

ClassName::ClassName (const std::string& name)
  : m_const(false)
{
  std::string::size_type pos = 0;
  parse (name, pos);
  skipSpaces (name, pos);
  if (pos != name.size())
    throw ExcBadClassName (name);
}
 

ClassName::ClassName (const std::string& name, std::string::size_type& pos)
  : m_const (false)
{
  parse (name, pos);
}
 

void ClassName::swap (ClassName& other)
{
  std::swap (m_const, other.m_const);
  std::swap (m_namespace, other.m_namespace);
  std::swap (m_name, other.m_name);
  m_targs.swap (other.m_targs);
}
 

bool ClassName::isConst() const
{
  return m_const;
}
 

void ClassName::setConst()
{
  m_const = true;
}
 

const std::string& ClassName::name() const
{
  return m_name;
}
 

std::string ClassName::qualifiedName() const
{
  std::string nsname;
  if (m_namespace.size() > 0)
    nsname = m_namespace[0].fullName() + "::";
  return nsname + m_name;
}
 

std::string ClassName::fullName() const
{
  std::string name = qualifiedName();
  if (m_const)
    name = "const " + name;
  if (m_targs.size() > 0) {
    name += '<';
    for (const ClassName& cn : m_targs) {
      if (name[name.size()-1] != '<')
        name += ',';
      name += cn.fullName();
    }
    if (name[name.size()-1] == '>')
      name += ' ';
    name += '>';
  }
  return name;
}
 

size_t ClassName::ntargs() const
{
  return m_targs.size();
}
 

const ClassName& ClassName::targ (size_t i) const
{
  return m_targs.at (i);
}
 

bool ClassName::operator== (const ClassName& other) const
{
  if (m_name != other.m_name)
    return false;
 
  if (m_const != other.m_const)
    return false;
 
  if (m_namespace.size() != other.m_namespace.size())
    return false;
 
  if (m_targs.size() != other.m_targs.size())
    return false;
 
  if (m_namespace.size() > 0 && m_namespace[0] != other.m_namespace[0])
    return false;
 
  for (size_t i = 0; i < m_targs.size(); ++i) {
    if (m_targs[i] != other.m_targs[i])
      return false;
  }
 
  return true;
}
 

bool ClassName::operator!= (const ClassName& other) const
{
  return !(*this==other);
}
 

bool ClassName::match (const ClassName& pattern, match_t& matches) const
{
  matches.clear();
  return match1 (pattern, true, matches);
}
 

void ClassName::subst (const match_t& matches)
{
  if (m_name[0] == '$') {
    std::string var = m_name.substr (1, std::string::npos);
    match_t::const_iterator it = matches.find (var);
    if (it != matches.end()) {
      bool const_save = m_const;
      *this = it->second;
      m_const |= const_save;
    }
    else {
      throw ExcMissingVariable (var);
    }
  }
 
  for (ClassName& c : m_namespace)
    c.subst (matches);
  for (ClassName& c : m_targs)
    c.subst (matches);
}
 

ClassName ClassName::substCopy (const match_t& matches) const
{
  ClassName cn (*this);
  cn.subst (matches);
  return cn;
}
 

void ClassName::applyRules (const Rules& rules)
{
  while (applyRules1 (rules))
    ;
}
 

std::string ClassName::applyRules (const std::string& name,
                                   const Rules& rules)
{
  ClassName cn (name);
  cn.applyRules (rules);
  return cn.fullName();
}
 

void ClassName::parse (const std::string& name, std::string::size_type& pos)
{
  m_name = parsePrimary (name, pos);
  if (m_name.compare (0, 6, "const ") ==0) {
    m_const = true;
    m_name.erase (0, 6);
  }
  if (m_name.size() >= 6 && m_name.compare (m_name.size()-6, 6, " const") ==0) {
    m_const = true;
    m_name.erase (m_name.size()-6, 6);
  }
 
  skipSpaces (name, pos);
  while (pos < name.size()) {
    if (name[pos] == '<')
      parseTemplateArgs (name, pos);
    else if (name[pos] == ':' && pos+1 < name.size() && name[pos+1] == ':')
      parseNamespace (name, pos);
    else
      break;
  }
  skipSpaces (name, pos);
  if (name.compare (pos, 5, "const")==0) {
    m_const = true;
    pos += 5;
  }
}
 

std::string
ClassName::parsePrimary (const std::string& name, std::string::size_type& pos)
{
  skipSpaces (name, pos);
  std::string out;
  size_t nest = 0;
  while (pos < name.size()) {
    char c = name[pos];
    if (c == '(')
      ++nest;
    else if (c == ')' && nest > 0)
      --nest;
    else if (nest == 0 && (c == '<' || c == '>' || c == ',' || c == ':'))
      break;
 
    out += c;
    ++pos;
  }
  return out;
}
 

void ClassName::parseNamespace (const std::string& name,
                                std::string::size_type& pos)
{
  assert (pos+1 < name.size() && name[pos] == ':' && name[pos+1] == ':');
  pos += 2;
  skipSpaces (name, pos);
 
  ClassName ns (name, pos);
  ns.swap (*this);
  if (ns.isConst()) {
    this->setConst();
    ns.m_const = false;
  }
  ClassName* p = this;
  while (p->m_namespace.size() > 0)
    p = &p->m_namespace[0];
  p->m_namespace.push_back (std::move(ns));
}
 

void ClassName::parseTemplateArgs (const std::string& name,
                                   std::string::size_type& pos)
{
  assert (pos < name.size() && name[pos] == '<');
  ++pos;
  while (true) {
    skipSpaces (name, pos);
    m_targs.emplace_back (name, pos);
    skipSpaces (name, pos);
    if (pos == name.size()) break;
    if (name[pos] == '>') {
      ++pos;
      break;
    }
    else if (name[pos] == ',')
      ++pos;
    else
      break;
  }
}
 

void ClassName::skipSpaces (const std::string& name,
                            std::string::size_type& pos)
{
  while (pos < name.size() && name[pos] == ' ')
    ++pos;
}
 

bool ClassName::match1 (const ClassName& pattern,
                        bool topLevel,
                        match_t& matches) const
{
  if (pattern.m_name[0] == '$') {
    std::string var = pattern.m_name.substr (1, std::string::npos);
    match_t::iterator it = matches.find (var);
    if (it != matches.end()) {
      if (pattern.m_const && !it->second.m_const) {
        ClassName cn (it->second);
        cn.setConst();
        return *this == cn;
      }
      return *this == it->second;
    }
 
    matches[var] = *this;
    if (pattern.m_const) {
      if (m_const)
        matches[var].m_const = false;
      else
        return false;
    }
    return true;
  }
 
  // Require that const qualifiers match.
  // However, if this is the top level, we allow a pattern with no explicit
  // const to match something that is const.  Otherwise, we'd need to repeat
  // all patterns for the const case.
  if (topLevel) {
    if (pattern.m_const && !m_const)
      return false;
  }
  else if (m_const != pattern.m_const) {
    return false;
  }
 
  if (m_name != pattern.m_name)
    return false;
 
  if (m_namespace.size() != pattern.m_namespace.size())
    return false;
 
  if (m_targs.size() != pattern.m_targs.size())
    return false;
 
  if (m_namespace.size() > 0) {
    if (!m_namespace[0].match1 (pattern.m_namespace[0], false, matches))
      return false;
  }
 
  for (size_t i = 0; i < m_targs.size(); i++) {
    if (!m_targs[i].match1 (pattern.m_targs[i], false, matches))
      return false;
  }
 
  return true;
}
 

bool ClassName::applyRules1 (const Rules& rules)
{
  bool ret = rules.applyTo (*this);
 
  if (m_namespace.size() > 0)
    ret |= m_namespace[0].applyRules1 (rules);
 
  for (size_t i = 0; i < m_targs.size(); i++)
    ret |= m_targs[i].applyRules1 (rules);
 
  return ret;
}
 
 
} // namespace CxxUtils