CxxUtils/CxxUtils/ClassName.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
 
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#ifndef CXXUTILS_CLASSNAME_H
#define CXXUTILS_CLASSNAME_H
 
 
#include <string>
#include <vector>
#include <map>
#include <stdexcept>
 
 
namespace CxxUtils {
 
 
class ClassName
{
public:
 
  class ExcBadClassName
    : public std::runtime_error
  {
  public:
    ExcBadClassName (const std::string& name);
  };
 
 
  class ExcMissingVariable
    : public std::runtime_error
  {
  public:
    ExcMissingVariable (const std::string& var);
  };
 
 
  class Rules
  {
  public:
    size_t size() const;
 
 
    void add (const ClassName& pattern, const ClassName& replacement);
 
 
    void add (ClassName&& pattern, ClassName&& replacement);
 
 
    bool applyTo (ClassName& cn) const;
 
 
    std::string apply (const std::string& name) const;
 
 
  private:
    typedef std::pair<ClassName, ClassName> pat_repl_t;
 
    typedef std::multimap<std::string, pat_repl_t> rulemap_t;
    rulemap_t m_rules;
  };
 
 
  typedef std::map<std::string, ClassName> match_t;
 
 
  ClassName ();
 
 
  ClassName (const char* name);
 
 
  ClassName (const std::string& name);
 
 
  ClassName (const std::string& name, std::string::size_type& pos);
 
 
  void swap (ClassName& other);
 
 
  bool isConst() const;
 
 
  void setConst();
 
 
  const std::string& name() const;
 
  
  std::string qualifiedName() const;
 
 
  std::string fullName() const;
 
 
  size_t ntargs() const;
 
 
  const ClassName& targ (size_t i) const;
 
 
  bool operator== (const ClassName& other) const;
 
 
  bool operator!= (const ClassName& other) const;
 
 
  bool match (const ClassName& pattern, match_t& matches) const;
 
 
  void subst (const match_t& matches);
 
 
  ClassName substCopy (const match_t& matches) const;
 
 
  void applyRules (const Rules& rules);
 
 
  static std::string applyRules (const std::string& name,
                                 const Rules& rules);
 
 
private:
  void parse (const std::string& name, std::string::size_type& pos);
 
 
  std::string parsePrimary (const std::string& name,
                            std::string::size_type& pos);
 
 
  void parseNamespace (const std::string& name, std::string::size_type& pos);
 
 
  void parseTemplateArgs (const std::string& name, std::string::size_type& pos);
 
 
  void skipSpaces (const std::string& name, std::string::size_type& pos);
 
 
  bool match1 (const ClassName& pattern,
               bool topLevel,
               match_t& matches) const;
 
 
  bool applyRules1 (const Rules& rules);
 
 
  bool m_const;
 
  std::vector<ClassName> m_namespace;
 
  std::string m_name;
 
  std::vector<ClassName> m_targs;
};
 
 
} // namespace CxxUtils
 
 
#endif // not CXXUTILS_CLASSNAME_H