C++ list::swap方法代码示例

void heuristic_search(const cholmod_sparse* const NNE,
                      std::list<int>& ordering,
                      std::list<int>& MIS) {

  std::list<int> tempMIS;

  size_t to_check = static_cast<size_t>(std::sqrt(static_cast<long double>(NNE->ncol))) + 10000;
  if (to_check > NNE->ncol) {
    to_check = NNE->ncol;
  }

  // 1,2,3,4,5
  // 2,1,3,4,5
  // 1,3,2,4,5
  // 3,2,4,1,5
  // 2,4,1,5,3
  // etc...

  std::list<int>::iterator insert_position = ordering.begin();
  for (size_t i = 0; i < to_check; ++i) {
    ++insert_position;
    ordering.insert(insert_position, ordering.front());
    ordering.pop_front();

    findMIS_in_sp_order(NNE, ordering, tempMIS);

    if (tempMIS.size() > MIS.size()) {
      MIS.swap(tempMIS);
    }
    tempMIS.clear();
  }
}

  bool BaseConnection::GetMessages(std::list<IncomingMessage::sptr>& messages) {
    if (state_ != STATE_CONNECTED || incoming_.empty()) {
      return false;
    }

    messages.swap(incoming_);
    return true;
  }

void fpathSetBlockingMap(PATHJOB *psJob)
{
	if (fpathCurrentGameTime != gameTime)
	{
		// New tick, remove maps which are no longer needed.
		fpathCurrentGameTime = gameTime;
		fpathPrevBlockingMaps.swap(fpathBlockingMaps);
		fpathBlockingMaps.clear();
	}

	// Figure out which map we are looking for.
	PathBlockingType type;
	type.gameTime = gameTime;
	type.propulsion = psJob->propulsion;
	type.owner = psJob->owner;
	type.moveType = psJob->moveType;

	// Find the map.
	std::list<PathBlockingMap>::iterator i = std::find(fpathBlockingMaps.begin(), fpathBlockingMaps.end(), type);
	if (i == fpathBlockingMaps.end())
	{
		// Didn't find the map, so i does not point to a map.
		fpathBlockingMaps.push_back(PathBlockingMap());
		--i;

		// i now points to an empty map with no data. Fill the map.
		i->type = type;
		std::vector<bool> &map = i->map;
		map.resize(mapWidth*mapHeight);
		uint32_t checksumMap = 0, checksumDangerMap = 0, factor = 0;
		for (int y = 0; y < mapHeight; ++y)
			for (int x = 0; x < mapWidth; ++x)
		{
			map[x + y*mapWidth] = fpathBaseBlockingTile(x, y, type.propulsion, type.owner, type.moveType);
			checksumMap ^= map[x + y*mapWidth]*(factor = 3*factor + 1);
		}
		if (!isHumanPlayer(type.owner) && type.moveType == FMT_MOVE)
		{
			std::vector<bool> &dangerMap = i->dangerMap;
			dangerMap.resize(mapWidth*mapHeight);
			for (int y = 0; y < mapHeight; ++y)
				for (int x = 0; x < mapWidth; ++x)
			{
				dangerMap[x + y*mapWidth] = auxTile(x, y, type.owner) & AUXBITS_THREAT;
				checksumDangerMap ^= map[x + y*mapWidth]*(factor = 3*factor + 1);
			}
		}
		syncDebug("blockingMap(%d,%d,%d,%d) = %08X %08X", gameTime, psJob->propulsion, psJob->owner, psJob->moveType, checksumMap, checksumDangerMap);
	}
	else
	{
		syncDebug("blockingMap(%d,%d,%d,%d) = cached", gameTime, psJob->propulsion, psJob->owner, psJob->moveType);
	}

	// i now points to the correct map. Make psJob->blockingMap point to it.
	psJob->blockingMap = &*i;
}

void UnionOfBallsView::subdiv_circle(const Weighted_point &wp, std::list<Segment> &segments, int subdiv)
{
    if (wp.weight() > 0) {
        for (int i=0; i<subdiv; ++i) {
            std::list<Segment> segments2;
            BOOST_FOREACH(Segment &s, segments) {
                Bare_point m = CGAL::midpoint(s[0], s[1]);
                Vector v = m-wp;
                m = wp + sqrt(wp.weight()/v.squared_length()) * v;
                segments2.push_back(Segment(s[0], m));
                segments2.push_back(Segment(m, s[1]));
            }
            segments.swap(segments2);
        }
    }

inline void ThreadPool::RemoveStopedThreads()
{
    std::list<TaskThread*> tmp;
    for (std::list<TaskThread*>::iterator i = stopThreads.begin();
         i != stopThreads.end(); ++i)
    {
        if ((*i)->IsAlive())
        {
            tmp.push_back(*i);
        }
        else
        {
            delete *i;
        }
    }
    stopThreads.swap(tmp);
}

            void FilterTargets(std::list<WorldObject*>& targets)
            {
                targets.sort(Trinity::ObjectDistanceOrderPred(GetCaster()));
                if (targets.empty())
                    return;

                std::list<WorldObject*> ranged, melee;
                std::list<WorldObject*>::iterator itr = targets.begin();

                if ((*itr)->ToCreature())
                    return;

                while (itr != targets.end() && (*itr)->GetDistance(GetCaster()) < 5.0f)
                {
                    melee.push_back((*itr)->ToUnit());
                    ++itr;
                }

                while (itr != targets.end())
                {
                    ranged.push_back((*itr)->ToUnit());
                    ++itr;
                }

                uint32 minTargets = GetCaster()->GetMap()->Is25ManRaid() ? 8 : 3;
                while (ranged.size() < minTargets)
                {
                    if (melee.empty())
                        break;

                    WorldObject* target = Trinity::Containers::SelectRandomContainerElement(melee);
                    ranged.push_back(target);
                    melee.remove(target);
                }

                if (!ranged.empty())
                    Trinity::Containers::RandomResizeList(ranged, GetCaster()->GetMap()->Is25ManRaid() ? 3 : 1);

                targets.swap(ranged);
            }

  //----------------------------------------------------------------
  // ready
  //
  static bool
  ready(std::map<Task::TimePoint, std::list<TaskPtr> > & tasks,
        std::list<TaskPtr> & next,
        Task::TimePoint & next_time_point)
  {
    std::map<Task::TimePoint, std::list<TaskPtr> >::iterator i = tasks.begin();
    if (i == tasks.end())
    {
      return false;
    }

    Task::TimePoint now = (boost::chrono::steady_clock::now() +
                           boost::chrono::milliseconds(1));

    if (now < i->first)
    {
      next_time_point = i->first;
      return false;
    }

    next.swap(i->second);
    tasks.erase(i);
    return true;
  }

void CSearchDialog::ProcessSelection(std::list<int> &selected_files, std::list<CServerPath> &selected_dirs)
{
    int sel = -1;
    while ((sel = m_results->GetNextItem(sel, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED)) != -1)
    {
        if (sel > (int)m_results->m_indexMapping.size())
            continue;
        int index = m_results->m_indexMapping[sel];

        if (m_results->m_fileData[index].entry.is_dir())
        {
            CServerPath path = m_results->m_fileData[index].path;
            path.ChangePath(m_results->m_fileData[index].entry.name);
            if (path.IsEmpty())
                continue;

            bool replaced = false;
            std::list<CServerPath>::iterator iter = selected_dirs.begin();
            std::list<CServerPath>::iterator prev;

            // Make sure that selected_dirs does not contain
            // any directories that are in a parent-child relationship
            // Resolve by only keeping topmost parents
            while (iter != selected_dirs.end())
            {
                if (*iter == path)
                {
                    replaced = true;
                    break;
                }

                if (iter->IsParentOf(path, false))
                {
                    replaced = true;
                    break;
                }

                if (iter->IsSubdirOf(path, false))
                {
                    if (!replaced)
                    {
                        *iter = path;
                        replaced = true;
                    }
                    else
                    {
                        prev = iter++;
                        selected_dirs.erase(prev);
                        continue;
                    }
                }
                ++iter;
            }
            if (!replaced)
                selected_dirs.push_back(path);
        }
        else
            selected_files.push_back(index);
    }

    // Now in a second phase filter out all files that are also in a directory
    std::list<int> selected_files_new;
    for (std::list<int>::const_iterator iter = selected_files.begin(); iter != selected_files.end(); ++iter)
    {
        CServerPath path = m_results->m_fileData[*iter].path;
        std::list<CServerPath>::const_iterator path_iter;
        for (path_iter = selected_dirs.begin(); path_iter != selected_dirs.end(); ++path_iter)
        {
            if (*path_iter == path || path_iter->IsParentOf(path, false))
                break;
        }
        if (path_iter == selected_dirs.end())
            selected_files_new.push_back(*iter);
    }
    selected_files.swap(selected_files_new);

    // At this point selected_dirs contains uncomparable
    // paths and selected_files contains only files not
    // covered by any of those directories.
}