MNE-CPP  0.1.9
A Framework for Electrophysiology
eventmanager.cpp
1 //=============================================================================================================
36 //=============================================================================================================
37 // INCLUDES
38 //=============================================================================================================
39 
40 #include "eventmanager.h"
41 
42 //=============================================================================================================
43 // QT INCLUDES
44 //=============================================================================================================
45 
46 #include <QDebug>
47 
48 
49 //=============================================================================================================
50 // USED NAMESPACES
51 //=============================================================================================================
52 
53 using namespace EVENTSLIB;
54 
55 //=============================================================================================================
56 // local and static declarations
57 //=============================================================================================================
58 
59 constexpr static int invalidID(0);
60 static std::string defaultGroupName("Default");
62 //=============================================================================================================
63 
65 : m_pSharedMemManager(std::make_unique<EVENTSINTERNAL::EventSharedMemManager>(this))
66 , m_iEventIdCounter(invalidID)
67 , m_iGroupIdCounter(invalidID)
68 , m_bDefaultGroupNotCreated(true)
69 , m_DefaultGroupId(invalidID)
70 {
71 
72 }
73 
74 //=============================================================================================================
75 
76 Event EventManager::getEvent(idNum eventId) const
77 {
78  auto eventInt = findEventINT(eventId);
79  if(eventInt != m_EventsListBySample.end())
80  {
81  return Event(eventInt->second);
82  }
83  return {};
84 }
85 
86 //=============================================================================================================
87 
88 std::multimap<int, EVENTSINTERNAL::EventINT>::const_iterator EventManager::findEventINT(idNum eventId) const
89 {
90  int sample = m_MapIdToSample.at(eventId);
91  auto eventsRange = m_EventsListBySample.equal_range(sample);
92  for(auto e = eventsRange.first; e != eventsRange.second; ++e)
93  {
94  if( e->second.getId() == eventId)
95  {
96  return e;
97  }
98  }
99  return m_EventsListBySample.end();
100 }
101 
102 //=============================================================================================================
103 
104 std::unique_ptr<std::vector<Event> >
105 EventManager::getEvents(const std::vector<idNum> eventIds) const
106 {
107  auto pEventsList(allocateOutputContainer<Event>(eventIds.size()));
108  for (const auto& id: eventIds)
109  {
110  auto event = getEvent(id);
111  if(event.id != invalidID)
112  {
113  pEventsList->push_back(event);
114  }
115  }
116  return pEventsList;
117 }
118 
119 //=============================================================================================================
120 
121 std::unique_ptr<std::vector<Event> > EventManager::getAllEvents() const
122 {
123  auto pEventsList(allocateOutputContainer<Event>(getNumEvents()));
124  for(auto& e: m_EventsListBySample)
125  {
126  pEventsList->emplace_back(Event(e.second));
127  }
128  return pEventsList;
129 }
130 
131 //=============================================================================================================
132 
133 std::unique_ptr<std::vector<Event> > EventManager::getEventsInSample(int sample) const
134 {
135  size_t numEventsInSample = m_EventsListBySample.count(sample);
136  auto pEventsList(allocateOutputContainer<Event>(numEventsInSample));
137 
138  auto eventsRange = m_EventsListBySample.equal_range(sample);
139  for(auto e = eventsRange.first; e != eventsRange.second; e++)
140  {
141  pEventsList->emplace_back(Event(e->second));
142  }
143  return pEventsList;
144 }
145 
146 //=============================================================================================================
147 
148 std::unique_ptr<std::vector<Event> >
149 EventManager::getEventsBetween(int sampleStart, int sampleEnd) const
150 {
151  int memoryHint = ((sampleEnd-sampleStart)/1000)+2;
152  auto pEventsList(allocateOutputContainer<Event>(memoryHint));
153 
154  auto eventStart = m_EventsListBySample.lower_bound(sampleStart);
155  auto eventEnd = m_EventsListBySample.upper_bound(sampleEnd);
156 
157  for(auto e = eventStart; e != eventEnd; e++)
158  {
159  pEventsList->emplace_back(Event(e->second));
160  }
161  return pEventsList;
162 }
163 
164 //=============================================================================================================
165 
166 std::unique_ptr<std::vector<Event> >
167 EventManager::getEventsBetween(int sampleStart, int sampleEnd, idNum groupId) const
168 {
169  int memoryHint = ((sampleEnd-sampleStart)/1000)+2;
170  auto pEventsList(allocateOutputContainer<Event>(memoryHint));
171 
172  auto eventStart = m_EventsListBySample.lower_bound(sampleStart);
173  auto eventEnd = m_EventsListBySample.upper_bound(sampleEnd);
174 
175  for(auto e = eventStart; e != eventEnd; e++)
176  {
177  if(e->second.getGroupId() == groupId)
178  {
179  pEventsList->emplace_back(Event(e->second));
180  }
181  }
182  return pEventsList;
183 }
184 
185 //=============================================================================================================
186 
187 std::unique_ptr<std::vector<Event> >
188 EventManager::getEventsBetween(int sampleStart, int sampleEnd, const std::vector<idNum>& groupIdsList) const
189 {
190  int memoryHint = (sampleEnd-sampleStart)/200;
191  auto pEventsList(allocateOutputContainer<Event>(memoryHint));
192 
193 
194  auto eventStart = m_EventsListBySample.lower_bound(sampleStart);
195  auto eventEnd = m_EventsListBySample.upper_bound(sampleEnd);
196 
197  for(auto e = eventStart; e != eventEnd; e++)
198  {
199  for(auto& groupId: groupIdsList)
200  {
201  if(e->second.getGroupId() == groupId)
202  {
203  pEventsList->emplace_back(Event(e->second));
204  }
205  }
206  }
207  return pEventsList;
208 }
209 
210 //=============================================================================================================
211 
212 std::unique_ptr<std::vector<Event> >
213 EventManager::getEventsInGroup(const idNum groupId) const
214 {
215  auto pEventsList(allocateOutputContainer<Event>());
216 
217  for(const auto& e: m_EventsListBySample)
218  {
219  if(e.second.getGroupId() == groupId)
220  {
221  pEventsList->emplace_back(Event(e.second));
222  }
223  }
224  return pEventsList;
225 }
226 
227 //=============================================================================================================
228 
229 std::unique_ptr<std::vector<Event> > EventManager::getEventsInGroups(const std::vector<idNum>& groupIdsList) const
230 {
231  auto pEventsList(allocateOutputContainer<Event>());
232 
233  for(const auto& e: m_EventsListBySample)
234  {
235  for (const auto groupId : groupIdsList)
236  {
237  if(e.second.getGroupId() == groupId)
238  {
239  pEventsList->emplace_back(Event(e.second));
240  break;
241  }
242  }
243  }
244 
245  return pEventsList;
246 }
247 
248 //=============================================================================================================
249 
250 idNum EventManager::generateNewEventId()
251 {
252  return ++m_iEventIdCounter;
253 }
254 
255 //=============================================================================================================
256 
257 idNum EventManager::generateNewGroupId()
258 {
259  return ++m_iGroupIdCounter;
260 }
261 
262 //=============================================================================================================
263 
265 {
266  return m_EventsListBySample.size();
267 }
268 
269 //=============================================================================================================
270 
271 Event EventManager::addEvent(int sample, idNum groupId)
272 {
273  EVENTSINTERNAL::EventINT newEvent(generateNewEventId(), sample, groupId);
274  insertEvent(newEvent);
275 
276  if(m_pSharedMemManager->isInit())
277  {
278  qDebug() << "Sending event to SM: Sample: " << sample;
279  m_pSharedMemManager->addEvent(newEvent.getSample());
280  }
281 
282  return Event(newEvent);
283 }
284 
285 //=============================================================================================================
286 
288 {
289  createDefaultGroupIfNeeded();
290  return addEvent(sample, m_DefaultGroupId);
291 }
292 
293 //=============================================================================================================
294 
295 bool EventManager::moveEvent(idNum eventId, int newSample)
296 {
297  bool status(false);
298  auto event = findEventINT(eventId);
299  if(event != m_EventsListBySample.end())
300  {
301  EVENTSINTERNAL::EventINT newEvent(event->second);
302  newEvent.setSample(newSample);
303  deleteEvent(eventId);
304  insertEvent(newEvent);
305  status = true;
306  }
307  return status;
308 }
309 
310 //=============================================================================================================
311 
312 bool EventManager::deleteEvent(idNum eventId) noexcept
313 {
314  bool eventFound(false);
315  eventFound = eraseEvent(eventId);
316  if(eventFound && m_pSharedMemManager->isInit())
317  {
318  m_pSharedMemManager->deleteEvent(m_MapIdToSample.at(eventId));
319  }
320  return eventFound;
321 }
322 
323 //=============================================================================================================
324 
325 bool EventManager::eraseEvent(idNum eventId)
326 {
327  auto event = findEventINT(eventId);
328  if(event != m_EventsListBySample.end())
329  {
330  m_EventsListBySample.erase(event);
331  m_MapIdToSample.erase(eventId);
332  return true;
333  }
334  return false;
335 }
336 
337 //=============================================================================================================
338 
339 bool EventManager::deleteEvents(const std::vector<idNum>& eventIds)
340 {
341  bool status(eventIds.size());
342  for(const auto& id: eventIds)
343  {
344  status = status && deleteEvent(id);
345  }
346  return status;
347 }
348 
349 //=============================================================================================================
350 
351 bool EventManager::deleteEvents(std::unique_ptr<std::vector<Event> > eventIds)
352 {
353  bool status(eventIds->size());
354  for(auto e: *eventIds){
355  status = status && deleteEvent(e.id);
356  }
357  return status;
358 }
359 
360 //=============================================================================================================
361 
363 {
364  std::vector<idNum> idList;
365  for(auto& e: m_EventsListBySample)
366  {
367  if(e.second.getGroupId() == groupId)
368  {
369  idList.emplace_back(e.second.getId());
370  }
371  }
372  return deleteEvents(idList);
373 }
374 
375 //=============================================================================================================
376 
377 void EventManager::insertEvent(const EVENTSINTERNAL::EventINT& e)
378 {
379  m_EventsListBySample.emplace(std::make_pair(e.getSample(),e));
380  m_MapIdToSample[e.getId()] = e.getSample();
381 }
382 
383 //=============================================================================================================
384 
386 {
387  return (int)(m_GroupsList.size());
388 }
389 
390 //=============================================================================================================
391 
392 EventGroup EventManager::getGroup(const idNum groupId) const
393 {
394  auto groupFound = m_GroupsList.find(groupId);
395  if(groupFound != m_GroupsList.end())
396  {
397  return EventGroup(groupFound->second);
398  } else
399  {
400  return {};
401  }
402 }
403 
404 //=============================================================================================================
405 
406 std::unique_ptr<std::vector<EventGroup> > EventManager::getAllGroups() const
407 {
408  size_t numGroups(m_GroupsList.size());
409  auto pGroupsList(allocateOutputContainer<EventGroup>(numGroups));
410  for(const auto& g: m_GroupsList)
411  {
412  pGroupsList->emplace_back(EventGroup(g.second));
413  }
414  return pGroupsList;
415 }
416 
417 //=============================================================================================================
418 
419 std::unique_ptr<std::vector<EventGroup> >
420 EventManager::getGroups(const std::vector<idNum>& groupIds) const
421 {
422  auto pGroupList(allocateOutputContainer<EventGroup>(groupIds.size()));
423  for(const auto& id: groupIds)
424  {
425  auto group = getGroup(id);
426  if (group.id != invalidID)
427  {
428  pGroupList->push_back(group);
429  }
430  }
431  return pGroupList;
432 }
433 
434 //=============================================================================================================
435 
436 EventGroup EventManager::addGroup(const std::string& sGroupName)
437 {
438  EVENTSINTERNAL::EventGroupINT newGroup(generateNewGroupId(), sGroupName);
439  m_GroupsList.emplace(newGroup.getId(), newGroup);
440  return EventGroup(newGroup);
441 }
442 
443 //=============================================================================================================
444 
445 EventGroup EventManager::addGroup(const std::string& sGroupName, const RgbColor& color)
446 {
447  EVENTSINTERNAL::EventGroupINT newGroup(generateNewGroupId(), sGroupName, color);
448  m_GroupsList.emplace(newGroup.getId(), newGroup);
449  return EventGroup(newGroup);
450 }
451 
452 //=============================================================================================================
453 
454 bool EventManager::deleteGroup(const idNum groupId)
455 {
456  bool out(false);
457  auto events = getEventsInGroup(groupId);
458  if(events->empty())
459  {
460  auto groupToDeleteIter = m_GroupsList.find(groupId);
461  if(groupToDeleteIter != m_GroupsList.end())
462  {
463  m_GroupsList.erase(groupToDeleteIter);
464  out = true;
465  if(!m_bDefaultGroupNotCreated && (groupId == m_DefaultGroupId))
466  {
467  m_bDefaultGroupNotCreated = true;
468  m_DefaultGroupId = invalidID;
469  }
470  }
471  }
472  return out;
473 }
474 
475 //=============================================================================================================
476 
477 bool EventManager::deleteGroups(const std::vector<idNum>& groupIds)
478 {
479  bool out(groupIds.size());
480  for(auto g: groupIds)
481  {
482  out = out && deleteGroup(g);
483  }
484  return out;
485 }
486 
487 //=============================================================================================================
488 
489 void EventManager::renameGroup(const idNum groupId, const std::string& newName)
490 {
491  auto group = m_GroupsList.find(groupId);
492  if(group != m_GroupsList.end())
493  {
494  group->second.setName(newName);
495  }
496 }
497 
498 //=============================================================================================================
499 
500 void EventManager::setGroupColor(const idNum groupId, const RgbColor& color)
501 {
502  auto group = m_GroupsList.find(groupId);
503  if( group != m_GroupsList.end())
504  {
505  group->second.setColor(color);
506  }
507 }
508 
509 //=============================================================================================================
510 
511 EventGroup EventManager::mergeGroups(const std::vector<idNum>& groupIds, const std::string& newName)
512 {
513  EVENTSLIB::EventGroup newGroup = addGroup(newName);
514  auto eventsAll = getAllEvents();
515  bool state(true);
516  for(const auto& ev: *eventsAll)
517  {
518  for(auto g: groupIds)
519  {
520  if(ev.groupId == g)
521  {
522  state = state && addEventToGroup(ev.id, newGroup.id);
523  }
524  }
525  }
526  deleteGroups(groupIds);
527  return newGroup;
528 }
529 
530 //=============================================================================================================
531 
532 EventGroup EventManager::duplicateGroup(const idNum groupId, const std::string& newName)
533 {
534  EVENTSLIB::EventGroup newGroup = addGroup(newName);
535  auto eventsToDuplicate = getEventsInGroup(groupId);
536  for( const auto& e: *eventsToDuplicate)
537  {
538  addEvent(e.sample, newGroup.id);
539  }
540  return newGroup;
541 }
542 
543 //=============================================================================================================
544 
545 bool EventManager::addEventToGroup(const idNum eventId, const idNum groupId)
546 {
547  bool state(false);
548  int sample(0);
549  if(m_MapIdToSample.count(eventId))
550  {
551  sample = m_MapIdToSample.at(eventId);
552  auto eventsRange = m_EventsListBySample.equal_range(sample);
553  std::multimap<int, EVENTSINTERNAL::EventINT>::iterator e = eventsRange.first;
554  for(; e != eventsRange.second; ++e)
555  {
556  if( e->second.getId() == eventId)
557  {
558  e->second.setGroupId(groupId);
559  state = true;
560  break;
561  }
562  }
563  }
564  return state;
565 }
566 
567 //=============================================================================================================
568 
569 bool EventManager::addEventsToGroup(const std::vector<idNum>& eventIds, const idNum groupId)
570 {
571  bool state(true);
572  for( idNum id: eventIds)
573  {
574  state = state && addEventToGroup(id, groupId);
575  }
576  return state;
577 }
578 
579 //=============================================================================================================
580 
582 {
583  initSharedMemory(SharedMemoryMode::READ);
584 }
585 
586 //=============================================================================================================
587 
588 void EventManager::initSharedMemory(SharedMemoryMode mode)
589 {
590  m_pSharedMemManager->init(mode);
591 }
592 
593 //=============================================================================================================
594 
596 {
597  m_pSharedMemManager->stop();
598 }
599 
600 //=============================================================================================================
601 
603 {
604  return m_pSharedMemManager->isInit();
605 }
606 
607 void EventManager::createDefaultGroupIfNeeded()
608 {
609  if(m_bDefaultGroupNotCreated)
610  {
611  EventGroup defaultGroup(addGroup(defaultGroupName));
612  m_bDefaultGroupNotCreated = false;
613  m_DefaultGroupId = defaultGroup.id;
614  }
615 }
EventGroup mergeGroups(const std::vector< idNum > &groupIds, const std::string &newName)
std::unique_ptr< std::vector< Event > > getEventsInSample(int sample) const
EventManager declaration.
Event getEvent(idNum eventId) const
bool deleteEventsInGroup(idNum groupId)
bool deleteEvent(idNum eventId) noexcept
Event addEvent(int sample)
bool deleteGroup(const idNum groupId)
bool moveEvent(idNum eventId, int newSample)
bool addEventToGroup(const idNum eventId, const idNum groupId)
void setGroupId(idNum iGroup)
Definition: event.cpp:139
bool deleteGroups(const std::vector< idNum > &groupIds)
std::unique_ptr< std::vector< EventGroup > > getGroups(const std::vector< idNum > &groupIds) const
size_t getNumEvents() const
void renameGroup(const idNum groupId, const std::string &newName)
EventGroup duplicateGroup(const idNum groupId, const std::string &newName)
the class stores the concept of an event group internally in the Event library.
Definition: eventgroup.h:154
EventGroup addGroup(const std::string &sGroupName)
Definition: event.h:282
EventGroup class is designed as a data holder for a group. It is designed towards ease of use for a c...
Definition: eventgroup.h:116
std::unique_ptr< std::vector< Event > > getEventsInGroups(const std::vector< idNum > &groupIdsList) const
std::unique_ptr< std::vector< Event > > getEventsInGroup(const idNum groupId) const
std::unique_ptr< std::vector< Event > > getAllEvents() const
std::unique_ptr< std::vector< EventGroup > > getAllGroups() const
bool deleteEvents(const std::vector< idNum > &eventIds)
std::unique_ptr< std::vector< Event > > getEventsBetween(int sampleStart, int sampleEnd) const
std::unique_ptr< std::vector< Event > > getEvents(const std::vector< idNum > eventIds) const
void setGroupColor(const idNum groupId, const RgbColor &color)
EventGroup getGroup(idNum groupId) const
bool addEventsToGroup(const std::vector< idNum > &eventIds, const idNum groupId)