Beispiel #1
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;
}
Beispiel #2
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();
 }
Beispiel #3
0
// ---------------------------------------------------------------------------------------
// FUNCTION:  CString::TrimRight
//		CString& TrimRight();
//
// DESCRIPTION:
//		This function removes any whitespace characters from the right end of the string.
//
// PARAMETERS: none
// RETURN VALUE:
//		a reference to this object (*this) -- allows chaining together of
//		these calls, eg. strTest.TrimRight().TrimLeft().ToUpper();
// ---------------------------------------------------------------------------------------
CString& CString::TrimRight()
{
	CString::reverse_iterator iter = std::find_if(rbegin(), rend(), NotSpace());
	if ( iter != rend() )
	{
		CString::size_type nNewSize = find_last_of(*iter);
		erase(nNewSize+1);
	}
	else
	{
		erase();
	}
	return *this;
}
Beispiel #4
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;
}
Beispiel #5
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;
}/*}}}*/
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));
}
Beispiel #7
0
uint32 RangeSet::getLast() const
{
	const_reverse_iterator it = rbegin();
	if (it == rend())
		return RangeSetAbsent;
	return upper(it);
}
static void test_posix_dup() 
{ 
    int pfd[2]; 

    BOOST_REQUIRE(::pipe(pfd) != -1); 
    bpd::file_handle rend(pfd[0]); 
    bpd::file_handle wend(pfd[1]); 

    BOOST_REQUIRE(rend.get() != 10); 
    BOOST_REQUIRE(wend.get() != 10); 
    bpd::file_handle fh1 = bpd::file_handle::posix_dup(wend.get(), 10); 
    BOOST_REQUIRE_EQUAL(fh1.get(), 10); 

    BOOST_REQUIRE(::write(wend.get(), "test-posix-dup", 14) != -1); 
    char buf1[15]; 
    BOOST_REQUIRE_EQUAL(::read(rend.get(), buf1, sizeof(buf1)), 14); 
    buf1[14] = '\0'; 
    BOOST_REQUIRE(std::strcmp(buf1, "test-posix-dup") == 0); 

    BOOST_REQUIRE(::write(fh1.get(), "test-posix-dup", 14) != -1); 
    char buf2[15]; 
    BOOST_REQUIRE_EQUAL(::read(rend.get(), buf2, sizeof(buf2)), 14); 
    buf2[14] = '\0'; 
    BOOST_REQUIRE(std::strcmp(buf2, "test-posix-dup") == 0); 
} 
Beispiel #9
0
Match::Match(const char *start_of_array, size_t array_size, size_t match_start_offset, size_t match_end_offset, long long line_number)
{
	auto line_ending = "\n";
	// Find the start of the line.
	std::reverse_iterator<const char*> rstart(start_of_array+match_start_offset);
	std::reverse_iterator<const char*> rend(start_of_array);

	auto line_start_rit = std::find(rstart, rend, line_ending[0]);
	const char *line_start;
	if(line_start_rit == rend)
	{
		// The line has no starting '\n', so it must be the first line.
		line_start = start_of_array;
	}
	else
	{
		// The line had a starting '\n', clip it off.
		line_start = line_start_rit.base();
	}

	// Find the end of the matched line.
	auto line_end = std::find(start_of_array+match_start_offset, start_of_array+array_size, line_ending[0]);

	// Form the match substrings.
	m_pre_match = std::string(line_start, start_of_array+match_start_offset);
	m_match = std::string(start_of_array+match_start_offset, start_of_array+match_end_offset);
	m_post_match = std::string(start_of_array+match_start_offset+(match_end_offset-match_start_offset), line_end);
	m_line_number = line_number;
}
Beispiel #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;
  }
}
Beispiel #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();
}
Beispiel #12
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;
}
Beispiel #13
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;

	}
}
Beispiel #14
0
DecodeOrderSampleMap::reverse_iterator DecodeOrderSampleMap::reverseFindSampleWithDecodeKey(const KeyType& key)
{
    DecodeOrderSampleMap::iterator found = findSampleWithDecodeKey(key);
    if (found == end())
        return rend();
    return --reverse_iterator(found);
}
Beispiel #15
0
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;
}
Beispiel #16
0
DecodeOrderSampleMap::reverse_iterator DecodeOrderSampleMap::findSyncSamplePriorToPresentationTime(const MediaTime& time, const MediaTime& threshold)
{
    PresentationOrderSampleMap::reverse_iterator reverseCurrentSamplePTS = m_presentationOrder.reverseFindSampleBeforePresentationTime(time);
    if (reverseCurrentSamplePTS == m_presentationOrder.rend())
        return rend();

    const RefPtr<MediaSample>& sample = reverseCurrentSamplePTS->second;
    reverse_iterator reverseCurrentSampleDTS = reverseFindSampleWithDecodeKey(KeyType(sample->decodeTime(), sample->presentationTime()));

    reverse_iterator foundSample = findSyncSamplePriorToDecodeIterator(reverseCurrentSampleDTS);
    if (foundSample == rend())
        return rend();
    if (foundSample->second->presentationTime() < time - threshold)
        return rend();
    return foundSample;
}
Beispiel #17
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();
}
Beispiel #18
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;
}
Beispiel #19
0
ZOrderedCells::ReverseIterator ZOrderedCells::findLast(const CellSet & cells)
{
    ReverseIterator it = rbegin();
    for(; it != rend(); ++it)
        if(cells.contains(*it))
            break;
    return it;
}
PositionVector
PositionVector::reverse() const {
    PositionVector ret;
    for (const_reverse_iterator i = rbegin(); i != rend(); i++) {
        ret.push_back(*i);
    }
    return ret;
}
Beispiel #21
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;
}
Beispiel #22
0
void CSVRow::erase(CSVRecordMap::reverse_iterator iter) {
	if (iter!=rend()) {
		if (iter->second) {
			delete iter->second;
		}
		_values.erase(--(iter.base()));
	}
}
Beispiel #23
0
//Remove gelps from this pickobjects.
void MGPickObjects::remove(const MGGelPositions& gelps){
	reverse_iterator i=rbegin(), iend=rend();
	for(; i!=iend;){
		MGPickObject& po=**i++;
		iterator ifoward=i.base();
		if(gelps.includes(po.gel()))
			erase(ifoward);	
	}
}
Beispiel #24
0
 array() {
   iterator i(begin());
   try {
     for (; i != end(); ++i) new (i) value_type();
   } catch (...) {
     for (reverse_iterator j(i); j != rend(); ++j) (*j).~value_type();
     throw;
   }
 }
Beispiel #25
0
void CandidateSet::initParentTrees() {
    if (parentTrees.empty()) {
        int count = Params::getInstance().popSize;
        for (reverse_iterator i = rbegin(); i != rend() && count > 0; i++, count--) {
            parentTrees.push(i->second.tree);
            //cout << i->first << endl;
        }
    }
}
Beispiel #26
0
vector<double> CandidateSet::getBestScores(int numBestScore) {
    if (numBestScore == 0)
        numBestScore = size();
    vector<double> res;
    for (reverse_iterator rit = rbegin(); rit != rend() && numBestScore > 0; rit++, numBestScore--) {
        res.push_back(rit->first);
    }
    return res;
}
Beispiel #27
0
/** Cancel finalization on all threads.
 */
void
ThreadList::cancel_finalize()
{
  MutexLocker lock(__finalize_mutex);

  for (reverse_iterator i = rbegin(); i != rend(); ++i) {
    (*i)->cancel_finalize();
  }
}
Beispiel #28
0
PB_DS_CLASS_T_DEC
inline typename PB_DS_CLASS_C_DEC::reverse_iterator
PB_DS_CLASS_C_DEC::
rbegin()
{
  if (empty())
    return rend();
  return --end();
}
Beispiel #29
0
//Remove objects of type from this pickobjects.
void MGPickObjects::remove(const MGAbstractGels& types){
	reverse_iterator i=rbegin(), ie=rend();
	for(; i!=ie;){
		if((**i).gel()->type_is(types)){
			m_PickObjects.erase((++i).base());
		}else
			i++;
	}
}
Beispiel #30
0
uint32 RangeSet::getPrev(uint32 v) const
{
	for (const_reverse_iterator it = rbegin(); it != rend(); ++it)
	{
		if (lower(it) < v)
			return min(v - 1, upper(it));
	}
	return RangeSetAbsent;
}