CxxUtils::ClassName Class Reference

Recursively separate out template arguments in a C++ class name. More...

#include <ClassName.h>

Collaboration diagram for CxxUtils::ClassName:

Classes
class	ExcBadClassName
	Exception to signal a malformed class name. More...
class	ExcMissingVariable
	Exception to signal a missing variable. More...
class	Rules
	A set of transformation rules to use with ClassName. More...

Public Types
typedef std::map< std::string, ClassName >	match_t
	Map used to hold variable assignments from matching.

Public Member Functions
	ClassName ()
	Default constructor.
	ClassName (const char *name)
	Parse a class name into component parts.
	ClassName (const std::string &name)
	Parse a class name into component parts.
	ClassName (const std::string &name, std::string::size_type &pos)
	Parse a class name into component parts.
void	swap (ClassName &other)
	Swap this expression with another one.
bool	isConst () const
	Get the const flag for this expression.
void	setConst ()
	Set the const flag for this expression.
const std::string &	name () const
	Return the root name of the expression.
std::string	qualifiedName () const
	Return the namespace-qualified name of the expression.
std::string	fullName () const
	Return the full name of the expression.
size_t	ntargs () const
	Return number of template arguments.
const ClassName &	targ (size_t i) const
	Return one template argument.
bool	operator== (const ClassName &other) const
	Test two expressions for equality.
bool	operator!= (const ClassName &other) const
	Test two expressions for inequality.
bool	match (const ClassName &pattern, match_t &matches) const
	Match this expression against a pattern.
void	subst (const match_t &matches)
	Substitute variables into this expression.
ClassName	substCopy (const match_t &matches) const
	Return a copy of this expression with variables substituted.
void	applyRules (const Rules &rules)
	Apply a set of transformation rules to this object.

Static Public Member Functions
static std::string	applyRules (const std::string &name, const Rules &rules)
	Apply a set of transformation rules a class name.

Private Member Functions
void	parse (const std::string &name, std::string::size_type &pos)
	Parse a string into a ClassName.
std::string	parsePrimary (const std::string &name, std::string::size_type &pos)
	Parse a primary part of the class name.
void	parseNamespace (const std::string &name, std::string::size_type &pos)
	Parse a namespace qualification.
void	parseTemplateArgs (const std::string &name, std::string::size_type &pos)
	Parse the template part of a name.
void	skipSpaces (const std::string &name, std::string::size_type &pos)
	Skip past spaces in a string.
bool	match1 (const ClassName &pattern, bool topLevel, match_t &matches) const
	Match this expression against a pattern.
bool	applyRules1 (const Rules &rules)
	Apply a set of transformation rules to this object.

Private Attributes
bool	m_const
	Is this expression const?
std::vector< ClassName >	m_namespace
	The containing namespace.
std::string	m_name
	The primary name part of this expression.
std::vector< ClassName >	m_targs
	The template arguments for this name.

Detailed Description

Recursively separate out template arguments in a C++ class name.

This class allows making some simple transformations of C++ class names. For example, given these rules:

ClassName::Rules rules;
 
 rules.add ("std::vector<$T, std::allocator<$T> >",
            "std::vector<$T>");
 rules.add ("std::map<$K,$V, std::less<$K>, std::allocator<std::pair<const $K,$V> > >",
            "std::map<$K,$V>");
 rules.add ("DataVector<$T, $B>", "DataVector<$T>");
 rules.add ("std::__1", "std");

then rules.apply can make transformations like this:

std::__1::vector<std::__1::vector<int, std::__1::allocator<int> >, std::__1::allocator<std::__1::vector<int, std::__1::allocator<int> > > > 
  -> std::vector<std::vector<int> >
 
std::map<int, float, std::less<int>, std::allocator<std::pair<const int, float> > >
  -> std::map<int, float>
 
DataVector<Foo, DataModel_detail::NoBase>
  -> DataVector<Foo>

In slightly more detail: this class analyzes C++ class names. A name like

A::B<int, double> 

is broken down like this:

• Name: B.
• Namespace: A.
• Template arguments: int and double.

This is done recursively; both the namespace and template argument pieces can be further broken down like this. A name can also be marked as ‘const’, but no other parsing of C-like declarators is done.

Parsed names can be matched against simple patterns like this:

A::B<$T>

and the variable T gets set to the corresponding piece of the type being matched. For example, given the above pattern,

• A::C<int> matches with T set to int.
• A::C<const Foo<Bar> > matches with T set to const Foo<Bar>.

If the pattern were A::B<const $T>, then A::B<const int> would match with T set to int, but A::B<int> would not match.

However, the root name of a pattern may not be a variable; for example, you can't use A::$T<int> as a pattern.

You can also substitute variables back into a pattern; for example,

• T=int into A::B<$T> gives A::B<int>.
• T=const int into A::B<$T> gives A::B<const int>.
• T=const int into A::B<const int> gives A::B<const int>.

Definition at line 100 of file CxxUtils/CxxUtils/ClassName.h.

Member Typedef Documentation

match_t

typedef std::map<std::string, ClassName> CxxUtils::ClassName::match_t

Map used to hold variable assignments from matching.

Definition at line 200 of file CxxUtils/CxxUtils/ClassName.h.

Constructor & Destructor Documentation

ClassName() [1/4]

ClassName< T >::ClassName

(

)

Default constructor.

Needed for STL compatibility.

Definition at line 138 of file CxxUtils/Root/ClassName.cxx.

  : m_const(false)
{
}

ClassName() [2/4]

ClassName< T >::ClassName

(

const char *

name

)

Parse a class name into component parts.

Parameters

name	The name to parse.

Raises a BadClassName exception if the name isn't completely parsed.

Parameters

name	The name to parse.

Raises a ExcBadClassName exception if the name isn't completely parsed.

Definition at line 150 of file CxxUtils/Root/ClassName.cxx.

  : 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() [3/4]

ClassName< T >::ClassName

(

const std::string &

name

)

Parse a class name into component parts.

Parameters

name	The name to parse.

Raises a BadClassName exception if the name isn't completely parsed.

Parameters

name	The name to parse.

Raises a ExcBadClassName exception if the name isn't completely parsed.

Definition at line 168 of file CxxUtils/Root/ClassName.cxx.

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

ClassName() [4/4]

ClassName< T >::ClassName	(	const std::string &	name,
		std::string::size_type &	pos )

Parse a class name into component parts.

Parameters

name	String containing the name to parse.
pos	Position in the string at which parsing should start.

pos is updated to point to past the point where parsing stopped.

Definition at line 186 of file CxxUtils/Root/ClassName.cxx.

  : m_const (false)
{
  parse (name, pos);
}

Member Function Documentation

applyRules() [1/2]

void ClassName< T >::applyRules

(

const Rules &

rules

)

Apply a set of transformation rules to this object.

Parameters

rules

The set of rules to apply.

Recursively walk this expression, trying to apply the transformation rules in rules. If any matches are found, this expression is modified in-place and the walk is repeated. This function terminates when no further matches are found.

Warning: An infinite loop is possible if the replacement for a pattern can always be matched by another pattern.

Definition at line 410 of file CxxUtils/Root/ClassName.cxx.

{
  while (applyRules1 (rules))
    ;
}

applyRules() [2/2]

std::string ClassName< T >::applyRules ( const std::string & name, const Rules & rules )

static

Apply a set of transformation rules a class name.

param The name of the class to transform.

Parameters

rules

The set of rules to apply.

This is just shorthand for

ClassName cn (name);
cn.applyRules (rules);
return cn.fullName();

Definition at line 430 of file CxxUtils/Root/ClassName.cxx.

{
  ClassName cn (name);
  cn.applyRules (rules);
  return cn.fullName();
}

applyRules1()

bool ClassName< T >::applyRules1 ( const Rules & rules )

private

Apply a set of transformation rules to this object.

Parameters

rules

The set of rules to apply.

Recursively walk this expression, trying to apply the transformation rules in rules. If any matches are found, this expression is modified in-place.

Returns true if any matches were found.

Definition at line 674 of file CxxUtils/Root/ClassName.cxx.

{
  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;
}

fullName()

std::string ClassName< T >::fullName

(

)

const

Return the full name of the expression.

Definition at line 252 of file CxxUtils/Root/ClassName.cxx.

{
  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;
}

isConst()

bool ClassName< T >::isConst

(

)

const

Get the const flag for this expression.

Definition at line 209 of file CxxUtils/Root/ClassName.cxx.

{
  return m_const;
}

match()

bool ClassName< T >::match	(	const ClassName &	pattern,
		match_t &	matches ) const

Match this expression against a pattern.

Parameters

	pattern	The pattern to match.
[out]	matches	Dictionary of pattern substitutions.

Return true if pattern matches the current expression. pattern may contain dummy variables of the form $T. On a successful return, the map matches contains the variable assignments needed for the match.

Definition at line 339 of file CxxUtils/Root/ClassName.cxx.

{
  matches.clear();
  return match1 (pattern, true, matches);
}

match1()

bool ClassName< T >::match1 ( const ClassName & pattern, bool topLevel, match_t & matches ) const

private

Match this expression against a pattern.

Parameters

	pattern	The pattern to match.
	topLevel	True if this is the outermost level of matching.
[out]	matches	Dictionary of pattern substitutions.

Return true if pattern matches the current expression. pattern may contain dummy variables of the form $T. On a successful return, the map matches contains the variable assignments needed for the match.

Definition at line 603 of file CxxUtils/Root/ClassName.cxx.

{
  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;
}

name()

const std::string & ClassName< T >::name

(

)

const

Return the root name of the expression.

In A::B<C>, the root name is B.

Definition at line 229 of file CxxUtils/Root/ClassName.cxx.

{
  return m_name;
}

ntargs()

size_t ClassName< T >::ntargs

(

)

const

Return number of template arguments.

Definition at line 275 of file CxxUtils/Root/ClassName.cxx.

{
  return m_targs.size();
}

operator!=()

bool ClassName< T >::operator!=

(

const ClassName &

other

)

const

Test two expressions for inequality.

Definition at line 323 of file CxxUtils/Root/ClassName.cxx.

{
  return !(*this==other);
}

operator==()

bool ClassName< T >::operator==

(

const ClassName &

other

)

const

Test two expressions for equality.

Definition at line 294 of file CxxUtils/Root/ClassName.cxx.

{
  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;
}

parse()

void ClassName< T >::parse ( const std::string & name, std::string::size_type & pos )

private

Parse a string into a ClassName.

Parameters

name	The string containing the name.
pos	Position in the string to start parsing.

On return, pos will be updated to point just past the last character consumed.

Definition at line 447 of file CxxUtils/Root/ClassName.cxx.

{
  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;
  }
}

parseNamespace()

void ClassName< T >::parseNamespace ( const std::string & name, std::string::size_type & pos )

private

Parse a namespace qualification.

Parameters

name	The string containing the name.
pos	Position in the string to start parsing.

When this is called, the namespace part has already been parsed, and the next two characters in name are ::. This reads in the remainder of the string as a ClassName, and then moves it inside the namespace given by the current object.

On return, pos will be updated to point just past the last character consumed.

Definition at line 522 of file CxxUtils/Root/ClassName.cxx.

{
  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));
}

parsePrimary()

std::string ClassName< T >::parsePrimary ( const std::string & name, std::string::size_type & pos )

private

Parse a primary part of the class name.

Parameters

name	The string containing the name.
pos	Position in the string to start parsing.

The primary part of the class name is a string without namespace and template delimiters.

On return, pos will be updated to point just past the last character consumed.

Definition at line 488 of file CxxUtils/Root/ClassName.cxx.

{
  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;
}

parseTemplateArgs()

void ClassName< T >::parseTemplateArgs ( const std::string & name, std::string::size_type & pos )

private

Parse the template part of a name.

Parameters

name	The string containing the name.
pos	Position in the string to start parsing.

When this is called, the qualified name part of the name has already been parsed, and the next character in name is ::. This reads in template arguments from name.

On return, pos will be updated to point just past the last character consumed.

Definition at line 554 of file CxxUtils/Root/ClassName.cxx.

{
  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;
  }
}

qualifiedName()

std::string ClassName< T >::qualifiedName

(

)

const

Return the namespace-qualified name of the expression.

Return the root name of the expression.

In A::B<C>, this is A::B.

In A::B<C>, the root name is B.

Definition at line 240 of file CxxUtils/Root/ClassName.cxx.

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

setConst()

void ClassName< T >::setConst

(

)

Set the const flag for this expression.

Definition at line 218 of file CxxUtils/Root/ClassName.cxx.

{
  m_const = true;
}

skipSpaces()

void ClassName< T >::skipSpaces ( const std::string & name, std::string::size_type & pos )

private

Skip past spaces in a string.

Parameters

name	The string containing the name.
pos	Position in the string to start skipping.

On return, pos will be updated to point just past the last character consumed.

Definition at line 584 of file CxxUtils/Root/ClassName.cxx.

{
  while (pos < name.size() && name[pos] == ' ')
    ++pos;
}

subst()

void ClassName< T >::subst

(

const match_t &

matches

)

Substitute variables into this expression.

Parameters

The	dictionary of variables to substitute.

If this expression contains variables like $T, they are replaced with the corresponding values from matches. If a variable is present in the expression but is not in matches, ExcMissingVariable is thrown.

The substitutions are made in-place.

Definition at line 357 of file CxxUtils/Root/ClassName.cxx.

{
  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);
}

substCopy()

ClassName ClassName< T >::substCopy

(

const match_t &

matches

)

const

Return a copy of this expression with variables substituted.

Parameters

The	dictionary of variables to substitute.

If this expression contains variables like $T, they are replaced with the corresponding values from matches. If a variable is present in the expression but is not in matches, ExcMissingVariable is thrown.

The substitutions are made in a copy of the expression, which is returned.

Definition at line 390 of file CxxUtils/Root/ClassName.cxx.

{
  ClassName cn (*this);
  cn.subst (matches);
  return cn;
}

swap()

void ClassName< T >::swap

(

ClassName &

other

)

Swap this expression with another one.

Parameters

other

The other expression with which to swap.

Definition at line 197 of file CxxUtils/Root/ClassName.cxx.

{
  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);
}

targ()

const ClassName & ClassName< T >::targ

(

size_t

i

)

const

Return one template argument.

Parameters

i	Index of the argument to return.

Definition at line 285 of file CxxUtils/Root/ClassName.cxx.

{
  return m_targs.at (i);
}

Member Data Documentation

m_const

bool CxxUtils::ClassName::m_const

private

Is this expression const?

Definition at line 477 of file CxxUtils/CxxUtils/ClassName.h.

m_name

std::string CxxUtils::ClassName::m_name

private

The primary name part of this expression.

Definition at line 486 of file CxxUtils/CxxUtils/ClassName.h.

m_namespace

std::vector<ClassName> CxxUtils::ClassName::m_namespace

private

The containing namespace.

This vector is always either 0 or 1 elements long; this is a way of getting something sort of like a pointer but with completely automatic management.

Definition at line 483 of file CxxUtils/CxxUtils/ClassName.h.

m_targs

std::vector<ClassName> CxxUtils::ClassName::m_targs

private

The template arguments for this name.

Definition at line 489 of file CxxUtils/CxxUtils/ClassName.h.

---

The documentation for this class was generated from the following files:

• CxxUtils/CxxUtils/ClassName.h
• CxxUtils/Root/ClassName.cxx