/**
* Copy all of the data (event lists) from the source workspace to this
*workspace.
*
* @param source: EventWorkspace from which we are taking data.
* @param sourceStartWorkspaceIndex: index in the workspace of source where we
*start
* copying the data. This index will be 0 in the "this" workspace.
* Default: -1, meaning copy all.
* @param sourceEndWorkspaceIndex: index in the workspace of source where we
*stop.
* It is inclusive = source[sourceEndWorkspaceIndex[ WILL be copied.
* Default: -1, meaning copy all.
*
*/
void EventWorkspace::copyDataFrom(const EventWorkspace &source,
std::size_t sourceStartWorkspaceIndex,
std::size_t sourceEndWorkspaceIndex) {
// Start with nothing.
this->clearData(); // properly de-allocates memory!
// Copy the vector of EventLists
EventListVector source_data = source.data;
EventListVector::iterator it;
EventListVector::iterator it_start = source_data.begin();
EventListVector::iterator it_end = source_data.end();
size_t source_data_size = source_data.size();
// Do we copy only a range?
if (sourceEndWorkspaceIndex == size_t(-1))
sourceEndWorkspaceIndex = source_data_size - 1;
if ((sourceStartWorkspaceIndex < source_data_size) &&
(sourceEndWorkspaceIndex < source_data_size) &&
(sourceEndWorkspaceIndex >= sourceStartWorkspaceIndex)) {
it_start += sourceStartWorkspaceIndex;
it_end = source_data.begin() + sourceEndWorkspaceIndex + 1;
}
for (it = it_start; it != it_end; ++it) {
// Create a new event list, copying over the events
EventList *newel = new EventList(**it);
// Make sure to update the MRU to point to THIS event workspace.
newel->setMRU(this->mru);
this->data.push_back(newel);
}
// Save the number of vectors
m_noVectors = this->data.size();
this->clearMRU();
}
TEST(TestSuite, aTest) {
// Create a list of events with time, set the size to 5 events
EventList<Event_T> testList = EventList<Event_T>(5);
testList[0].source = 0;
testList[0].dest = 1;
testList[0].setTime(1);
testList[1].source = 0;
testList[1].dest = 2;
testList[1].setTime(2);
testList[2].source = 0;
testList[2].dest = 1;
testList[2].setTime(4);
testList[3].source = 2;
testList[3].dest = 0;
testList[3].setTime(5);
testList[4].source = 0;
testList[4].dest = 1;
testList[4].setTime(7);
// cout << "Simple event list:" << endl;
for (int i = 0; i < testList.size; i++) {
EXPECT_GT(testList[i].getLongEventInformation().length(), 0);
}
// Test writing and reading binary file
char *testFileName = (char *) "test1.bin";
testList.WriteFile_Binary(testFileName);
EventList<Event_T> testList2 = EventList<Event_T>(0);
testList2.ReadFile_Binary(testFileName);
if (remove(testFileName) != 0) {
cout << "Error while deleting file " << testFileName << endl;
}
// cout << "Simple event list after writing and reading binary file:" << endl;
for (int i = 0; i < testList2.size; i++) {
Event_T e1 = testList[i];
Event_T e2 = testList2[i];
EXPECT_GT(testList2[i].getLongEventInformation().length(), 0);
EXPECT_EQ(e1.getDest(), e2.getDest());
EXPECT_EQ(e1.getSource(), e2.getSource());
EXPECT_EQ(e1.getTime(), e2.getTime());
}
// Test reading a file, compare result to explicit event list
EventList<Event_T> testList_file = EventList<Event_T>(0);
char *testListFileName = (char *) "../eventpy/data/eventlist_small1_sdt.txt";
// cout << "Reading in some SourceDestTime data" << endl;
testList_file.ReadFile_SourceDestTime(testListFileName);
EXPECT_EQ(testList_file.size, testList.size);
}
static EventList createEventList( const QDate& start, const QDate& end, int minutes, const TaskId& taskId )
{
Q_ASSERT( start < end );
EventList events;
const int days = start.daysTo( end );
#if QT_VERSION >= 0x040700
events.reserve( days );
#endif
for ( int i = 0; i < days; ++i ) {
const QDate date = start.addDays( i );
//for each work day, create an event starting at 8 am
if ( isWorkDay( date ) ) {
const QDateTime startTime = QDateTime( date, QTime( 8, 0 ) );
const QDateTime endTime = startTime.addSecs( minutes * 60 );
Event event;
event.setTaskId( taskId );
event.setStartDateTime( startTime );
event.setEndDateTime( endTime );
event.setComment( QObject::tr( "(created by vacation dialog)" ) );
events.append( event );
}
}
return events;
}
void SqLiteStorageTests::deleteTaskWithEventsTest()
{
// make a task
const int TaskId = 1;
const QString Task1Name( "Task-Name" );
Task task;
task.setId( TaskId );
task.setName( Task1Name );
task.setValidFrom( QDateTime::currentDateTime() );
QVERIFY( m_storage->deleteAllTasks() );
QVERIFY( m_storage->deleteAllEvents() );
QVERIFY( m_storage->getAllTasks().size() == 0 );
QVERIFY( m_storage->addTask( task ) );
QVERIFY( m_storage->getAllTasks().size() == 1 );
Task task2;
task2.setId( 2 );
task2.setName( "Task-2-Name" );
QVERIFY( m_storage->addTask( task2 ) );
QVERIFY( m_storage->getAllTasks().size() == 2 );
// create 3 events, 2 for task 1, and one for another one
{
Event event = m_storage->makeEvent();
QVERIFY( event.isValid() );
event.setTaskId( task.id() );
event.setUserId( 1 );
event.setReportId( 42 );
const QString EventComment( "Event-Comment" );
event.setComment( EventComment );
QVERIFY( m_storage->modifyEvent( event ) );
}
{
Event event = m_storage->makeEvent();
QVERIFY( event.isValid() );
event.setTaskId( task.id() );
event.setUserId( 1 );
event.setReportId( 43 );
const QString EventComment( "Event-Comment 2" );
event.setComment( EventComment );
QVERIFY( m_storage->modifyEvent( event ) );
}
// this is the event that is supposed to remain in the DB:
Event event = m_storage->makeEvent();
QVERIFY( event.isValid() );
event.setTaskId( task2.id() );
event.setUserId( 1 );
event.setReportId( 43 );
const QString EventComment( "Event-Comment 2" );
event.setComment( EventComment );
QVERIFY( m_storage->modifyEvent( event ) );
// verify task database entries
QVERIFY( m_storage->deleteTask( task ) );
EventList events = m_storage->getAllEvents();
QVERIFY( events.count() == 1 );
QVERIFY( events.first() == event );
}
/**
* \brief ocl::Image::copyToAsync Copies asynchronously from this Image to the destination Image.
*
* \param queue is a command queue on which the command is executed.
* \param src_origin is the 3D offset in bytes from which the Image is read.
* \param region is the 3D region of the data. It is given with {image_width, image_height, image_depth}.
* \param dest is the Image into which the data is going to be copied.
* \param dest_origin is the 3D offset in bytes from which the destionation Image is read.
* \param list contains all events for which this command has to wait.
* \return event which can be integrated into other EventList.
*/
ocl::Event ocl::Image::copyToAsync(const Queue &queue, size_t *src_origin, const size_t *region, const Image &dest, size_t *dest_origin, const EventList &list)
{
TRUE_ASSERT(this->context() == dest.context(), "Context of this and dest must be equal");
TRUE_ASSERT(queue.context() == *this->context(), "Context of queue and this must be equal");
cl_event event_id;
OPENCL_SAFE_CALL( clEnqueueCopyImage(queue.id(), this->id(), dest.id(),
src_origin, dest_origin, region, list.size(),
list.events().data(), &event_id) );
return ocl::Event(event_id, this->context());
}
/**
* \brief ocl::Image::copyToAsync Copies asynchronously from this Image to the destination Image.
*
* \param src_origin is the 3D offset in bytes from which the Image is read.
* \param region is the 3D region of the data. It is given with {image_width, image_height, image_depth}.
* \param dest is the Image into which the data is going to be copied.
* \param dest_origin is the 3D offset in bytes from which the destionation Image is read.
* \param list contains all events for which this command has to wait.
* \return event which can be integrated into other EventList.
*/
ocl::Event ocl::Image::copyToAsync(size_t *src_origin, const size_t *region, const Image &dest, size_t *dest_origin, const EventList &list)
{
TRUE_ASSERT(this->context() == dest.context(), "Context of this and dest must be equal");
TRUE_ASSERT(this->id() != dest.id(), "Images must not be equal this->id() " << this->id() << "; other.id " << dest.id());
cl_event event_id;
OPENCL_SAFE_CALL( clEnqueueCopyImage(this->activeQueue().id(), this->id(), dest.id(),
src_origin, dest_origin, region, list.size(),
list.events().data(), &event_id) );
return ocl::Event(event_id, this->context());
}
void Song::cmdResizePart(Track* track, Part* oPart, unsigned int len)/*{{{*/
{
{
startUndo();
MidiPart* nPart = new MidiPart(*(MidiPart*) oPart);
nPart->setLenTick(len);
// Indicate no undo, and do port controller values but not clone parts.
audio->msgChangePart(oPart, nPart, false, true, false);
// cut Events in nPart
// Changed by T356. Don't delete events if this is a clone part.
// The other clones might be longer than this one and need these events.
if (nPart->cevents()->arefCount() <= 1)
{
if (oPart->lenTick() > len)
{
EventList* el = nPart->events();
iEvent ie = el->lower_bound(len);
for (; ie != el->end();)
{
iEvent i = ie;
++ie;
// Indicate no undo, and do port controller values and clone parts.
audio->msgDeleteEvent(i->second, nPart, false, true, true);
}
}
}
/*
// cut Events in nPart
// Changed by T356. Don't delete events if this is a clone part.
// The other clones might be longer than this one and need these events.
if(oPart->cevents()->arefCount() <= 1)
{
if (oPart->lenTick() > len) {
EventList* el = nPart->events();
iEvent ie = el->lower_bound(len);
for (; ie != el->end();) {
iEvent i = ie;
++ie;
// Indicate no undo, and do not do port controller values and clone parts.
//audio->msgDeleteEvent(i->second, nPart, false);
audio->msgDeleteEvent(i->second, nPart, false, false, false);
}
}
}
// Indicate no undo, and do port controller values but not clone parts.
//audio->msgChangePart(oPart, nPart, false);
audio->msgChangePart(oPart, nPart, false, true, false);
*/
endUndo(SC_PART_MODIFIED);
}
}/*}}}*/
void Song::cmdGluePart(Track* track, Part* oPart)
{
PartList* pl = track->parts();
Part* nextPart = 0;
for (iPart ip = pl->begin(); ip != pl->end(); ++ip)
{
if (ip->second == oPart)
{
++ip;
if (ip == pl->end())
return;
nextPart = ip->second;
break;
}
}
Part* nPart = track->newPart(oPart);
nPart->setLenTick(nextPart->tick() + nextPart->lenTick() - oPart->tick());
// populate nPart with Events from oPart and nextPart
EventList* sl1 = oPart->events();
EventList* dl = nPart->events();
for (iEvent ie = sl1->begin(); ie != sl1->end(); ++ie)
dl->add(ie->second);
EventList* sl2 = nextPart->events();
//int frameOffset = nextPart->frame() - oPart->frame();
//for (iEvent ie = sl2->begin(); ie != sl2->end(); ++ie) {
// Event event = ie->second.clone();
// event.setFrame(event.frame() + frameOffset);
// dl->add(event);
// }
// p3.3.54 Changed.
{
int tickOffset = nextPart->tick() - oPart->tick();
for (iEvent ie = sl2->begin(); ie != sl2->end(); ++ie)
{
Event event = ie->second.clone();
event.setTick(event.tick() + tickOffset);
dl->add(event);
}
}
startUndo();
audio->msgRemovePart(nextPart, false);
// Indicate no undo, and do port controller values but not clone parts.
//audio->msgChangePart(oPart, nPart, false);
audio->msgChangePart(oPart, nPart, false, true, false);
endUndo(SC_PART_MODIFIED | SC_PART_REMOVED);
}
EventList EventsView::selectedEvents() const
{
EventList result;
const QModelIndexList &selectedItems = selectionModel()->selectedRows();
foreach (const QModelIndex &selectedItem, selectedItems)
{
EventData *eventData = selectedItem.data(EventsModel::EventDataPtr).value<EventData*>();
if (eventData)
result.append(*eventData);
}
int main(int argc, char **argv)
{
EventList eventlist;
ProcessList processes;
long ev_EndSimulation = 0;
Traverser traverser(&eventlist);
ColdTestCell cell1(&eventlist,&traverser);
ColdTestCell cell2(&eventlist, &traverser);
ColdTestCell cell3(&eventlist, &traverser);
Source supply(&eventlist, &traverser);
Sink derig(&eventlist);
processes.push_back(&traverser);
processes.push_back(&cell1);
processes.push_back(&cell2);
processes.push_back(&cell3);
processes.push_back(&supply);
processes.push_back(&derig);
// Connect up production layout
traverser.cell1(&cell1);
traverser.cell2(&cell2);
traverser.cell3(&cell3);
traverser.infeed(&supply);
traverser.outfeed(&derig);
// Initialise the processes
eventlist.push(new Event(100000,
nullptr,
ev_EndSimulation)); // End Simulation Event
bool change;
do {
change = false;
for (ProcessList::iterator i = processes.begin();
i != processes.end(); i++)
change |= (*i)->run(); // Run each process until no change
} while (change);
// Run the event management loop.
while (Event *event = eventlist.top()) {
eventlist.pop(); // Remove the top element from the list
SimulationTime += event->getTime(); // Advance simulation time
if (event->getEventType() == ev_EndSimulation)
break;
event->getProcess()->HandleEvent(event);
delete event; // no longer needed
}
}
/**
* \brief ocl::Image::map Maps the Image into the host memory.
*
* No data transfer is performed. Note that in order to map data of the Image the active queue must be a cpu and must have been allocated
* with the Image access mode AllocHost. You cannot modify the Image with OpenCL until unmap.
* \param ptr is returned and contains the address of a pointer to the host memory.
* \param origin is the 3D offset in bytes from which the image is read.
* \param region is the 3D region in bytes to be mapped.
* \param access specifies in what way the host_mem is used.
* \param list contains all events for which this command has to wait.
* \return event which can be integrated into other EventList
*/
ocl::Event ocl::Image::mapAsync(void **ptr, size_t *origin, const size_t *region, Memory::Access access, const EventList &list) const
{
TRUE_ASSERT(this->activeQueue().device().isCpu(), "Device " << this->activeQueue().device().name() << " is not a cpu!");
cl_int status;
cl_event event_id;
cl_map_flags flags = access;
*ptr = clEnqueueMapImage(this->activeQueue().id(), this->id(), CL_TRUE, flags,
origin, region, 0, 0, list.size(), list.events().data(), &event_id, &status);
OPENCL_SAFE_CALL (status ) ;
TRUE_ASSERT(ptr != NULL, "Could not map image!");
return ocl::Event(event_id, this->context());
}
/// Executes the algorithm for events
void UnaryOperation::execEvent() {
g_log.information("Processing event workspace");
const MatrixWorkspace_const_sptr matrixInputWS = getProperty(inputPropName());
// generate the output workspace pointer
API::MatrixWorkspace_sptr matrixOutputWS = getProperty(outputPropName());
if (matrixOutputWS != matrixInputWS) {
matrixOutputWS = MatrixWorkspace_sptr(matrixInputWS->clone().release());
setProperty(outputPropName(), matrixOutputWS);
}
auto outputWS = boost::dynamic_pointer_cast<EventWorkspace>(matrixOutputWS);
// Now fetch any properties defined by concrete algorithm
retrieveProperties();
int64_t numHistograms = static_cast<int64_t>(outputWS->getNumberHistograms());
API::Progress prog = API::Progress(this, 0.0, 1.0, numHistograms);
PARALLEL_FOR1(outputWS)
for (int64_t i = 0; i < numHistograms; ++i) {
PARALLEL_START_INTERUPT_REGION
// switch to weighted events if needed, and use the appropriate helper
// function
EventList *evlist = outputWS->getEventListPtr(i);
switch (evlist->getEventType()) {
case TOF:
// Switch to weights if needed.
evlist->switchTo(WEIGHTED);
/* no break */
// Fall through
case WEIGHTED:
unaryOperationEventHelper(evlist->getWeightedEvents());
break;
case WEIGHTED_NOTIME:
unaryOperationEventHelper(evlist->getWeightedEventsNoTime());
break;
}
prog.report();
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
outputWS->clearMRU();
auto inputWS = boost::dynamic_pointer_cast<EventWorkspace>(matrixOutputWS);
if (inputWS->getNumberEvents() != outputWS->getNumberEvents()) {
g_log.information() << "Number of events has changed!!!" << std::endl;
}
}
void Track::splitPart(Part* part, int tickpos, Part*& p1, Part*& p2)
{
int l1 = 0; // len of first new part (ticks or samples)
int l2 = 0; // len of second new part
int samplepos = tempomap.tick2frame(tickpos);
{
l1 = tickpos - part->tick();
l2 = part->lenTick() - l1;
}
if (l1 <= 0 || l2 <= 0)
return;
p1 = newPart(part); // new left part
p2 = newPart(part); // new right part
// Added by Tim. p3.3.6
//printf("Track::splitPart part ev %p sz:%d ref:%d p1 %p sz:%d ref:%d p2 %p sz:%d ref:%d\n", part->events(), part->events()->size(), part->events()->arefCount(), p1->events(), p1->events()->size(), p1->events()->arefCount(), p2->events(), p2->events()->size(), p2->events()->arefCount());
{
p1->setLenTick(l1);
p2->setTick(tickpos);
p2->setLenTick(l2);
}
p2->setSn(p2->newSn());
EventList* se = part->events();
EventList* de1 = p1->events();
EventList* de2 = p2->events();
p1->setColorIndex(part->colorIndex());
p2->setColorIndex(part->colorIndex());
{
for (iEvent ie = se->begin(); ie != se->end(); ++ie)
{
Event event = ie->second.clone();
int t = event.tick();
if (t >= l1)
{
event.move(-l1);
de2->add(event);
}
else
de1->add(event);
}
}
}
void EventListIntegration::a_hoster_stops_updating()
{
EventList testee;
const QString expected_user = "******";
const QString expected_event = "Beer";
testee.update_event(expected_user, expected_event);
IM::Events result = testee.get_active_events();
QCOMPARE(result.size(), 1);
QCOMPARE(result.first().nick_name, expected_user);
QCOMPARE(result.first().event_name, expected_event);
QSignalSpy block_and(this, SIGNAL(dummy()));
block_and.wait(4000);
testee.update_event(expected_user, expected_event);
result = testee.get_active_events();
QCOMPARE(result.size(), 1);
QCOMPARE(result.first().nick_name, expected_user);
QCOMPARE(result.first().event_name, expected_event);
block_and.wait(4000);
testee.update_event(expected_user, expected_event);
result = testee.get_active_events();
QCOMPARE(result.size(), 1);
QCOMPARE(result.first().nick_name, expected_user);
QCOMPARE(result.first().event_name, expected_event);
block_and.wait(7800);
result = testee.get_active_events();
QCOMPARE(result.size(), 0);
}
EventList*
EventList::allEventsForObject(QObject *widget)
{
if (!widget) return 0;
EventList *l = new EventList();
EventList::ConstIterator endIt = constEnd();
for (EventList::ConstIterator it = constBegin(); it != endIt; ++it) {
if (((*it)->sender() == widget) || ((*it)->receiver() == widget))
l->addEvent(*it);
}
return l;
}
QueueLoggerSampling::QueueLoggerSampling(simtime_picosec period, EventList &eventlist)
: EventSource(eventlist,"QueuelogSampling"),
_queue(NULL), _lastlook(0), _period(period), _lastq(0),
_seenQueueInD(false), _cumidle(0), _cumarr(0), _cumdrop(0)
{
eventlist.sourceIsPendingRel(*this,0);
}
/// Обновление
void UpdateEvent (const char* name, ResourceState state)
{
EventMap::iterator iter = event_map.find (name);
if (iter == event_map.end ())
{
EventPtr event = EventPtr (new EventDesc (name, state), false);
EventList::iterator iter = event_list.insert (event_list.end (), event);
event_map.insert_pair (name, iter);
}
else
{
EventPtr event = *iter->second;
if (state == event->state)
return;
if (event->state == ResourceState_Ignore)
{
event_list.splice (event_list.end (), event_list, iter->second);
event->state = state;
return;
}
switch (state)
{
case ResourceState_Unloaded:
event->state = ResourceState_Ignore;
break;
case ResourceState_Prefetched:
if (event->state != ResourceState_Unloaded)
return;
event_list.splice (event_list.end (), event_list, iter->second);
event->state = state;
break;
case ResourceState_Loaded:
if (event->state == ResourceState_Unloaded) event->state = ResourceState_Ignore;
else
{
event_list.splice (event_list.end (), event_list, iter->second);
event->state = state;
}
break;
default:
break;
}
}
}
/** Integrate all the spectra in the matrix workspace within the range given.
* Default implementation, can be overridden by base classes if they know
*something smarter!
*
* @param out :: returns the vector where there is one entry per spectrum in the
*workspace. Same
* order as the workspace indices.
* @param minX :: minimum X bin to use in integrating.
* @param maxX :: maximum X bin to use in integrating.
* @param entireRange :: set to true to use the entire range. minX and maxX are
*then ignored!
*/
void EventWorkspace::getIntegratedSpectra(std::vector<double> &out,
const double minX, const double maxX,
const bool entireRange) const {
// Start with empty vector
out.resize(this->getNumberHistograms(), 0.0);
// We can run in parallel since there is no cross-reading of event lists
PARALLEL_FOR_NO_WSP_CHECK()
for (int wksp_index = 0; wksp_index < int(this->getNumberHistograms());
wksp_index++) {
// Get Handle to data
EventList *el = this->data[wksp_index];
// Let the eventList do the integration
out[wksp_index] = el->integrate(minX, maxX, entireRange);
}
}
/*
* This function checks if there is free terminal
* and generates arrival if there is free terminal
*/
static void generateArrEvent(int numTerminals)
{
if((countInfo.terminalPool>0) && (countInfo.terminalPool<=numTerminals))
{
Elist.insert(clock + exp_rv(configInfo.arrivalRate),ARR);
countInfo.terminalPool--;
}
}
void CtEvent::getEventList(EventList& event_list)
{
DEB_MEMBER_FUNCT();
AutoMutex l = lock();
DEB_PARAM() << DEB_VAR2(event_list.size(), m_event_list.size());
if (!event_list.empty())
THROW_CTL_ERROR(InvalidValue) << "Not empty event_list ("
<< DEB_VAR1(event_list.size()) << "): "
<< "Where all the events deleted?";
else if (hasRegisteredCallback())
DEB_WARNING() << "An EventCallback is registered, events are dispatched";
event_list = m_event_list;
m_event_list.clear();
}
std::vector<double> beatTrack(const AgentParameters ¶ms,
const EventList &events,
const EventList &beats)
{
AgentList agents;
int count = 0;
double beatTime = -1;
if (!beats.empty()) {
count = beats.size() - 1;
EventList::const_iterator itr = beats.end();
--itr;
beatTime = itr->time;
}
if (count > 0) { // tempo given by mean of initial beats
double ioi = (beatTime - beats.begin()->time) / count;
agents.push_back(new Agent(params, ioi));
}
else // tempo not given; use tempo induction
agents = Induction::beatInduction(params, events);
if (!beats.empty()) {
for (AgentList::iterator itr = agents.begin(); itr != agents.end(); ++itr) {
(*itr)->beatTime = beatTime;
(*itr)->beatCount = count;
(*itr)->events = beats;
}
}
agents.beatTrack(events, params, -1);
Agent *best = agents.bestAgent();
std::vector<double> resultBeatTimes;
if (best) {
best->fillBeats(beatTime);
for (EventList::const_iterator itr = best->events.begin();
itr != best->events.end(); ++itr) {
resultBeatTimes.push_back(itr->time);
}
}
for (AgentList::iterator ai = agents.begin(); ai != agents.end(); ++ai) {
delete *ai;
}
return resultBeatTimes;
}
void EventList::append(const EventList& other)
{
for(size_t i = 0; i < other.size(); ++i)
{
cl_event e = other._events[i];
clRetainEvent(e);
_events.push_back(e);
}
}
void EventQueue::InsertEvent( Event *event, ncycle_t when, int priority )
{
event->SetCycle( when );
/* If this event time is before our previous nextEventCycle, change it. */
if( when < nextEventCycle )
{
nextEventCycle = when;
}
/* If there are no events at this time, create a new mapping. */
if( eventMap.count( when ) == 0 )
{
EventList eventList;
eventList.push_back( event );
eventMap.insert( std::pair<ncycle_t, EventList>( when, eventList ) );
}
/* Otherwise append this event to the event list for this cycle. */
else
{
EventList& eventList = eventMap[when];
EventList::iterator it;
bool inserted = false;
for( it = eventList.begin(); it != eventList.end(); it++ )
{
if( (*it)->GetPriority( ) > priority )
{
eventList.insert( it, event );
inserted = true;
break;
}
}
if( !inserted )
{
eventList.push_back( event );
}
}
}
int CEventListHandler::exec(CMenuTarget* parent, const std::string &/*actionKey*/)
{
int res = menu_return::RETURN_REPAINT;
EventList *e;
CChannelList *channelList;
if (parent)
parent->hide();
e = new EventList;
channelList = CNeutrinoApp::getInstance()->channelList;
e->exec(live_channel_id, channelList->getActiveChannelName()); // UTF-8
delete e;
return res;
}
// In specific order many at a time:
bool waitForEventList(const EventList& evts, Duration timeout=Duration::seconds(5)) {
for(uint idx = 0; idx < evts.size(); idx++) {
Event read_evt;
bool got_event = _events.blockingPop(read_evt, timeout);
TS_ASSERT(got_event);
if (!got_event) return false;
TS_ASSERT_EQUALS(evts[idx], read_evt);
if (evts[idx] != read_evt) return false;
}
return true;
}
void AgentList::beatTrack(const EventList &el,
const AgentParameters ¶ms,
double stop)
{
EventList::const_iterator ei = el.begin();
bool phaseGiven = !empty() && ((*begin())->beatTime >= 0); // if given for one, assume given for others
while (ei != el.end()) {
Event ev = *ei;
++ei;
if ((stop > 0) && (ev.time > stop))
break;
bool created = phaseGiven;
double prevBeatInterval = -1.0;
// cc: Duplicate our list of agents, and scan through the
// copy. This means we can safely add agents to our own
// list while scanning without disrupting our scan. Each
// agent needs to be re-added to our own list explicitly
// (since it is modified by e.g. considerAsBeat)
Container currentAgents = list;
list.clear();
for (Container::iterator ai = currentAgents.begin();
ai != currentAgents.end(); ++ai) {
Agent *currentAgent = *ai;
if (currentAgent->beatInterval != prevBeatInterval) {
if ((prevBeatInterval >= 0) && !created && (ev.time < 5.0)) {
// Create new agent with different phase
Agent *newAgent = new Agent(params, prevBeatInterval);
// This may add another agent to our list as well
newAgent->considerAsBeat(ev, *this);
add(newAgent);
}
prevBeatInterval = currentAgent->beatInterval;
created = phaseGiven;
}
if (currentAgent->considerAsBeat(ev, *this))
created = true;
add(currentAgent);
} // loop for each agent
removeDuplicates();
} // loop for each event
}
//-------------------------------------------- Constructeurs - destructeur
EventList::EventList ( const EventList & aEventList )
// Algorithme :
//
{
#ifdef MAPD
cout << "Appel au constructeur de copie de <EventList>" << endl;
#endif
root = aEventList.GetRoot();
nbEvents = 0;
} //----- Fin de EventList (constructeur de copie)
int Game::Run()
{
EventList eventList;
this->window->setFramerateLimit(60);
//clock.restart();
sf::Time elapsed = clock.restart();
while ( this->window->isOpen() )
{
sf::Event event;
while ( window->pollEvent(event) )
{
if ( event.type == sf::Event::Closed )
window->close();
// else if ( event.type = sf::Event::Resized )
// this->windowResized = true;
else
eventList.insert( std::pair< sf::Event::EventType,sf::Event >( event.type,event ) );
}
window->clear();
this->Update( elapsed , &eventList );
this->Draw();
this->window->display();
eventList.clear();
elapsed = clock.restart();
}
return 0;
}
void EventWorkspace::init(const HistogramData::Histogram &histogram) {
if (histogram.xMode() != HistogramData::Histogram::XMode::BinEdges)
throw std::runtime_error(
"EventWorkspace can only be initialized with XMode::BinEdges");
if (histogram.sharedY() || histogram.sharedE())
throw std::runtime_error(
"EventWorkspace cannot be initialized non-NULL Y or E data");
data.resize(numberOfDetectorGroups(), nullptr);
EventList el;
el.setHistogram(histogram);
for (size_t i = 0; i < data.size(); i++) {
data[i] = new EventList(el);
data[i]->setMRU(mru);
data[i]->setSpectrumNo(specnum_t(i));
}
m_axes.resize(2);
m_axes[0] = new API::RefAxis(this);
m_axes[1] = new API::SpectraAxis(this);
}
void tst_QQuickAccessible::cleanup()
{
const EventList list = QTestAccessibility::events();
if (!list.isEmpty()) {
qWarning("%d accessibility event(s) were not handled in testfunction '%s':", list.count(),
QString(QTest::currentTestFunction()).toLatin1().constData());
for (int i = 0; i < list.count(); ++i)
qWarning(" %d: Object: %p Event: '%s' Child: %d", i + 1, list.at(i)->object(),
qAccessibleEventString(list.at(i)->type()), list.at(i)->child());
}
QTestAccessibility::clearEvents();
}
