comparison base/EventSeries.cpp @ 1796:ff8c57c364a0

Make EventSeries threadsafe

     COPYING included with this distribution for more information.
 */
 
 #include "EventSeries.h"
 
+#include <QMutexLocker>
+
+EventSeries::EventSeries(const EventSeries &other) :
+    EventSeries(other, QMutexLocker(&other.m_mutex))
+{
+}
+
+EventSeries::EventSeries(const EventSeries &other, const QMutexLocker &) :
+    m_events(other.m_events),
+    m_seams(other.m_seams),
+    m_finalDurationlessEventFrame(other.m_finalDurationlessEventFrame)
+{
+}
+
+EventSeries &
+EventSeries::operator=(const EventSeries &other)
+{
+    QMutexLocker locker(&m_mutex), otherLocker(&other.m_mutex);
+    m_events = other.m_events;
+    m_seams = other.m_seams;
+    m_finalDurationlessEventFrame = other.m_finalDurationlessEventFrame;
+    return *this;
+}
+
+EventSeries &
+EventSeries::operator=(EventSeries &&other)
+{
+    QMutexLocker locker(&m_mutex), otherLocker(&other.m_mutex);
+    m_events = std::move(other.m_events);
+    m_seams = std::move(other.m_seams);
+    m_finalDurationlessEventFrame = std::move(other.m_finalDurationlessEventFrame);
+    return *this;
+}
+
+bool
+EventSeries::operator==(const EventSeries &other) const
+{
+    QMutexLocker locker(&m_mutex);
+    return m_events == other.m_events;
+}
+
 EventSeries
 EventSeries::fromEvents(const EventVector &v)
 {
     EventSeries s;
     for (const auto &e: v) {

 }
 
 bool
 EventSeries::isEmpty() const
 {
+    QMutexLocker locker(&m_mutex);
     return m_events.empty();
 }
 
 int
 EventSeries::count() const
 {
+    QMutexLocker locker(&m_mutex);
     if (m_events.size() > INT_MAX) {
         throw std::logic_error("too many events");
     }
     return int(m_events.size());
 }
 
 void
 EventSeries::add(const Event &p)
 {
+    QMutexLocker locker(&m_mutex);
+
     bool isUnique = true;
 
     auto pitr = lower_bound(m_events.begin(), m_events.end(), p);
     if (pitr != m_events.end() && *pitr == p) {
         isUnique = false;

 }
 
 void
 EventSeries::remove(const Event &p)
 {
+    QMutexLocker locker(&m_mutex);
+
     // If we are removing the last (unique) example of an event,
     // then we also need to remove it from the seam map. If this
     // is only one of multiple identical events, then we don't.
     bool isUnique = true;
         

 }
 
 bool
 EventSeries::contains(const Event &p) const
 {
+    QMutexLocker locker(&m_mutex);
     return binary_search(m_events.begin(), m_events.end(), p);
 }
 
 void
 EventSeries::clear()
 {
+    QMutexLocker locker(&m_mutex);
     m_events.clear();
     m_seams.clear();
     m_finalDurationlessEventFrame = 0;
 }
 
 sv_frame_t
 EventSeries::getStartFrame() const
 {
+    QMutexLocker locker(&m_mutex);
     if (m_events.empty()) return 0;
     return m_events.begin()->getFrame();
 }
 
 sv_frame_t
 EventSeries::getEndFrame() const
 {
+    QMutexLocker locker(&m_mutex);
+
     sv_frame_t latest = 0;
 
     if (m_events.empty()) return latest;
     
     latest = m_finalDurationlessEventFrame;

 
 EventVector
 EventSeries::getEventsSpanning(sv_frame_t frame,
                                sv_frame_t duration) const
 {
+    QMutexLocker locker(&m_mutex);
+
     EventVector span;
     
     const sv_frame_t start = frame;
     const sv_frame_t end = frame + duration;
         

 EventVector
 EventSeries::getEventsWithin(sv_frame_t frame,
                              sv_frame_t duration,
                              int overspill) const
 {
+    QMutexLocker locker(&m_mutex);
+
     EventVector span;
     
     const sv_frame_t start = frame;
     const sv_frame_t end = frame + duration;
 

 
 EventVector
 EventSeries::getEventsStartingWithin(sv_frame_t frame,
                                      sv_frame_t duration) const
 {
+    QMutexLocker locker(&m_mutex);
+
     EventVector span;
     
     const sv_frame_t start = frame;
     const sv_frame_t end = frame + duration;
 

 }
 
 EventVector
 EventSeries::getEventsCovering(sv_frame_t frame) const
 {
+    QMutexLocker locker(&m_mutex);
+
     EventVector cover;
 
     // first find any zero-duration events
 
     auto pitr = lower_bound(m_events.begin(), m_events.end(),

 }
 
 EventVector
 EventSeries::getAllEvents() const
 {
+    QMutexLocker locker(&m_mutex);
+
     return m_events;
 }
 
 bool
 EventSeries::getEventPreceding(const Event &e, Event &preceding) const
 {
+    QMutexLocker locker(&m_mutex);
+
     auto pitr = lower_bound(m_events.begin(), m_events.end(), e);
     if (pitr == m_events.end() || *pitr != e) {
         return false;
     }
     if (pitr == m_events.begin()) {

 }
 
 bool
 EventSeries::getEventFollowing(const Event &e, Event &following) const
 {
+    QMutexLocker locker(&m_mutex);
+
     auto pitr = lower_bound(m_events.begin(), m_events.end(), e);
     if (pitr == m_events.end() || *pitr != e) {
         return false;
     }
     while (*pitr == e) {

 EventSeries::getNearestEventMatching(sv_frame_t startSearchAt,
                                      std::function<bool(const Event &)> predicate,
                                      Direction direction,
                                      Event &found) const
 {
+    QMutexLocker locker(&m_mutex);
+
     auto pitr = lower_bound(m_events.begin(), m_events.end(),
                             Event(startSearchAt));
 
     while (true) {
 

 }
 
 Event
 EventSeries::getEventByIndex(int index) const
 {
+    QMutexLocker locker(&m_mutex);
+
     if (index < 0 || index >= count()) {
         throw std::logic_error("index out of range");
     }
     return m_events[index];
 }
 
 int
 EventSeries::getIndexForEvent(const Event &e) const
 {
+    QMutexLocker locker(&m_mutex);
+
     auto pitr = lower_bound(m_events.begin(), m_events.end(), e);
     auto d = distance(m_events.begin(), pitr);
     if (d < 0 || d > INT_MAX) return 0;
     return int(d);
 }

 void
 EventSeries::toXml(QTextStream &out,
                    QString indent,
                    QString extraAttributes) const
 {
-    toXml(out, indent, extraAttributes, Event::ExportNameOptions());
+    QMutexLocker locker(&m_mutex);
+
+    out << indent << QString("<dataset id=\"%1\" %2>\n")
+        .arg(getExportId())
+        .arg(extraAttributes);
+    
+    for (const auto &p: m_events) {
+        p.toXml(out, indent + "  ", "", {});
+    }
+    
+    out << indent << "</dataset>\n";
 }
 
 void
 EventSeries::toXml(QTextStream &out,
                    QString indent,
                    QString extraAttributes,
                    Event::ExportNameOptions options) const
 {
+    QMutexLocker locker(&m_mutex);
+
     out << indent << QString("<dataset id=\"%1\" %2>\n")
         .arg(getExportId())
         .arg(extraAttributes);
     
     for (const auto &p: m_events) {

                                    sv_frame_t duration,
                                    sv_samplerate_t sampleRate,
                                    sv_frame_t resolution,
                                    Event fillEvent) const
 {
+    QMutexLocker locker(&m_mutex);
+
     QString s;
 
     const sv_frame_t end = startFrame + duration;
 
     auto pitr = lower_bound(m_events.begin(), m_events.end(),