inline std::string demangle(const std::type_info & type) { #ifdef __GNUG__ int status; char * realname = abi::__cxa_demangle(type.name(), 0, 0, &status); std::string result(realname); free(realname); return result; #else return std::string("<") + type.name() + std::string(">"); #endif }
bool ContextRead::query(void *ptr, const std::type_info &objType, void *&pObj) { if (type_ptr_obj_ptr_.get() && (*type_ptr_obj_ptr_)[ objType.name() ].find(ptr) != (*type_ptr_obj_ptr_)[ objType.name() ].end() ) { pObj = (*type_ptr_obj_ptr_)[ objType.name() ][ ptr ]; return true; } else { return false; } }
std::string DefTagMetaData::GetTypeName(const std::type_info& typeInfo) { // demangle typename #ifndef _MSC_VER int status; char* ctname = abi::__cxa_demangle(typeInfo.name(), 0, 0, &status); const std::string tname = ctname; free(ctname); #else const std::string tname(typeInfo.name()); // FIXME? #endif return tname; }
void Variant::convert_to(const std::type_info& info, void* p) const { try { TRY_CONVERT_TO(std::string); TRY_CONVERT_TO(long); TRY_CONVERT_TO(bool); TRY_CONVERT_TO(float); TRY_CONVERT_TO(double); TRY_CONVERT_TO(unsigned long); TRY_CONVERT_TO(int); TRY_CONVERT_TO(unsigned int); TRY_CONVERT_TO(char); TRY_CONVERT_TO(unsigned char); TRY_CONVERT_TO(int32_t); TRY_CONVERT_TO(uint32_t); } catch(Poco::SyntaxException& ex) { string msg = "Could not convert variant with typeid "; msg += self->var.type().name(); msg += " to type"; msg += info.name(); msg += "error: "; msg += ex.what(); msg += ", string value: " + self->var.toString(); throw std::logic_error(msg); } string msg = "Could not convert variant with typeid "; msg += self->var.type().name(); msg += " to type"; msg += info.name(); throw invalid_argument(msg); }
bool ContextRead::query(void *ptr, const std::type_info &objType, void *&pObj) { RCF_ASSERT(mEnabled); if (mTypeToObjMap.get() && (*mTypeToObjMap)[ objType.name() ].find(ptr) != (*mTypeToObjMap)[ objType.name() ].end() ) { pObj = (*mTypeToObjMap)[ objType.name() ][ ptr ]; return true; } else { return false; } }
void Adaptor::RegisterSingleton(const std::type_info& info, BaseHandle singleton) { if(singleton) { mSingletonContainer.insert(SingletonPair(info.name(), singleton)); } }
bool TypeRegistry::Register( const std::string& uniqueTypeName, const std::type_info& baseTypeInfo, Dali::TypeInfo::CreateFunction createInstance, bool callCreateOnInit ) { bool ret = false; std::string baseTypeName = DemangleClassName(baseTypeInfo.name()); RegistryMap::iterator iter = mRegistryLut.find(uniqueTypeName); if( iter == mRegistryLut.end() ) { mRegistryLut[uniqueTypeName] = Dali::TypeInfo(new Internal::TypeInfo(uniqueTypeName, baseTypeName, createInstance)); ret = true; DALI_LOG_INFO( gLogFilter, Debug::Concise, "Type Registration %s(%s)\n", uniqueTypeName.c_str(), baseTypeName.c_str()); } else { DALI_LOG_WARNING("Duplicate name for TypeRegistry for '%s'\n", + uniqueTypeName.c_str()); DALI_ASSERT_ALWAYS(!"Duplicate type name for Type Registation"); } if( callCreateOnInit ) { mInitFunctions.push_back(createInstance); } return ret; }
bool TypeRegistry::Register( const std::type_info& theTypeInfo, const std::type_info& baseTypeInfo, Dali::TypeInfo::CreateFunction createInstance, bool callCreateOnInit ) { std::string uniqueTypeName = DemangleClassName(theTypeInfo.name()); return Register( uniqueTypeName, baseTypeInfo, createInstance, callCreateOnInit ); }
void connection::connection_specific_reset(std::type_info const &type, connection_specific_data *ptr) { std::auto_ptr<connection_specific_data> tmp(ptr); if(ptr && typeid(*ptr)!=type) { throw cppdb_error( std::string("cppdb::connection_specific::Inconsistent pointer type") + typeid(*ptr).name() + " and std::type_info reference:" + type.name() ); } for(data::conn_specific_type::iterator p=d->conn_specific.begin();p!=d->conn_specific.end();++p) { if(typeid(**p) == type) { delete *p; if(ptr) *p = tmp.release(); else d->conn_specific.erase(p); return; } } if(ptr) { d->conn_specific.push_back(0); d->conn_specific.back() = tmp.release(); } }
std::string name_of(const std::type_info &ti) { const static std::string typename_notavailable = "N/A"; const char* mangled = ti.name(); if (!mangled) { return typename_notavailable; } int status; char* demangled = abi::__cxa_demangle(mangled, 0, 0, &status); std::string rv; if (status != 0) rv = mangled; else rv = demangled ? demangled : typename_notavailable; std::free(demangled); return rv; }
std::string demangle(const std::type_info& id) { int status; char* unmangled = abi::__cxa_demangle(id.name(), 0, 0, &status); std::string realname = unmangled; free(unmangled); return realname; }
bool Registry::isTypeRegistered(const std::type_info &ti) { ReadLock lock(mReadWriteMutex); RCF_UNUSED_VARIABLE(lock); Rtti typeRtti = ti.name(); return mRttiToTypename.find(typeRtti) != mRttiToTypename.end(); }
[[noreturn]] void JSONProtocolReaderCommon::throwUnrecognizableAsIntegral( folly::StringPiece s, std::type_info const& type) { throw TProtocolException( TProtocolException::INVALID_DATA, folly::to<std::string>(s, " is not a valid ", type.name())); }
void SingletonService::Register( const std::type_info& info, BaseHandle singleton ) { if( singleton ) { mSingletonContainer.insert( SingletonPair( info.name(), singleton ) ); } }
unsigned register_interface(const std::type_info& info) { std::string key = info.name(); unsigned data = ++m_max_key; m_interfaces[key] = data; return data; }
unsigned register_callback(const std::type_info& info, dump_context::dump_callback callback) { std::string key = info.name(); unsigned data = ++m_max_key; m_callbacks[key] = std::make_pair(data,callback); return data; }
/// Decode the template name (removing namespaces and class name) std::string Base::decodeTemplateName(const std::type_info& t) { std::string name = t.name(); const char* realname = NULL; char* allocname = strdup(name.c_str()); #ifdef __GNUC__ int status; realname = allocname = abi::__cxa_demangle(allocname, 0, 0, &status); if (realname==NULL) #endif realname = allocname; int len = strlen(realname); char* newname = (char*)malloc(len+1); newname[0] = '\0'; int start = 0; int dest = 0; int i = 0; char cprev = '\0'; //std::cout << "name = "<<realname<<std::endl; while (i < len && realname[i]!='<') ++i; start = i+1; ++i; for (; i<len; i++) { char c = realname[i]; //if (c == '<') break; if (c == ':') // && cprev == ':') { start = i+1; } else if (c == ' ' && i >= 5 && realname[i-5] == 'c' && realname[i-4] == 'l' && realname[i-3] == 'a' && realname[i-2] == 's' && realname[i-1] == 's') { start = i+1; } else if (c != ':' && c != '_' && (c < 'a' || c > 'z') && (c < 'A' || c > 'Z')) { // write result while (start <= i) { newname[dest++] = realname[start++]; newname[dest] = 0; } } cprev = c; //std::cout << "i = "<<i<<" start = "<<start<<" dest = "<<dest<<" newname = "<<newname<<std::endl; } while (start < i) { newname[dest++] = realname[start++]; newname[dest] = 0; } newname[dest] = '\0'; //std::cout << "newname = "<<newname<<std::endl; name = newname; free(newname); //if (allocname) // free(allocname); return name; }
dump_context::callback_data lookup_callback(const std::type_info& info) const { std::string key = info.name(); callback_map::const_iterator found = m_callbacks.find(key); if (found == m_callbacks.end()) throw persistent_illegal_type(key); return found->second; }
void SignalCaster::unregisterCast (const std::type_info& type) { size_t n = functions_.erase(type.name ()); if (0 == n) // erase did not find element // TODO: throw Cast not registered exception throw ExceptionSignal(ExceptionSignal::GENERIC); }
unsigned lookup_interface(const std::type_info& info) const { std::string key = info.name(); interface_map::const_iterator found = m_interfaces.find(key); if (found == m_interfaces.end()) throw persistent_illegal_type(key); return found->second; }
void ContextRead::add(void *ptr, const std::type_info &objType, void *pObj) { RCF_ASSERT(bEnabled_); if (type_ptr_obj_ptr_.get() == NULL) { type_ptr_obj_ptr_.reset( new std::map<std::string, std::map< void *, void * > >() ); } (*type_ptr_obj_ptr_)[ objType.name() ][ ptr ] = pObj; }
bool table::is_column(const std::string& column_name, const std::type_info& type) const { assert(has_column(column_name)); const auto& c = m_columns.at(column_name); assert(c->type_hash()); return (*c->type_hash()) == type.hash_code(); }
void ContextRead::add(void *ptr, const std::type_info &objType, void *pObj) { RCF_ASSERT(mEnabled); if (mTypeToObjMap.get() == NULL) { mTypeToObjMap.reset( new std::map<std::string, std::map< void *, void * > >() ); } (*mTypeToObjMap)[ objType.name() ][ ptr ] = pObj; }
void Adaptor::RegisterSingleton(const std::type_info& info, Dali::BaseHandle singleton) { mToolkitAdaptor.mFunctionsCalled.RegisterSingleton = true; if(singleton) { mSingletonContainer.insert(SingletonPair(info.name(), singleton)); } }
Type::Type(const std::type_info& typeInfo) { int iStatus; char* sRealName = abi::__cxa_demangle(typeInfo.name(), 0, 0, &iStatus); msName = sRealName; msFullName = sRealName; free(sRealName); }
std::string typestr(std::type_info const& info) { std::size_t n = 0; char* buf = abi::__cxa_demangle(info.name(), nullptr, &n, 0); std::string result(buf, n); std::free(buf); return result; }
/** * @return The demangled (human readable) version of the name() string for std::type_info */ inline std::string demangleTypeInfo(const std::type_info& aTypeInfo) { int status; char* realname; realname = abi::__cxa_demangle(aTypeInfo.name(), 0, 0, &status); std::string result(realname); std::free(realname); return result; }
inline type_info::type_info(std::type_info const& id) : m_base_type( # ifdef BOOST_PYTHON_TYPE_ID_NAME id.name() # else &id # endif ) { }
std::string BaseClass::decodeTypeName(const std::type_info& type) { std::string name; #ifdef __GNUC__ int status; char* allocname = abi::__cxa_demangle(type.name(), 0, 0, &status); if(allocname) name = allocname; else std::cerr << "Unable to demangle symbol: " << type.name() << std::endl; #else name = type.name(); #endif helper::replaceAll<std::string>(name, "class ", ""); helper::replaceAll<std::string>(name, "struct ", ""); helper::replaceAll<std::string>(name, " ", ""); return name; }
virtual std::size_t calc_hash() const { std::size_t seed = 0; boost::hash_combine(seed, obj_is_const); boost::hash_combine(seed, ptr_is_const); boost::hash_combine(seed, is_ref); boost::hash_combine(seed, is_ptr); boost::hash_combine(seed, std::string(info->name())); return seed; }