コード例 #1
0
ファイル: console.cpp プロジェクト: C1annad/warzone2100
/** Update the console messages.
	This function will remove messages that are overdue.
*/
void	updateConsoleMessages(void)
{
	// If there are no messages or we're on permanent (usually for scripts) then exit
	if ((!getNumberConsoleMessages() && !InfoMessages.size()) || mainConsole.permanent)
	{
		return;
	}
	for (auto i = InfoMessages.begin(); i != InfoMessages.end();)
	{
		if (realTime - i->timeAdded > messageDuration)
		{
			i = InfoMessages.erase(i);
		}
		else
		{
			++i;
		}
	}
	// Time to kill all expired ones
	for (auto i = ActiveMessages.begin(); i != ActiveMessages.end();)
	{
		if (realTime - i->timeAdded > messageDuration)
		{
			i = ActiveMessages.erase(i);
		}
		else
		{
			++i;
		}
	}
}
コード例 #2
0
	void next(std::deque<std::deque<match_t *> > *last_round, std::deque<player_t *> &tournament_players) {
		int half = tournament_players.size()/2;

		/** "Rotates clockwise" */
		tournament_players.insert(tournament_players.begin() + 1, tournament_players[half]);
		tournament_players.erase(tournament_players.begin() + half + 1);
		tournament_players.insert(tournament_players.end(), tournament_players[half]);
		tournament_players.erase(tournament_players.begin() + half);
	}
コード例 #3
0
void bad_erase_deque1(std::deque<int> &D) {
  auto i2 = D.cbegin(), i0 = i2++, i1 = i2++;
  D.erase(i1);
  *i0; // expected-warning{{Invalidated iterator accessed}}
  *i1; // expected-warning{{Invalidated iterator accessed}}
  *i2; // expected-warning{{Invalidated iterator accessed}}
}
コード例 #4
0
ファイル: AStar.cpp プロジェクト: hawkaa/ducking-wookie
bool remove(std::deque<RHNode> &vec, RHNode &element)
{
	std::deque<RHNode>::iterator it = std::find(vec.begin(), vec.end(), element);
	if(it == vec.end())
		return true;
	vec.erase(it);
	return true;
}
コード例 #5
0
ファイル: dragon_warrior.cpp プロジェクト: huycz/panda
 bool deactive(thread_control_block *tcb){
     threads.erase(std::find(threads.begin(), threads.end(), tcb));
     threads.push_back(tcb);
     sem_post(&service_count);
     int v;
     sem_getvalue(&service_count, &v);
     return true;
 }
コード例 #6
0
void UserPhotosSliceBuilder::sliceToLimits() {
	auto aroundIt = ranges::find(_ids, _key.photoId);
	auto removeFromBegin = (aroundIt - _ids.begin() - _limitBefore);
	auto removeFromEnd = (_ids.end() - aroundIt - _limitAfter - 1);
	if (removeFromEnd > 0) {
		_ids.erase(_ids.end() - removeFromEnd, _ids.end());
		_skippedAfter += removeFromEnd;
	}
	if (removeFromBegin > 0) {
		_ids.erase(_ids.begin(), _ids.begin() + removeFromBegin);
		if (_skippedBefore) {
			*_skippedBefore += removeFromBegin;
		}
	} else if (removeFromBegin < 0 && (!_skippedBefore || *_skippedBefore > 0)) {
		_insufficientPhotosAround.fire(_ids.empty() ? 0 : _ids.front());
	}
}
コード例 #7
0
ファイル: Filter.cpp プロジェクト: darkpixel93/flatworm
void EndSockWatch(SOCKET sock) {
	std::deque<SOCKET>::iterator it = std::find(
		socketwatches.begin(),
		socketwatches.end(),
		sock
	);
	if (it != socketwatches.end())
		socketwatches.erase(it);
}
コード例 #8
0
ファイル: symbol_table.hpp プロジェクト: NVIDIA/Forma
  ///Method to remove a symbol
  bool remove_symbol(const char* symbol_name) {
    for( typename std::deque<std::pair<std::string, T> >::iterator it = symbols.begin() ; it != symbols.end() ; it++ ){
      if( it->first.compare(symbol_name) == 0 ){
	symbols.erase(it);
	return true;
      }
    }
    return false;
  }
コード例 #9
0
 T popAt(int index) {
   if (index >= stacks.size()) { throw; }
   std::stack<T> &stack = *(stacks.begin() + index);
   T ret = stack.top(); stack.pop();
   if (stack.size() == 0) {
     stacks.erase(stacks.begin() + index);
   }
   return ret;
 }
コード例 #10
0
	void deleteTrailingZeros()
	{
		auto reverse_it = std::find_if(
        pos_vec.rbegin(), 
        pos_vec.rend(), 
        [](int i) {return i != 0;} );

		pos_vec.erase(reverse_it.base(),pos_vec.end());
	};
コード例 #11
0
CInputReceiver::~CInputReceiver(void)
{
	std::deque<CInputReceiver*>::iterator ri;
	for(ri=inputReceivers.begin();ri!=inputReceivers.end();++ri){
		if(*ri==this){
			inputReceivers.erase(ri);
			break;
		}
	}
}
コード例 #12
0
    void processTask(int position) {

        auto task = tasks[position];
        tasks.erase(tasks.begin() + position);

        task->setTile(std::make_shared<Tile>(task->tileId(), s_projection, &task->source()));

        pendingTiles = true;
        processedCount++;
    }
コード例 #13
0
ファイル: zZone.cpp プロジェクト: KnIfER/armagetron
void zZone::RemoveFromZoneList(void) {
    std::deque<zZone *>::iterator pos_found =
        std::find_if(
            sz_Zones.begin(),
            sz_Zones.end(),
            std::bind2nd(
                std::equal_to<zZone *>(),
                this)
        );
    if(pos_found != sz_Zones.end())
        sz_Zones.erase(pos_found);
}
コード例 #14
0
ファイル: flowmath.cpp プロジェクト: 151706061/Voreen
std::vector<T> FlowMath::dequeToVector(std::deque<T>& deq) {
    // convert the std::deque into a std::vector
    //
    std::vector<T> vec;
    typename std::deque<T>::iterator it = deq.begin();
    while (deq.empty() == false) {
        vec.push_back(*it);
        deq.erase(it);
        it = deq.begin();
    }
    return vec;
}
コード例 #15
0
/*
 * Removes outdated challenges
 * PRE: The caller has acquired a lock on mutex
 */
static void Cleanup()
{
	auto now = Challenge::Clock::now();
	challenges.erase(
		std::remove_if( challenges.begin(), challenges.end(),
			[&now]( const Challenge& challenge ) {
				return !challenge.ValidAt( now );
			}
		),
		challenges.end()
	);
}
コード例 #16
0
ファイル: Tree.C プロジェクト: Qilewuqiong/MIAMI
void
deque_erase (std::deque<T> d, T elt)
{
  typename std::deque<T>::iterator iter = d.begin();
  while (iter != d.end()) {
    T k = *iter;
    if (k == elt) {
      d.erase(iter);
      break;
    }
  }
}
コード例 #17
0
    // ------------------------------------------------------------------------
    void addAndSetTime(uint32_t ping, uint64_t server_time)
    {
        if (m_synchronised.load() == true)
            return;

        if (m_force_set_timer.load() == true)
        {
            m_force_set_timer.store(false);
            m_synchronised.store(true);
            STKHost::get()->setNetworkTimer(server_time + (uint64_t)(ping / 2));
            return;
        }

        const uint64_t cur_time = StkTime::getMonoTimeMs();
        // Discard too close time compared to last ping
        // (due to resend when packet loss)
        // 10 packets per second as seen in STKHost
        const uint64_t frequency = (uint64_t)((1.0f / 10.0f) * 1000.0f) / 2;
        if (!m_times.empty() &&
            cur_time - std::get<2>(m_times.back()) < frequency)
            return;

        // Take max 20 averaged samples from m_times, the next addAndGetTime
        // is used to determine that server_time if it's correct, if not
        // clear half in m_times until it's correct
        if (m_times.size() >= 20)
        {
            uint64_t sum = std::accumulate(m_times.begin(), m_times.end(),
                (uint64_t)0, [cur_time](const uint64_t previous,
                const std::tuple<uint32_t, uint64_t, uint64_t>& b)->uint64_t
                {
                    return previous + (uint64_t)(std::get<0>(b) / 2) +
                        std::get<1>(b) + cur_time - std::get<2>(b);
                });
            const int64_t averaged_time = sum / 20;
            const int64_t server_time_now = server_time + (uint64_t)(ping / 2);
            int difference = (int)std::abs(averaged_time - server_time_now);
            if (std::abs(averaged_time - server_time_now) <
                UserConfigParams::m_timer_sync_difference_tolerance)
            {
                STKHost::get()->setNetworkTimer(averaged_time);
                m_times.clear();
                m_force_set_timer.store(false);
                m_synchronised.store(true);
                Log::info("NetworkTimerSynchronizer", "Network "
                    "timer synchronized, difference: %dms", difference);
                return;
            }
            m_times.erase(m_times.begin(), m_times.begin() + 10);
        }
        m_times.emplace_back(ping, server_time, cur_time);
    }
コード例 #18
0
void CFolderCrawler::RemoveDuplicate(std::deque<CTGitPath> &list,const CTGitPath &path)
{
	for (auto it = list.cbegin(); it != list.cend(); ++it)
	{
		if(*it == path)
		{
			list.erase(it);
			it = list.cbegin(); /* search again*/
			if (it == list.cend())
				break;
		}
	}
}
コード例 #19
0
ファイル: Timer.cpp プロジェクト: Berniecrochu/epitech_perso
void		Timer::update(gdl::GameClock const& gameClock, gdl::Input& input, std::deque<AObject*>& map)
{
  (void)gameClock;
  (void)input;
  (void)map;
  this->_timer->update();

  float		elapsedTime = (this->_timer->getTotalElapsedTime());
  float		eltm = _timer->getElapsedTime();
  std::stringstream	tmp;

  if (123 - elapsedTime < 0)
    {
      while (map.size() > 0)
	if (map[0]->getType() != TIMER)
	  map.erase(map.begin());
	else
	  map.erase(map.begin() + 1);
      map.push_front(new MyCursor(0, 0));
      map.push_front(new MyMenu("libgdl_gl/images/bomber-accueil.png", 0, 0));
      for (unsigned int i = 0; i < map.size(); ++i)
	map[i]->initialize();
    }
  else if (120 - elapsedTime < 0 && 123 - elapsedTime >= 2)
    {
      while (map.size() > 0)
	map.erase(map.begin());
      map.push_front(new MyMenu("libgdl_gl/images/bomber-gameover.png", 0, 0));
      for (unsigned int i = 0; i < map.size(); ++i)
	map[i]->initialize();
    }
  else
    {
      if (eltm < 0.0333)
	usleep((int)((0.0333 - eltm) * 1000000));
      tmp << (120 - (int)elapsedTime);
      _time->setText(tmp.str());
    }
}
コード例 #20
0
void CFolderCrawler::RemoveDuplicate(std::deque<CTGitPath> &list,const CTGitPath &path)
{
	std::deque<CTGitPath>::iterator it, lastit;
	for(it = list.begin(); it != list.end(); ++it)
	{
		if(*it == path)
		{
			list.erase(it);
			it = list.begin(); /* search again*/
			if(it == list.end())
				break;
		}
	}
}
コード例 #21
0
    std::vector<T> filter(const std::vector<T> & in)
    {
        assert(in.size() > 0);

        //---------------------------------------------------------------------
        // init state

        unsigned hist_ptr = 0;

        std::fill(_history.begin(), _history.end(), in[0]);
        std::fill(_pool.begin(), _pool.end(), in[0]);

        // pool is keep sorted

        //---------------------------------------------------------------------
        // filter input

        std::vector<T> out;
        out.reserve(in.size());

        for(auto x : in)
        {
            // step 1, remove oldest value from the pool.

            auto last = _history[hist_ptr];

            auto last_pos = std::lower_bound(_pool.begin(), _pool.end(), last);

            _pool.erase(last_pos);

            // step 2, insert new value into pool

            auto insert_pos = std::lower_bound(_pool.begin(), _pool.end(), x);

            _pool.insert(insert_pos, x);

            // step 3, write input value into history.

            _history[hist_ptr] = x;

            hist_ptr = (hist_ptr + 1) % _history.size();

            // median is always the middle of the pool

            out.push_back(*(_pool.begin() +_median));
        }

        return out;
    }
コード例 #22
0
void OptimizeAndOutputSets(std::deque<GCodeSet> &vSets, unsigned int &uiLinesOut, FILE *pfOutput = stdout)
{
	double dDepth = 0.0f;
	if (vSets.empty() == false)
	{
		dDepth = vSets[0].GetZStart();
	}
	fprintf(stderr, "Sorting %u sets at depth %.02f\n", vSets.size(), dDepth);

	//
	// 
	// SLOW sort algorithm, but the idea is to find the nearest place to jump to after completing
	// one operation (set).  So we calculate the absolute nearest over and over as we move.  The result
	// is very few long jumps (linear G0)!
	double dXLast = 0.0f;
	double dYLast = 0.0f;
	std::deque<GCodeSet> vOptimizedSet;
	while (vSets.empty() == false)
	{
		//
		// Search for nearest to dXLast, dYLast
		std::deque<std::pair<std::vector<GCodeSet>::size_type, double> > vDistance;
		std::deque<GCodeSet>::size_type index = 0;
		for (auto entry : vSets)
		{
			double dXDelta = entry.GetXStart() - dXLast;
			double dYDelta = entry.GetYStart() - dYLast;
			vDistance.push_back(std::make_pair(index, abs(dXDelta) + abs(dYDelta)));
			++index;
		}
		std::sort(vDistance.begin(), vDistance.end(), SortLessPair);
		std::deque<GCodeSet>::size_type szIndex = vDistance.front().first;
		vOptimizedSet.push_back(vSets[szIndex]);
		auto erasey = vSets.begin() + szIndex;
		vSets.erase(erasey);
		dXLast = vOptimizedSet.back().GetXEnd();
		dYLast = vOptimizedSet.back().GetYEnd();
	}

	for (auto entry : vOptimizedSet)
	{
		fprintf(stderr, "\tOutputing set with %u lines\n", entry.GetLines().size());
		for (auto line : entry.GetLines())
		{
			++uiLinesOut;
			fprintf(pfOutput, line.c_str());
		}
	}
}
コード例 #23
0
ファイル: GCTest.cpp プロジェクト: Gwill/luna
void FreeGlobal(int count)
{
    for (int i = 0; i < count; ++i)
    {
        std::size_t size = 0;
        size += g_globalFunction.size();
        size += g_globalClosure.size();
        size += g_globalString.size();
        size += g_globalTable.size();

        if (size == 0)
            return ;

        auto index = RandomNum(size);
        if (index < g_globalFunction.size())
        {
            g_globalFunction.erase(g_globalFunction.begin() + index);
        }
        else if (index < g_globalFunction.size() + g_globalClosure.size())
        {
            index -= g_globalFunction.size();
            g_globalClosure.erase(g_globalClosure.begin() + index);
        }
        else if (index < g_globalFunction.size() + g_globalClosure.size() +
                 g_globalString.size())
        {
            index -= g_globalFunction.size() + g_globalClosure.size();
            g_globalString.erase(g_globalString.begin() + index);
        }
        else
        {
            index -= g_globalFunction.size() + g_globalClosure.size() + g_globalString.size();
            g_globalTable.erase(g_globalTable.begin() + index);
        }
    }
}
コード例 #24
0
ファイル: Queue.hpp プロジェクト: ecswm/AC
		bool Find(T &elem,const char *CallID)
		{
			std::deque<T>::iterator pos;
			for (pos = m_PreDataList.begin();pos < m_PreDataList.end();)
			{
				if (strcmp(CallID,(*pos).CallID) == 0)
				{
					strcpy(elem.CallID,CallID);
					strcpy(elem.ANI,(*pos).ANI);
					strcpy(elem.StationID,(*pos).StationID);
					m_PreDataList.erase(pos++);
					return true;
				}
				pos++;
			}
			return false;
		}
コード例 #25
0
void CVideoBufferPoolDRMPRIME::Return(int id)
{
  CSingleLock lock(m_critSection);

  m_all[id]->Unref();
  auto it = m_used.begin();
  while (it != m_used.end())
  {
    if (*it == id)
    {
      m_used.erase(it);
      break;
    }
    else
      ++it;
  }
  m_free.push_back(id);
}
コード例 #26
0
ファイル: astar.cpp プロジェクト: Usanter/RobotLegoMazeSolver
Case lowest_node ()
{
        Case min = ouvert[0];

        unsigned int i;
        int indice = 0;
        for(i = 1 ; i < ouvert.size(); i++)
        {
            if(ouvert[i].F < min.F)
            {
                min = ouvert[i];
                indice = i;
            }
        }

        ouvert.erase(ouvert.begin() + indice);
        return min;
}
コード例 #27
0
void smoothTraj(){
	if(!planned || current_path.size()<2)
		return;
	int i=1;
	State<2> a=startState;
	State<2> b=current_path[i];
	while(i<current_path.size()){ // situtation always is of type a->m->b->n
		//if a->b feasible, remove m and set b=n to try to remove b
		if(segmentFeasibility(a,b)){
			current_path.erase(current_path.begin()+i-1);
			b=current_path[i];
		}else{ // if a->b unfeasible, we need to keep a->m, so a becomes m, b becomes n to try to remove the previous b 
			a=current_path[i-1];
			i++;
			b=current_path[i];
		}
	}
}
コード例 #28
0
ファイル: keepbesthm.hpp プロジェクト: yesyestian/BNB-solver
 /**
  * Find best matching solutions to send to a slave from free slaves list.
  * Modify free slaves list accordingly. Form solutions vector and a destination
  * free slave number.
  * @param freeSlaves list of free slaves
  * @param sv vector of solutions
  * @param s pointer to the free slave to send
  * @return true if best match was found false otherwise
  */
  bool findBestMatch(std::deque<int> &freeSlaves , std::vector<Solution> &sv, int &s) {
    bool rv = false;
    std::deque<int>::iterator i;
    if(BASE::mHasBestSolution && (!mNotServed.empty())){
      for(i = freeSlaves.begin(); i != freeSlaves.end(); i ++) {
        std::vector<int>::iterator p;
        p = std::find(mNotServed.begin(), mNotServed.end(), *i); 
        if(p != mNotServed.end()) {
          rv = true;
          s = *p;
          freeSlaves.erase(i);
          mNotServed.erase(p);
          sv.push_back(BASE::mBestSolution);
          break;
        }
      }
    }
    return rv;
  }
コード例 #29
0
ファイル: stickshift.cpp プロジェクト: petechap/stickshift
bool JsFile::AttemptOutput()
{
    std::stable_sort(m_events.begin(), m_events.end(), EventOrder());
    assert(m_readReq);
    size_t eventsWanted = m_readSize/sizeof(js_event);
    size_t eventsToSend = std::min(eventsWanted, m_events.size());
    if (eventsToSend > 0)
    {
        std::deque<js_event>::iterator i = m_events.begin() + eventsToSend;
        // need events in a contiguous area of memory
        std::vector<js_event> buf(m_events.begin(), i);
        m_events.erase(m_events.begin(), i);
        fuse_reply_buf(m_readReq, (char*)buf.data(),
                       buf.size()*sizeof(js_event));
        m_readReq = 0;
        return true;
    }
    return false;
}
コード例 #30
0
ファイル: flow2d.cpp プロジェクト: alvatar/smartmatter
std::deque<tgt::ivec2> Flow2D::flowPosToSlicePos(std::deque<tgt::vec2>& fps,
        const tgt::ivec2& sliceSize, const tgt::ivec2& offset) const
{
    std::deque<tgt::ivec2> sps;    // slice positions
    while (fps.empty() == false) {
        std::deque<tgt::vec2>::iterator it = fps.begin();

        // no call to overloaded flowPosToViewportPos() for performance
        //
        tgt::vec2 aux(*it / static_cast<tgt::vec2>(dimensions_));
        tgt::ivec2 sp(
            (static_cast<int>(tgt::round(aux.x * sliceSize.x)) + offset.x) % sliceSize.x,
            (static_cast<int>(tgt::round(aux.y * sliceSize.y)) + offset.y) % sliceSize.y);

        sps.push_back(sp);
        fps.erase(it);
    }
    return sps;
}