void PipeLine::cancel_last_packet_reservation(std::shared_ptr<Frame> frame)
{
    auto slack = frame->slack_interval();
    auto interval_res = reservations_in_interval(slack);
    auto result = std::find_if(interval_res.rbegin(), interval_res.rend(), [frame](const pipeline_datatype& pair) -> bool {return frame == pair.second;} );
    cancel_reservation(slack.second - 1 - std::distance(interval_res.rbegin(), result));
}
Example #2
0
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//! return list of qcParameters for the last n seconds in buffer
const QcBuffer* QcBuffer::qcParameter(const Core::TimeSpan& lastNSeconds) const {

	QcBuffer* qcb = new QcBuffer();
	
	if (empty()) return qcb;

	const_reverse_iterator Start = rbegin();
	const_reverse_iterator End = rbegin();

	for (const_reverse_iterator qcPar = rbegin(); qcPar != rend(); qcPar++) {
		
		if (!(*qcPar)) continue;
		
		Core::TimeSpan diff = back()->recordEndTime - (*qcPar)->recordEndTime;
		
		Start = qcPar;

		if ( diff > lastNSeconds )
			break;
		
	}
	

	if (Start != End) {
		qcb->insert(qcb->begin(), End, Start);
		qcb->reverse();
	}

	return qcb;
}
Example #3
0
 /** Retrieve the 10 most recent tweet ids in the user's news feed. Each item in the news feed must be posted by users who the user followed or by the user herself. Tweets must be ordered from most recent to least recent. */
 std::vector<int> getNewsFeed(int u) {
   std::vector<int> rslt;
   auto feeds = m_tweets[u];
   for (auto rit = feeds.rbegin();
        rit != feeds.rend() && rit - feeds.rbegin() < 10;
        ++rit) {
     rslt.push_back(rit->first);
   }
   return rslt;
 }
Example #4
0
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q)
{
    auto pathToP = pathToElem(root, p);
    auto pathToQ = pathToElem(root, q);
    size_t i = 0;
    for (i = 0; i != std::min(pathToQ.size(), pathToP.size()); i++)
    {
        if (*(pathToQ.rbegin() + i) != *(pathToP.rbegin() + i)) break;
    }
    return *(pathToQ.rbegin() + i - 1);
}
Example #5
0
TEST(WordCountOpenMPTest, FileParAndSeqTest)
{
    pair<const char*, size_t> text = loadTextFromFile("book.txt");

    auto counted1 = countWords(text.first, text.second);
    auto flipped1 = flipMap<string, int>(counted1);

    auto counted2 = countWordsOpenMP(text.first, text.second, defaultThreadCount);
    auto flipped2 = flipMap<string, int>(counted2);

    ASSERT_TRUE(std::equal(flipped1.rbegin(), flipped1.rend(), flipped2.rbegin()));
}
Example #6
0
PresentationOrderSampleMap::iterator_range PresentationOrderSampleMap::findSamplesWithinPresentationRangeFromEnd(const MediaTime& beginTime, const MediaTime& endTime)
{
    reverse_iterator rangeEnd = std::find_if(rbegin(), rend(), [&beginTime] (PresentationOrderSampleMap::MapType::value_type value) {
        return value.second->presentationTime() <= beginTime;
    });

    reverse_iterator rangeStart = std::find_if(rbegin(), rangeEnd, [&endTime] (PresentationOrderSampleMap::MapType::value_type value) {
        return value.second->presentationTime() <= endTime;
    });

    return iterator_range(rangeEnd.base(), rangeStart.base());
}
Example #7
0
 position_type   GetLength (void) const
 {
    if(! m_vRanges.empty())  {
         position_type From = begin()->GetFrom();
         return rbegin()->GetToOpen() - From;
    } else return 0;
 }
Example #8
0
CItem* CItemList::find(const QPoint& pos) const/*{{{*/
{
	rciCItem ius;
	bool usfound = false;
	for (rciCItem i = rbegin(); i != rend(); ++i)
	{
		if (i->second->contains(pos))
		{
			if (i->second->isSelected())
				return i->second;

			else
			{
				if (!usfound)
				{
					ius = i;
					usfound = true;
				}
			}
		}
	}
	if (usfound)
		return ius->second;
	else
		return 0;
}/*}}}*/
Example #9
0
File: folds.hpp Project: Rapptz/Lia
inline T foldr(Cont&& cont, BinaryFunc&& func, T starting) {
    auto first = rbegin(std::forward<Cont>(cont));
    auto last = rend(std::forward<Cont>(cont));
    for(; first != last; ++first)
        starting = func(*first, starting);
    return starting;
}
Example #10
0
/** Finalize Threads.
 * The threads are finalized.
 * This operation is carried out unlocked. Lock it from the outside if needed.
 * This is done because it is likely that this will be chained with other
 * actions that require locking, thus you can lock the whole operation.
 * @param finalizer thread finalizer to use to finalize the threads
 */
void
ThreadList::finalize(ThreadFinalizer *finalizer)
{
  bool error = false;
  Exception me("One or more threads failed to finalize");
  for (reverse_iterator i = rbegin(); i != rend(); ++i) {
    try {
      (*i)->finalize();
    } catch (CannotFinalizeThreadException &e) {
      error = true;
      me.append("AspectIniFin called Thread[%s]::finalize() which failed", (*i)->name());
      me.append(e);
    } catch (Exception &e) {
      error = true;
      me.append("AspectIniFin called Thread[%s]::finalize() which failed", (*i)->name());
      me.append(e);
    } catch (...) {
      error = true;
      me.append("Thread[%s]::finalize() threw unsupported exception", (*i)->name());
    }
    try {
      finalizer->finalize(*i);
    } catch (CannotFinalizeThreadException &e) {
      error = true;
      me.append("Could not finalize thread '%s' in list '%s'", (*i)->name(), __name);
      me.append(e);
    }
  }
  if ( error ) {
    throw me;
  }
}
Example #11
0
CandidateSet::iterator CandidateSet::getCandidateTree(string topology) {
    for (CandidateSet::reverse_iterator rit = rbegin(); rit != rend(); rit++) {
        if (rit->second.topology == topology)
            return --(rit.base());
    }
    return end();
}
Example #12
0
void Scene::cleanup()
{
	auto toBeDestroyed = findGameObjects([](GameObject & go){return (go.toBeDestroyed_ == true);});
	for(auto it = toBeDestroyed.rbegin(); it != toBeDestroyed.rend(); it++)
	{
		auto* go = *it;
		go->setParent(nullptr);
		auto rootIt = std::find(root_->children_.begin(), root_->children_.end(), go);
		auto gameObjectsIt = std::find(gameObjects_.begin(), gameObjects_.end(), go);

		//the scene graph must contain this object
		assert(rootIt != root_->children_.end());

		//the list of all gameobjects must contain this object
		assert(gameObjectsIt != gameObjects_.end());

		//remove from scene graph
		root_->children_.erase(rootIt);

		//remove from all gameobjects
		gameObjects_.erase(gameObjectsIt);
		delete go;

	}
}
Example #13
0
rColor rGradient::GetColor(float where) {
#ifndef DEDICATED
    if(empty()) return rColor();
    if(begin()->first >= where) return begin()->second;
    iterator upper, lower;
    iterator i=begin();
    iterator j=begin();
    ++j;
    bool finished = false;
    for(; j!=end(); ++i, ++j) {
        if(j->first >= where) {
            lower = i;
            upper = j;
            finished = true;
            break;
        }
    }
    if (!finished) return rbegin()->second;
    float diff = upper->first - lower->first;
    float pos = where - lower->first;
    rColor &c1 = lower->second;
    rColor &c2 = upper->second;
    float r = c1.r_*(diff-pos)/diff + c2.r_*pos/diff;
    float g = c1.g_*(diff-pos)/diff + c2.g_*pos/diff;
    float b = c1.b_*(diff-pos)/diff + c2.b_*pos/diff;
    float a = c1.a_*(diff-pos)/diff + c2.a_*pos/diff;
    return rColor(r,g,b,a);
#else
    return rColor(0.,0.,0.,0.);
#endif
}
Example #14
0
inline void testReadUntil(const char* format)
{
    TemporaryData data{format};

    brion::SpikeReport reportWrite(brion::URI(data.tmpFileName),
                                   brion::MODE_WRITE);
    reportWrite.write(data.spikes);
    reportWrite.close();

    brion::SpikeReport reportRead(brion::URI(data.tmpFileName),
                                  brion::MODE_READ);

    auto spikes = reportRead.readUntil(0.15).get();
    BOOST_CHECK_EQUAL(spikes.size(), 1);
    BOOST_CHECK(reportRead.getCurrentTime() >= 0.15f);

    spikes = reportRead.readUntil(0.3).get();
    BOOST_CHECK_EQUAL(spikes.size(), 2);
    BOOST_CHECK(reportRead.getCurrentTime() >= 0.3f);
    BOOST_CHECK(spikes.rbegin()->first < 0.3);
    BOOST_CHECK_EQUAL(reportRead.getState(), brion::SpikeReport::State::ok);

    spikes = reportRead.read(brion::UNDEFINED_TIMESTAMP).get();
    BOOST_CHECK_EQUAL(spikes.size(), 2);
    BOOST_CHECK_EQUAL(reportRead.getCurrentTime(), brion::UNDEFINED_TIMESTAMP);
    BOOST_CHECK_EQUAL(reportRead.getState(), brion::SpikeReport::State::ended);
}
Example #15
0
            types::ndarray<T,N> _transpose(types::ndarray<T,N> const & a, long const l[N])
            {
                auto shape = a.shape;
                types::array<long, N> shp;
                for(unsigned long i=0; i<N; ++i)
                    shp[i] = shape[l[i]];

                types::ndarray<T,N> new_array(shp, __builtin__::None);

                types::array<long, N> new_strides;
                new_strides[N-1] = 1;
                std::transform(new_strides.rbegin(), new_strides.rend() -1, shp.rbegin(), new_strides.rbegin() + 1, std::multiplies<long>());

                types::array<long, N> old_strides;
                old_strides[N-1] = 1;
                std::transform(old_strides.rbegin(), old_strides.rend() -1, shape.rbegin(), old_strides.rbegin() + 1, std::multiplies<long>());

                auto iter = a.buffer,
                     iter_end = a.buffer + a.size();
                for(long i=0; iter!=iter_end; ++iter, ++i) {
                    long offset = 0;
                    for(unsigned long s=0; s<N; s++)
                        offset += ((i/old_strides[l[s]]) % shape[l[s]])*new_strides[s];
                    new_array.buffer[offset] = *iter;
                }

                return new_array;
            }
Example #16
0
PresentationOrderSampleMap::reverse_iterator PresentationOrderSampleMap::reverseFindSampleContainingPresentationTime(const MediaTime& time)
{
    auto range = std::equal_range(rbegin(), rend(), time, SampleIsGreaterThanMediaTimeComparator<MapType>());
    if (range.first == range.second)
        return rend();
    return range.first;
}
Example #17
0
std::vector<CreaturePtr> Map::getSpectatorsInRangeEx(const Position& centerPos, bool multiFloor, int minXRange, int maxXRange, int minYRange, int maxYRange)
{
    int minZRange = 0;
    int maxZRange = 0;
    std::vector<CreaturePtr> creatures;

    if(multiFloor) {
        minZRange = 0;
        maxZRange = Otc::MAX_Z;
    }

    //TODO: optimize
    //TODO: get creatures from other floors corretly
    //TODO: delivery creatures in distance order

    for(int iz=-minZRange; iz<=maxZRange; ++iz) {
        for(int iy=-minYRange; iy<=maxYRange; ++iy) {
            for(int ix=-minXRange; ix<=maxXRange; ++ix) {
                TilePtr tile = getTile(centerPos.translated(ix,iy,iz));
                if(!tile)
                    continue;

                auto tileCreatures = tile->getCreatures();
                creatures.insert(creatures.end(), tileCreatures.rbegin(), tileCreatures.rend());
            }
        }
    }

    return creatures;
}
Example #18
0
 const_reverse_iterator rfind(value_type const& v) const
 {
     const_reverse_iterator i(std::upper_bound(rbegin(), rend(), v,
             compose_binary(std::logical_not<bool>(),
                 static_cast<TweakOrdering_ const&>(ord_))));
     return i != rend() && *i == v ? i: rend();
 }
Example #19
0
uint32 RangeSet::getLast() const
{
	const_reverse_iterator it = rbegin();
	if (it == rend())
		return RangeSetAbsent;
	return upper(it);
}
void
TileImportanceTable::buildMatrix()
{

   if ( empty() ) {
      return;
   }
   
   int nbrDetailLevels = int((*rbegin()).second.getDetailLevel()) + 1;

   m_importanceMatrix.resize( nbrDetailLevels );
   for ( int i = 0; i < nbrDetailLevels; ++i ) {

      int nbrImportances = getNbrImportanceNbrs( 0, i );
      
      
      std::vector<const TileImportanceNotice*>* vecPtr = 
         new std::vector<const TileImportanceNotice*>();

      vecPtr->resize( nbrImportances );

      m_importanceMatrix[ i ] = vecPtr;
      for ( int j = 0; j < nbrImportances; ++j ) {
         // Use the slow method.
         (*vecPtr)[ j ] = getImportanceNbrSlow( j, i ); 
      }
   }
}
Example #21
0
void Messages::display_messages(WINDOW *const ipk_target, int const left, int const top,
                                int const right, int const bottom)
{
    if (!size()) {
        return;
    }
    
    int const maxlength = right - left;
    int line = bottom;

    for (int i = size() - 1; i >= 0; --i) {
        if (line < top) {
            break;
        }

        const game_message &m = player_messages.impl_->messages[i];
        const nc_color col = m.get_color(player_messages.impl_->curmes);

        const auto folded_strings = foldstring(m.get_with_count(), maxlength);
        const auto folded_rend = folded_strings.rend();
        for( auto string_iter = folded_strings.rbegin();
             string_iter != folded_rend && line >= top; ++string_iter, line-- ) {
            mvwprintz(ipk_target, line, left, col, "%s", string_iter->c_str());
        }
    }

    player_messages.impl_->curmes = calendar::turn.get_turn();
}
Example #22
0
std::vector<std::string> getProcArgs(int pid, size_t argmax) {
  auto raw_args = getProcRawArgs(pid, argmax);
  std::vector<std::string> args;
  bool collect = false;

  // Iterate from the back until we stop seeing environment vars
  // Then start pushing args (in reverse order) onto a vector.
  // We trim the args of leading/trailing whitespace to make
  // analysis easier.
  for (auto itr = raw_args.rbegin(); itr < raw_args.rend(); ++itr) {
    if (collect) {
      std::string arg = *itr;
      boost::algorithm::trim(arg);
      args.push_back(arg);
    } else {
      size_t idx = itr->find_first_of("=");
      if (idx == std::string::npos) {
        collect = true;
      }
    }
  }

  // We pushed them on backwards, so we need to fix that.
  std::reverse(args.begin(), args.end());

  return args;
}
Example #23
0
inline void testReadUntilFiltered(const char* format)
{
    TemporaryData data{format};

    brion::SpikeReport reportWrite(brion::URI(data.tmpFileName),
                                   brion::MODE_WRITE);
    reportWrite.write(data.spikes);
    reportWrite.close();

    brion::SpikeReport reportRead(brion::URI(data.tmpFileName),
                                  brion::GIDSet{22, 25});

    auto spikes = reportRead.readUntil(0.4).get();
    BOOST_CHECK_EQUAL(spikes.size(), 1);
    BOOST_CHECK(reportRead.getCurrentTime() >= 0.4f);
    BOOST_CHECK(spikes.rbegin()->first < 0.4);
    BOOST_CHECK_EQUAL(reportRead.getState(), brion::SpikeReport::State::ok);

    spikes = reportRead.readUntil(brion::UNDEFINED_TIMESTAMP).get();
    BOOST_CHECK_EQUAL(spikes.size(), 1);
    BOOST_CHECK_EQUAL(reportRead.getCurrentTime(), brion::UNDEFINED_TIMESTAMP);
    BOOST_CHECK_EQUAL(reportRead.getState(), brion::SpikeReport::State::ended);

    BOOST_CHECK_THROW(reportRead.read(reportRead.getCurrentTime()),
                      std::logic_error);
}
Example #24
0
ZOrderedCells::ReverseIterator ZOrderedCells::findLast(const CellSet & cells)
{
    ReverseIterator it = rbegin();
    for(; it != rend(); ++it)
        if(cells.contains(*it))
            break;
    return it;
}
Example #25
0
    ID::ID(std::string str)
    {
        auto hash = sha1(str); // 160 bits

        std::bitset<4> nibble;

        for (int i = 0; i < std::min(data_.size(), hash.size() * 4); i++)
        {
            if (!(i % 4))
            {
                nibble = std::bitset<4>(std::stoul(std::string(1, hash.back()), nullptr, 16));
                std::rotate(hash.rbegin(), hash.rbegin() + 1, hash.rend());
            }

            data_[i] = nibble[i % 4];
        }
    }
Example #26
0
bool palindrome(T n)
{
    std::ostringstream s;
    s << n;
    auto r = s.str();
    return std::equal(r.begin(), r.end(),
                      r.rbegin());
}
Example #27
0
void GameState::play_move(int color, int vertex) {
    if (vertex != FastBoard::PASS && vertex != FastBoard::RESIGN) {
        KoState::play_move(color, vertex);
    } else {
        KoState::play_pass();
        if (vertex == FastBoard::RESIGN) {
            std::rotate(rbegin(m_lastmove), rbegin(m_lastmove) + 1,
                        rend(m_lastmove));
            m_lastmove[0] = vertex;
            m_last_was_capture = false;
        }
    }

    // cut off any leftover moves from navigating
    game_history.resize(m_movenum);
    game_history.push_back(*this);
}
Example #28
0
 TRange          GetLimits() const
 {
     if(! m_vRanges.empty())  {
         position_type From = begin()->GetFrom();
         position_type To = rbegin()->GetTo();
         return TRange(From, To);
     } else return TRange::GetEmpty();
 }
PositionVector
PositionVector::reverse() const {
    PositionVector ret;
    for (const_reverse_iterator i = rbegin(); i != rend(); i++) {
        ret.push_back(*i);
    }
    return ret;
}
Example #30
0
static std::vector<int64_t> computeLinearStride(const Tensor & tensor) {
  // computes the stride as if tensor were contigous
  auto sizes = tensor.sizes();
  std::vector<int64_t> stride(tensor.dim());
  stride[tensor.dim() - 1] = 1;
  std::partial_sum(sizes.rbegin(), sizes.rend() - 1, stride.rbegin() + 1, std::multiplies<int64_t>());
  return stride;
}