comparison base/EventSeries.h @ 1626:895186c43fce single-point

Experiment with storing vectors of event ids in seam map for compactness

     void add(const Event &p) {
 
         ++m_events[p];
         ++m_count;
 
+        sv_id_t id = Event::getId(p);
+        
         if (p.hasDuration()) {
 
             const sv_frame_t frame = p.getFrame();
             const sv_frame_t endFrame = p.getFrame() + p.getDuration();
 

                     SVCERR << "ERROR: EventSeries::add: "
                            << "reached end of seam map"
                            << endl;
                     break;
                 }
-                i->second.insert(p);
+/*                bool found = false;
+                for (auto eid: i->second) {
+                    if (eid == id) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {*/
+                    i->second.push_back(id);
+//                }
             }
         }
 
 #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();
 

                 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");
                 }
-                
-                i->second.erase(p);
+                for (size_t j = 0; j < i->second.size(); ) {
+                    if (i->second[j] == id) {
+                        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;

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

             ++pitr;
         }
 
         // now any non-zero-duration ones from the seam map
         
+        std::set<Event> found;
         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->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);
-                }
+            for (const auto &id: sitr->second) {
+                found.insert(Event::getEventForId(id));
+            }
+            ++sitr;
+        }
+        for (const auto &p: found) {
+            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;
     }

      * 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::set<Event>> FrameEventMap;
+    typedef std::map<sv_frame_t, std::vector<sv_id_t>> 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.