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