C++ Hits::end方法代码示例

list<int> *Searcher::search(list<string> &terms, list<int> &res) {
  int ndocs = getDocs();
  vector<double> A(ndocs + 1);
  
  list<int> numhits;
  BOOST_FOREACH(string &term, terms) {
    
    Hits hits = getHits(term);
    int ft = hits.size();
    
    if(hits.size() == 0)
      continue;

    Hits::iterator ai;
    for(ai = hits.begin(); ai != hits.end(); ++ai) {
      Node &anode = *ai;
      int doc = anode.doc;

      double wdt = getWdt(anode.freq, getWd()[doc]);
      double wqt = getWqt(ndocs, ft);	
      
      A[doc] += wdt * wqt;
    }

    hits.free();
  }

ShipBattle::Hits ShipBattle::AutoAssignHits(const Dice& dice, const Game& game) const
{
	Hits hits;

	Dice remainingDice = dice;

	std::map<int, std::set<int>> destroyedShips; // group index, ship indices.

	// Try to destroy ships (biggest type and most damaged ship first.) 
	std::vector<int> groupIndices = GetTargetGroupIndicesBiggestFirst();
	for (int groupIndex : groupIndices)
	{
		if (remainingDice.empty())
			break;

		const Group& group = m_groups[groupIndex];
		int toHit = GetToHitRoll(group.shipType, game);

		Hits groupHits = GetHitsToDestroy(group, remainingDice, toHit);
		hits.insert(hits.begin(), groupHits.begin(), groupHits.end());

		// Remember destroyed ships so we don't try to damage them. 
		for (auto& hit : groupHits)
			destroyedShips[groupIndex].insert(hit.shipIndex);
	}

	// Try to damage remaining ships. Only need to consider the weakest ship of each group. 
	for (int groupIndex : groupIndices)
	{
		if (remainingDice.empty())
			break;

		const Group& group = m_groups[groupIndex];
		const auto shipIndices = GetShipIndicesWeakestFirst(group);

		// Check if the whole group has been destroyed. 
		// We can't just check if shipIndices is empty, because the damamge hasn't been applied yet. 
		if (destroyedShips[groupIndex].size() == shipIndices.size())
			continue;

		int toHit = GetToHitRoll(group.shipType, game);

		for (int shipIndex : shipIndices)
		{
			if (destroyedShips[groupIndex].count(shipIndex) == 0) // Still alive.
			{
				Dice used = remainingDice.RemoveAll(toHit);
				if (!used.empty())
					hits.push_back(Hit(group.shipType, shipIndex, used));

				break; // No point checking healthier ships. 
			}
		}
	}

	return hits;
}

bool
Picker::getObjectIDs(const Hits& results, std::set<ObjectID>& out_objectIDs) const
{
    ObjectIndex* index = Registry::objectIndex();

    for(Hits::const_iterator hit = results.begin(); hit != results.end(); ++hit)
    {
        bool found = false;

        // check for the uniform.
        const osg::NodePath& path = hit->nodePath;
        for(osg::NodePath::const_reverse_iterator n = path.rbegin(); n != path.rend(); ++n )
        {
            osg::Node* node = *n;
            if ( node && node->getStateSet() )
            {
                osg::Uniform* u = node->getStateSet()->getUniform( index->getObjectIDUniformName() );
                if ( u )
                {
                    ObjectID oid;
                    if ( u->get(oid) )
                    {
                        out_objectIDs.insert( oid );
                        found = true;
                    }
                }
            }
        }

        if ( !found )
        {
            // check the geometry.
            const osg::Geometry* geom = hit->drawable ? hit->drawable->asGeometry() : 0L;
            if ( geom )
            {
                const ObjectIDArray* ids = dynamic_cast<const ObjectIDArray*>( geom->getVertexAttribArray(index->getObjectIDAttribLocation()) );
                if ( ids )
                {
                    for(unsigned i=0; i < hit->indexList.size(); ++i)
                    {
                        unsigned index = hit->indexList[i];
                        if ( index < ids->size() )
                        {
                            ObjectID oid = (*ids)[index];
                            out_objectIDs.insert( oid );
                        }
                    }
                }
            }
        }
    }

    return !out_objectIDs.empty();
}