comparison base/EventSeries.h @ 1627:1c21ddac220e single-point

Seems we can do just as well with a vector of events themselves

         return m_events == other.m_events;
     }
     
     void add(const Event &p) {
 
+        bool isUnique = true;
+
+        auto pitr = m_events.find(p);
+        if (pitr != m_events.end()) {
+            isUnique = false;
+        }
+
         ++m_events[p];
         ++m_count;
 
-        sv_id_t id = Event::getId(p);
-        
-        if (p.hasDuration()) {
+        if (p.hasDuration() && isUnique) {
 
             const sv_frame_t frame = p.getFrame();
             const sv_frame_t endFrame = p.getFrame() + p.getDuration();
 
             createSeam(frame);

                     SVCERR << "ERROR: EventSeries::add: "
                            << "reached end of seam map"
                            << endl;
                     break;
                 }
-/*                bool found = false;
-                for (auto eid: i->second) {
-                    if (eid == id) {
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found) {*/
-                    i->second.push_back(id);
-//                }
+                i->second.push_back(p);
             }
         }
 
 #ifdef DEBUG_EVENT_SERIES
         std::cerr << "after add:" << std::endl;

                 m_events.erase(pitr);
             }
             --m_count;
         }
 
-        sv_id_t id = Event::getId(p);
-        
         if (p.hasDuration() && isUnique) {
             
             const sv_frame_t frame = p.getFrame();
             const sv_frame_t endFrame = p.getFrame() + p.getDuration();
 

                        << " for event not found in seam map: event is "
                        << p.toXmlString() << endl;
             }
 #endif
 
+            // Remove any and all instances of p from the seam map; we
+            // are only supposed to get here if we are removing the
+            // last instance of p from the series anyway
+            
             for (auto i = i0; i != i1; ++i) {
                 if (i == m_seams.end()) {
                     // This can happen only if we have a negative
                     // duration, which Event forbids
                     throw std::logic_error("unexpectedly reached end of map");
                 }
                 for (size_t j = 0; j < i->second.size(); ) {
-                    if (i->second[j] == id) {
+                    if (i->second[j] == p) {
                         i->second.erase(i->second.begin() + j);
                     } else {
                         ++j;
                     }
                 }
             }
 
             // Tidy up by removing any entries that are now identical
             // to their predecessors
-
-//!!! won't work as vector is not consistently ordered
             
             std::vector<sv_frame_t> redundant;
 
             auto pitr = m_seams.end();
             if (i0 != m_seams.begin()) {
                 pitr = i0;
                 --pitr;
             }
 
             for (auto i = i0; i != m_seams.end(); ++i) {
-                if (pitr != m_seams.end() && i->second == pitr->second) {
+                if (pitr != m_seams.end() &&
+                    seamsEqual(i->second, pitr->second)) {
                     redundant.push_back(i->first);
                 }
                 pitr = i;
                 if (i == i1) {
                     break;
                 }
             }
 
             for (sv_frame_t f: redundant) {
                 m_seams.erase(f);
+            }
+
+            // And remove any empty seams from the start of the map
+            
+            while (m_seams.begin() != m_seams.end() &&
+                   m_seams.begin()->second.empty()) {
+                m_seams.erase(m_seams.begin());
             }
         }
 
 #ifdef DEBUG_EVENT_SERIES
         std::cerr << "after remove:" << std::endl;

             if (sitr != m_seams.begin()) {
                 --sitr;
             }                
         }
         while (sitr != m_seams.end() && sitr->first < end) {
-            for (const auto &id: sitr->second) {
-                found.insert(Event::getEventForId(id));
+            for (const auto &p: sitr->second) {
+                found.insert(p);
             }
             ++sitr;
         }
         for (const auto &p: found) {
             int n = m_events.at(p);

             if (sitr != m_seams.begin()) {
                 --sitr;
             }                
         }
         if (sitr != m_seams.end() && sitr->first <= frame) {
-            for (const auto &id: sitr->second) {
-                found.insert(Event::getEventForId(id));
+            for (const auto &p: sitr->second) {
+                found.insert(p);
             }
             ++sitr;
         }
         for (const auto &p: found) {
             int n = m_events.at(p);

      * an entry here for each frame at which an event starts or ends,
      * with the event appearing in all entries from its start time
      * onward and disappearing again at its end frame.
      *
      * Only events with duration appear in this map; point events
-     * appear only in m_events.
-     */
-    typedef std::map<sv_frame_t, std::vector<sv_id_t>> FrameEventMap;
+     * appear only in m_events. Note that unlike m_events, we only
+     * store one instance of each event here, even if we hold many -
+     * we refer back to m_events when we need to know how many
+     * identical copies of a given event we have.
+     */
+    typedef std::map<sv_frame_t, std::vector<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.

         } else if (itr->first < frame) {
             m_seams[frame] = itr->second;
         } else if (itr->first > frame) { // itr must be begin()
             m_seams[frame] = {};
         }
+    }
+
+    bool seamsEqual(const std::vector<Event> &s1,
+                    const std::vector<Event> &s2) const {
+        
+        if (s1.size() != s2.size()) {
+            return false;
+        }
+
+        // precondition: no event appears more than once in s1 or more
+        // than once in s2
+
+#ifdef DEBUG_EVENT_SERIES
+        for (int i = 0; in_range_for(s1, i); ++i) {
+            for (int j = i + 1; in_range_for(s1, j); ++j) {
+                if (s1[i] == s1[j] || s2[i] == s2[j]) {
+                    throw std::runtime_error
+                        ("debug error: duplicate event in s1 or s2");
+                }
+            }
+        }
+#endif
+
+        std::set<Event> ee;
+        for (const auto &e: s1) {
+            ee.insert(e);
+        }
+        for (const auto &e: s2) {
+            if (ee.find(e) == ee.end()) {
+                return false;
+            }
+        }
+        return true;
     }
 
 #ifdef DEBUG_EVENT_SERIES
     void dumpEvents() const {
         std::cerr << "EVENTS (" << m_events.size() << ") [" << std::endl;