自学教程：C++ typeId函数代码示例

void QmlProfilerRangeModel::findBindingLoops(){    typedef QPair<int, int> CallStackEntry;    QStack<CallStackEntry> callStack;    for (int i = 0; i < count(); ++i) {        int potentialParent = callStack.isEmpty() ? -1 : callStack.top().second;        while (potentialParent != -1 && !(endTime(potentialParent) > startTime(i))) {            callStack.pop();            potentialParent = callStack.isEmpty() ? -1 : callStack.top().second;        }        // check whether event is already in stack        for (int ii = 0; ii < callStack.size(); ++ii) {            if (callStack.at(ii).first == typeId(i)) {                m_data[i].bindingLoopHead = callStack.at(ii).second;                break;            }        }        CallStackEntry newEntry(typeId(i), i);        callStack.push(newEntry);    }}

	XMLNode Entity::save(XMLNode &parent) const {		XMLNode node = parent.addChild(toString(typeId()));		node.addAttrib("pos", m_pos);		if(m_dir_angle != 0.0f)			node.addAttrib("angle", m_dir_angle);		return node;	}

int item::volume(){ if (typeId() == itm_corpse) {  switch (corpse->size) {   case MS_TINY:   return   2;   case MS_SMALL:  return  40;   case MS_MEDIUM: return  75;   case MS_LARGE:  return 160;   case MS_HUGE:   return 600;  } } if( is_null() )  return 0; int ret = type->volume;  if (count_by_charges()) { ret *= charges; ret /= 100; }   if (is_gun()) {  for (int i = 0; i < contents.size(); i++)   ret += contents[i].volume(); }   return ret;}

std::string item::save_info(){ if (type == NULL)  debugmsg("Tried to save an item with NULL type!"); int ammotmp = 0;/* TODO: This causes a segfault sometimes, even though we check to make sure * curammo isn't NULL.  The crashes seem to occur most frequently when saving an * NPC, or when saving map data containing an item an NPC has dropped. */ if (curammo != NULL)  ammotmp = curammo->id; if (ammotmp < 0 || ammotmp > num_items)  ammotmp = 0; // Saves us from some bugs std::stringstream dump;// (std::stringstream::in | std::stringstream::out); dump << " " << int(invlet) << " " << int(typeId()) << " " <<  int(charges) <<         " " << int(damage) << " " << int(burnt) << " " << poison << " " <<         ammotmp << " " << owned << " " << int(bday); if (active)  dump << " 1"; else  dump << " 0"; if (corpse != NULL)  dump << " " << corpse->id; else  dump << " -1"; dump << " " << mission_id << " " << player_id; size_t pos = name.find_first_of("/n"); while (pos != std::string::npos)  {  name.replace(pos, 1, "@@");  pos = name.find_first_of("/n"); } dump << " '" << name << "'"; return dump.str();}

 void ValueType<T>::read(const byte* buf, long len, ByteOrder byteOrder) {     value_.clear();     for (long i = 0; i < len; i += TypeInfo::typeSize(typeId())) {         value_.push_back(getValue<T>(buf + i, byteOrder));     } }

void NotesModel::update(int index, const QString &text){    Note &note = m_data[index];    if (text != note.text) {        note.text = text;        emit changed(typeId(index), note.timelineModel, note.timelineIndex);    }}

bool ToolChain::operator == (const ToolChain &tc) const{    if (this == &tc)        return true;    // We ignore displayname    return typeId() == tc.typeId() && isAutoDetected() == tc.isAutoDetected();}

nc_color item::color(){ if (typeId() == itm_corpse)  return corpse->color; if( is_null() )  return c_black; return type->color;}

void vehicle::turret_reload( vehicle_part &pt ){    item &gun = pt.base;    if( !gun.is_gun() || gun.ammo_type() == "NULL" ) {        return;    }    // try to reload using stored fuel from onboard vehicle tanks    for( const auto &e : fuels_left() ) {        const itype *fuel = item::find_type( e.first );        if( !fuel->ammo || e.second < gun.ammo_required() ) {            continue;        }        if( ( gun.ammo_current() == "null" && fuel->ammo->type == gun.ammo_type() ) ||            ( gun.ammo_current() == e.first ) ) {            int qty = gun.ammo_remaining();            gun.ammo_set( e.first, e.second );            drain( e.first, gun.ammo_remaining() - qty );            return;        }    }    // otherwise try to reload from turret cargo space    for( auto it = pt.items.begin(); it != pt.items.end(); ++it ) {        if( it->is_ammo() &&            ( ( gun.ammo_current() == "null" && it->ammo_type() == gun.ammo_type() ) ||              ( gun.ammo_current() == it->typeId() ) ) ) {            int qty = gun.ammo_remaining();            gun.ammo_set( it->typeId(), it->charges );            it->charges -= gun.ammo_remaining() - qty;            if( it->charges <= 0 ) {                pt.items.erase( it );            }            return;        }    }}

QVariantList NotesModel::byTypeId(int selectedType) const{    QVariantList ret;    for (int noteId = 0; noteId < count(); ++noteId) {        if (selectedType == typeId(noteId))            ret << noteId;    }    return ret;}

const MessageType *MessageTypePool::type(const std::string &typeName) const{    const Id id = typeId(typeName);    if (id == npos) {        return nullptr;    } else {        return type(id);    }}

void NotesModel::remove(int index){    Note &note = m_data[index];    int noteType = typeId(index);    int timelineModel = note.timelineModel;    int timelineIndex = note.timelineIndex;    m_data.removeAt(index);    emit changed(noteType, timelineModel, timelineIndex);}

void NodeMetadata::serialize(std::ostream &os){	u8 buf[2];	writeU16(buf, typeId());	os.write((char*)buf, 2);	std::ostringstream oss(std::ios_base::binary);	serializeBody(oss);	os<<serializeString(oss.str());}

bool item::made_of(material mat){ if( is_null() )  return false; if (typeId() == itm_corpse)  return (corpse->mat == mat); return (type->m1 == mat || type->m2 == mat);}

    void CloudReconnectWorker::processNotification( AbsOptCloudClientWorker::TypeId tId, const AbsOptCloudClientWorker::BufferType& data )    {      LOG_Debug(core, "Process event message type notification ...");      IUccSessionListener::TypeId typeId(tId);      // Here we need to verify if the notification correspond to uccReconnectRequest.      if( typeId == gvr::communication::ucc::UccMessageCloudReconnect::GetTypeId() )      {        doReconnect(data);      }    }

void QmlProfilerRangeModel::computeExpandedLevels(){    QHash<int, int> eventRow;    int eventCount = count();    for (int i = 0; i < eventCount; i++) {        int eventTypeId = typeId(i);        if (!eventRow.contains(eventTypeId)) {            eventRow[eventTypeId] = m_expandedRowTypes.size();            m_expandedRowTypes << eventTypeId;        }        m_data[i].displayRowExpanded = eventRow[eventTypeId];    }    setExpandedRowCount(m_expandedRowTypes.size());}

int item::weight(){ if (typeId() == itm_corpse) {  int ret;  switch (corpse->size) {   case MS_TINY:   ret =    5;	break;   case MS_SMALL:  ret =   60;	break;   case MS_MEDIUM: ret =  520;	break;   case MS_LARGE:  ret = 2000;	break;   case MS_HUGE:   ret = 4000;	break;  }  if (made_of(VEGGY))   ret /= 10;  else if (made_of(IRON) || made_of(STEEL) || made_of(STONE))   ret *= 5;  return ret; } if( is_null() )  return 0; int ret = type->weight; if (count_by_charges() && !made_of(LIQUID)) { ret *= charges; ret /= 100; } for (int i = 0; i < contents.size(); i++)  if (contents[i].made_of(LIQUID))  {    if (contents[i].type->is_food())       {        it_comest* tmp_comest = dynamic_cast<it_comest*>(contents[i].type);        ret += contents[i].weight() * (contents[i].charges / tmp_comest->charges);      }          else if (contents[i].type->is_ammo())      {        it_ammo* tmp_ammo = dynamic_cast<it_ammo*>(contents[i].type);        ret += contents[i].weight() * (contents[i].charges / tmp_ammo->count);          }      else        ret += contents[i].weight();  }  else  ret += contents[i].weight();   return ret;}

FurnaceNodeMetadata::FurnaceNodeMetadata(IGameDef *gamedef):	NodeMetadata(gamedef){	NodeMetadata::registerType(typeId(), typeName(), create, create);		m_inventory = NULL;	m_infotext = "Furnace is inactive";	m_step_accumulator = 0;	m_fuel_totaltime = 0;	m_fuel_time = 0;	m_src_totaltime = 0;	m_src_time = 0;}

//==============================================================================bool ContextDefinitionManager::deserializeDefinitions(ISerializer& serializer){	// load generic definitions	size_t count = 0;	serializer.deserialize(count);	for (size_t i = 0; i < count; i++)	{		std::string defName;		serializer.deserialize(defName);		std::string parentDefName;		serializer.deserialize(parentDefName);		auto pDef = getDefinition(defName.c_str());		IClassDefinitionModifier* modifier = nullptr;		if (!pDef)		{			auto definition = registerDefinition(createGenericDefinition(defName.c_str()));			modifier = definition->getDetails().getDefinitionModifier();		}		size_t size = 0;		serializer.deserialize(size);		std::string propName;		std::string typeName;		uint32_t flags;		for (size_t j = 0; j < size; j++)		{			propName.clear();			typeName.clear();			serializer.deserialize(propName);			serializer.deserialize(typeName);			serializer.deserialize(flags);			IBasePropertyPtr property = nullptr;			auto metaType = MetaType::find(typeName.c_str());			if (modifier)			{				bool isCollection = flags & ContextDefinitionManagerDetails::IS_COLLECTION;				auto property = modifier->addProperty(				propName.c_str(), metaType != nullptr ? metaType->typeId().getName() : typeName.c_str(), nullptr,				isCollection);				// TF_ASSERT( property );			}		}	}	return true;}

	GenericNodeMetadata(IGameDef *gamedef):		NodeMetadata(gamedef),		m_inventory(NULL),		m_text(""),		m_owner(""),		m_infotext("GenericNodeMetadata"),		m_inventorydrawspec(""),		m_allow_text_input(false),		m_removal_disabled(false),		m_enforce_owner(false),		m_inventory_modified(false),		m_text_modified(false)	{		NodeMetadata::registerType(typeId(), typeName(), create, create);	}

QVariantMap QmlProfilerTimelineModel::locationFromTypeId(int index) const{    QVariantMap result;    int id = typeId(index);    if (id < 0)        return result;    auto types = modelManager()->qmlModel()->eventTypes();    if (id >= types.length())        return result;    QmlEventLocation location = types.at(id).location();    result.insert(QStringLiteral("file"), location.filename());    result.insert(QStringLiteral("line"), location.line());    result.insert(QStringLiteral("column"), location.column());    return result;}

bool item::is_food(player *u) const{ if (!u)  return is_food(); if( is_null() )  return false; if (type->is_food())  return true; if (u->has_bionic("bio_batteries") && is_ammo() &&     (dynamic_cast<it_ammo*>(type))->type == AT_BATT)  return true; if (u->has_bionic("bio_furnace") && is_flammable(type->m1) &&     is_flammable(type->m2) && typeId() != "corpse")  return true; return false;}

/** * Returns the value of the property /a name, taking into account that it may * be inherited from another object or from the type. * * - A Tile instance can inherit properties based on its type * - A MapObject instance can inherit properties based on: *      - Its template object *      - Its tile *      - Its type (or the type of its tile) */QVariant Object::inheritedProperty(const QString &name) const{    if (hasProperty(name))        return property(name);    QString objectType;    switch (typeId()) {    case MapObjectType: {        auto mapObject = static_cast<const MapObject*>(this);        objectType = mapObject->type();        if (const MapObject *templateObject = mapObject->templateObject())            if (templateObject->hasProperty(name))                return templateObject->property(name);        if (Tile *tile = mapObject->cell().tile()) {            if (tile->hasProperty(name))                return tile->property(name);            if (objectType.isEmpty())                objectType = tile->type();        }        break;    }    case TileType:        objectType = static_cast<const Tile*>(this)->type();        break;    default:        return QVariant();    }    if (!objectType.isEmpty()) {        for (const ObjectType &type : qAsConst(mObjectTypes)) {            if (type.name == objectType)                if (type.defaultProperties.contains(name))                    return type.defaultProperties.value(name);        }    }    return QVariant();}

bool item::is_food(player *u){ if (u == NULL)  return is_food(); if( is_null() )  return false; if (type->is_food())  return true; if (u->has_bionic(bio_batteries) && is_ammo() &&     (dynamic_cast<it_ammo*>(type))->type == AT_BATT)  return true; if (u->has_bionic(bio_furnace) && is_flammable(type->m1) &&     is_flammable(type->m2) && typeId() != itm_corpse)  return true; return false;}

std::string item::save_info(){ if (type == NULL){  debugmsg("Tried to save an item with NULL type!"); } itype_id ammotmp = "null";/* TODO: This causes a segfault sometimes, even though we check to make sure * curammo isn't NULL.  The crashes seem to occur most frequently when saving an * NPC, or when saving map data containing an item an NPC has dropped. */ if (curammo != NULL){  ammotmp = curammo->id; } if( std::find(unreal_itype_ids.begin(), unreal_itype_ids.end(),     ammotmp) != unreal_itype_ids.end()  &&     std::find(artifact_itype_ids.begin(), artifact_itype_ids.end(),     ammotmp) != artifact_itype_ids.end()     ) {  ammotmp = "null"; //Saves us from some bugs, apparently? } std::stringstream dump; dump << " " << int(invlet) << " " << typeId() << " " <<  int(charges) <<         " " << int(damage) << " " << int(item_flags) << " " << int(burnt) <<         " " << poison << " " << ammotmp << " " << owned << " " << int(bday); if (active)  dump << " 1"; else  dump << " 0"; if (corpse != NULL)  dump << " " << corpse->id; else  dump << " -1"; dump << " " << mission_id << " " << player_id; size_t pos = name.find_first_of("/n"); while (pos != std::string::npos)  {  name.replace(pos, 1, "@@");  pos = name.find_first_of("/n"); } dump << " '" << name << "'"; return dump.str();}

bool VariantStreamHandler::read(Variant& v, const NodePtr& node, const char* typeName){	// Check that we've been given a valid Variant	if (v.isVoid() || v.type() == nullptr)	{		return false;	}	auto variantTypeName = this->getReservedNames().variantInternalType;	std::string typeData = node->getChildNode(variantTypeName, strlen(variantTypeName))->getValueString();	TypeId typeId(typeData.c_str());	// Check that the types match	if (strcmp(v.type()->typeId().getName(), typeId.getName()) != 0)	{		return false;	}	ResizingMemoryStream rs(node->getValueString());	TextStream ts(rs);	ts >> v;	return true;}

 //! Return the size in bytes of one component of this type long typeSize() const { return TypeInfo::typeSize(typeId()); }

 //! Return the name of the type const char* typeName() const { return TypeInfo::typeName(typeId()); }