comparison base/EventSeries.h @ 1625:7dbb2a7b592e single-point

That last change didn't seem worthwhile

 #define SV_EVENT_SERIES_H
 
 #include "Event.h"
 
 #include <set>
-
-#include <QHash>
-#include <QMap>
 
 //#define DEBUG_EVENT_SERIES 1
 
 /**
  * Container storing a series of events, with or without durations,

                     SVCERR << "ERROR: EventSeries::add: "
                            << "reached end of seam map"
                            << endl;
                     break;
                 }
-                i.value().insert(p);
+                i->second.insert(p);
             }
         }
 
 #ifdef DEBUG_EVENT_SERIES
         std::cerr << "after add:" << std::endl;

         
         auto pitr = m_events.find(p);
         if (pitr == m_events.end()) {
             return; // we don't know this event
         } else {
-            if (--(pitr.value()) == 0) {
+            if (--(pitr->second) == 0) {
                 isUnique = true;
                 m_events.erase(pitr);
             }
             --m_count;
         }

                     // This can happen only if we have a negative
                     // duration, which Event forbids
                     throw std::logic_error("unexpectedly reached end of map");
                 }
                 
-                i.value().remove(p);
+                i->second.erase(p);
             }
 
             // Tidy up by removing any entries that are now identical
             // to their predecessors
 

                 pitr = i0;
                 --pitr;
             }
 
             for (auto i = i0; i != m_seams.end(); ++i) {
-                if (pitr != m_seams.end() && i.value() == pitr.value()) {
-                    redundant.push_back(i.key());
+                if (pitr != m_seams.end() && i->second == pitr->second) {
+                    redundant.push_back(i->first);
                 }
                 pitr = i;
                 if (i == i1) {
                     break;
                 }
             }
 
             for (sv_frame_t f: redundant) {
-                m_seams.remove(f);
+                m_seams.erase(f);
             }
         }
 
 #ifdef DEBUG_EVENT_SERIES
         std::cerr << "after remove:" << std::endl;

         const sv_frame_t start = frame;
         const sv_frame_t end = frame + duration;
         
         // first find any zero-duration events
         
-        auto pitr = m_events.lowerBound(Event(start, QString()));
-        while (pitr != m_events.end() && pitr.key().getFrame() < end) {
-            if (!pitr.key().hasDuration()) {
-                for (int i = 0; i < pitr.value(); ++i) {
-                    span.push_back(pitr.key());
+        auto pitr = m_events.lower_bound(Event(start, QString()));
+        while (pitr != m_events.end() && pitr->first.getFrame() < end) {
+            if (!pitr->first.hasDuration()) {
+                for (int i = 0; i < pitr->second; ++i) {
+                    span.push_back(pitr->first);
                 }
             }
             ++pitr;
         }
 
         // now any non-zero-duration ones from the seam map
 
         std::set<Event> found;
-        auto sitr = m_seams.lowerBound(start);
-        if (sitr == m_seams.end() || sitr.key() > start) {
+        auto sitr = m_seams.lower_bound(start);
+        if (sitr == m_seams.end() || sitr->first > start) {
             if (sitr != m_seams.begin()) {
                 --sitr;
             }                
         }
-        while (sitr != m_seams.end() && sitr.key() < end) {
-            for (const auto &p: sitr.value()) {
+        while (sitr != m_seams.end() && sitr->first < end) {
+            for (const auto &p: sitr->second) {
                 found.insert(p);
             }
             ++sitr;
         }
         for (const auto &p: found) {
-            int n = m_events.value(p);
+            int n = m_events.at(p);
             if (n < 1) {
                 throw std::logic_error("event is in seams but not events");
             }
             for (int i = 0; i < n; ++i) {
                 span.push_back(p);

     EventVector getEventsCovering(sv_frame_t frame) const {
         EventVector cover;
 
         // first find any zero-duration events
         
-        auto pitr = m_events.lowerBound(Event(frame, QString()));
-        while (pitr != m_events.end() && pitr.key().getFrame() == frame) {
-            if (!pitr.key().hasDuration()) {
-                for (int i = 0; i < pitr.value(); ++i) {
-                    cover.push_back(pitr.key());
+        auto pitr = m_events.lower_bound(Event(frame, QString()));
+        while (pitr != m_events.end() && pitr->first.getFrame() == frame) {
+            if (!pitr->first.hasDuration()) {
+                for (int i = 0; i < pitr->second; ++i) {
+                    cover.push_back(pitr->first);
                 }
             }
             ++pitr;
         }
 
-        // now any non-zero-duration ones from the seam map. We insert
-        // these into a std::set to recover the ordering, lost by QSet
-        
-        std::set<Event> found;
-        auto sitr = m_seams.lowerBound(frame);
-        if (sitr == m_seams.end() || sitr.key() > frame) {
+        // now any non-zero-duration ones from the seam map
+        
+        auto sitr = m_seams.lower_bound(frame);
+        if (sitr == m_seams.end() || sitr->first > frame) {
             if (sitr != m_seams.begin()) {
                 --sitr;
             }                
         }
-        if (sitr != m_seams.end() && sitr.key() <= frame) {
-            for (const auto &p: sitr.value()) {
-                found.insert(p);
-            }
-            ++sitr;
-        }
-        for (const auto &p: found) {
-            int n = m_events.value(p);
-            if (n < 1) {
-                throw std::logic_error("event is in seams but not events");
-            }
-            for (int i = 0; i < n; ++i) {
-                cover.push_back(p);
+        if (sitr != m_seams.end() && sitr->first <= frame) {
+            for (const auto &p: sitr->second) {
+                int n = m_events.at(p);
+                if (n < 1) {
+                    throw std::logic_error("event is in seams but not events");
+                }
+                for (int i = 0; i < n; ++i) {
+                    cover.push_back(p);
+                }
             }
         }
         
         return cover;
     }

     /**
      * Total number of events in the series. Will exceed
      * m_events.size() if the series contains duplicate events.
      */
     int m_count;
-    
+
     /**
      * The (ordered) Events map acts as a list of all the events in
      * the series. For reasons of backward compatibility, we have to
      * handle series containing multiple instances of identical
      * events; the int indexed against each event records the number

      *
      * Because events are immutable, we never have to move one to a
      * different "key" in this map - we only add or delete them or
      * change their counts.
      */
-    typedef QMap<Event, int> Events;
+    typedef std::map<Event, int> Events;
     Events m_events;
 
     /**
      * The FrameEventMap maps from frame number to a set of events. In
      * the seam map this is used to represent the events that are

      * onward and disappearing again at its end frame.
      *
      * Only events with duration appear in this map; point events
      * appear only in m_events.
      */
-    typedef QMap<sv_frame_t, QSet<Event>> FrameEventMap;
+    typedef std::map<sv_frame_t, std::set<Event>> FrameEventMap;
     FrameEventMap m_seams;
 
     /** Create a seam at the given frame, copying from the prior seam
      *  if there is one. If a seam already exists at the given frame,
      *  leave it untouched.
      */
     void createSeam(sv_frame_t frame) {
-        auto itr = m_seams.lowerBound(frame);
-        if (itr == m_seams.end() || itr.key() > frame) {
+        auto itr = m_seams.lower_bound(frame);
+        if (itr == m_seams.end() || itr->first > frame) {
             if (itr != m_seams.begin()) {
                 --itr;
             }
         }
         if (itr == m_seams.end()) {
             m_seams[frame] = {};
-        } else if (itr.key() < frame) {
-            m_seams[frame] = itr.value();
-        } else if (itr.key() > frame) { // itr must be begin()
+        } else if (itr->first < frame) {
+            m_seams[frame] = itr->second;
+        } else if (itr->first > frame) { // itr must be begin()
             m_seams[frame] = {};
         }
     }
 
 #ifdef DEBUG_EVENT_SERIES