ROOT logo
ROOT » CINT » REFLEX » Reflex::Tools

namespace Reflex::Tools

Function Members (Methods)

public:
stringBuildTypeName(Reflex::Type& t, unsigned int modifiers)
stringDemangle(const type_info& ti)
Reflex::EFUNDAMENTALTYPEFundamentalType(const Reflex::Type& typ)
vector<std::string>GenTemplateArgVec(const string& name)
stringGetBaseName(const string& name, bool startFromLeft = false)
size_tGetBasePosition(const string& name)
size_tGetFirstScopePosition(const string& name, size_t& start)
stringGetScopeName(const string& name, bool startFromLeft = false)
stringGetTemplateArguments(const char* name)
voidGetTemplateComponents(const string& Name, string& templatename, vector<std::string>& args)
stringGetTemplateName(const char* name)
boolIsTemplated(const char* name)
stringNormalizeName(const string& name)
stringNormalizeName(const char* name)
voidStringSplit(vector<std::string>& splitValues, const string& str, const string& delim = ",")
voidStringSplitPair(string& val1, string& val2, const string& str, const string& delim = ",")
voidStringStrip(string& str)
stringStringVec2String(const vector<std::string>& vec)

Class Charts

Function documentation

RFLX_API EFUNDAMENTALTYPE FundamentalType(const Reflex::Type& typ)
 * GetFundamentalType will return an enum representing the
 * fundamental type which was passed in, or NOFUNDAMENTALTYPE
 * @param typ the type passed into the system
 * @return enum representing kind of fundamental type

RFLX_API std::string Demangle(const type_info& ti)
 * Demangle will call the internal demangling routines and
 * return the demangled string of a At
 * @param ti the mangled At string
 * @return the demangled string

RFLX_API void StringSplit(vector<std::string>& splitValues, const string& str, const string& delim = ",")
 * StringSplit will return a vector of splitted strings
 * @param  splitValues returns the vector with splitted strings
 * @param  str the input string
 * @param  delim the delimiter on which to split

RFLX_API void StringStrip(string& str)
 * StringSplitPair will return two values which are split
 * @param  val1 returns the first value
 * @param  val2 returns the second value
 * @param  str the string to be split
 * @param  delim the delimiter on which to split


 * StringStrip will strip off Empty spaces of a string
 * @param str a reference to a string to be stripped

RFLX_API std::string StringVec2String(const vector<std::string>& vec)
 * StringVec2String will take a vector of strings and return the
 * vector containees concatenated by commas
 * @param vec the vector to be converted
 * @return string of comma concatenated containees

RFLX_API std::string BuildTypeName(Reflex::Type& t, unsigned int modifiers)
RFLX_API void GetTemplateComponents(const string& Name, string& templatename, vector<std::string>& args)
 * GetTemplateComponents extract from 'Name' a template name and a vector containing its argument.
 *

RFLX_API size_t GetFirstScopePosition(const string& name, size_t& start)
 * GetBasePosition will return the position in a
 * string where the unscoped At begins

RFLX_API std::string GetScopeName(const string& name, bool startFromLeft = false)
 * Get the At part of a given At/member Name

RFLX_API bool IsTemplated(const char* name)
 * Get the BaseAt (unscoped) Name of a At/member Name


 * IsTemplated returns true if the At (class) is templated
 * @param Name the At Name
 * @return true if At is templated

RFLX_API std::string GetTemplateArguments(const char* name)
 * templateArguments returns a string containing the template arguments
 * of a templated At (including outer angular brackets)
 * @param Name the Name of the templated At
 * @return template arguments of the templated At

RFLX_API std::string GetTemplateName(const char* name)
 * GetTemplateName returns the Name of the template At (without arguments)
 * @param Name the Name of the template At
 * @return template Name

RFLX_API std::string NormalizeName(const std::string& name)
RFLX_API std::string NormalizeName(const char* name)