namespace Reflex::Tools

Function Members (Methods)

public:

string	BuildTypeName(Reflex::Type& t, unsigned int modifiers)
string	Demangle(const type_info& ti)
Reflex::EFUNDAMENTALTYPE	FundamentalType(const Reflex::Type& typ)
vector<std::string>	GenTemplateArgVec(const string& name)
string	GetBaseName(const string& name, bool startFromLeft = false)
size_t	GetBasePosition(const string& name)
size_t	GetFirstScopePosition(const string& name)
string	GetScopeName(const string& name, bool startFromLeft = false)
string	GetTemplateArguments(const char* name)
void	GetTemplateComponents(const string& Name, string& templatename, vector<std::string>& args)
string	GetTemplateName(const char* name)
bool	IsTemplated(const char* name)
string	NormalizeName(const string& name)
string	NormalizeName(const char* name)
void	StringSplit(vector<std::string>& splitValues, const string& str, const string& delim = ",")
void	StringSplitPair(string& val1, string& val2, const string& str, const string& delim = ",")
void	StringStrip(string& str)
string	StringVec2String(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(std::vector < std:: string > & splitValues, const std::string & str, const std::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)

      * 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 GetBasePosition(const string& name)

      * getUnscopedPosition will return the position in a
      * string where the unscoped At begins

RFLX_API size_t GetFirstScopePosition(const string& name)

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)

      * 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 )