]> git.donarmstrong.com Git - lilypond.git/blobdiff - lily/sequential-music-iterator.cc
release: 1.3.92
[lilypond.git] / lily / sequential-music-iterator.cc
index ce71cc36e1bae7cfe9eafc34d0618876fbc1c463..7260e3eb83f1e49c0d946489607239c1abc64496 100644 (file)
 #include "music-list.hh"
 #include "request-chord-iterator.hh"
 
+/*
+  Invariant for the data structure.
+
+
+  if (gh_pair_p (cursor_))
+    iter_p_->music_l_ == unsmob_music (gh_car (cursor_))
+  else
+    iter_p_ == 0;
+
+  The length of musiclist from start to up to cursor_ (cursor_ not
+  including), is summed
+
+  here_mom_  = sum (length (musiclist [start ... cursor> ))  %)  
+  
+ */
+
+
 Sequential_music_iterator::Sequential_music_iterator ()
 {
-  cursor_ = 0;
-  here_mom_ = 0;
+  cursor_ = SCM_EOL;
+  here_mom_ = Moment (0);
+
   iter_p_ =0;
 }
 
@@ -24,66 +42,61 @@ Sequential_music_iterator::Sequential_music_iterator (Sequential_music_iterator
 {
   cursor_ = src.cursor_;
   here_mom_ = src.here_mom_;
-  iter_p_ = src.iter_p_->clone ();
+  if (src.iter_p_)
+    iter_p_ = src.iter_p_->clone ();
+  else
+    iter_p_ = 0;
 }
 
 Sequential_music_iterator::~Sequential_music_iterator()
 {
-  if (iter_p_)
-    {
-      if (iter_p_->ok ())
-       music_l_->origin ()->warning (_ ("Must stop before this music ends"));
-      delete iter_p_;
-      iter_p_ = 0;
-    }
-}
-
-void
-Sequential_music_iterator::do_print() const
-{
-  if (iter_p_)
-    iter_p_->print();
+  delete iter_p_;
 }
 
 void
 Sequential_music_iterator::construct_children()
 {
   cursor_ = dynamic_cast<Music_sequence const*> (music_l_)->music_list ();
-  
-  while (gh_pair_p (cursor_ ))
+
+  iter_p_ = gh_pair_p (cursor_) ?  get_iterator_p (unsmob_music (gh_car (cursor_))) : 0;
+  while (iter_p_ && !iter_p_->ok ())
     {
-      start_next_element();
-      if (!iter_p_->ok()) 
-       {
-         leave_element();
-       }
-      else 
-       {
-         set_sequential_music_translator();
-         break;
-       }
+      next_element ();
     }
-}
 
-void 
-Sequential_music_iterator::leave_element()
-{
-  delete iter_p_;
-  iter_p_ =0;
-  Moment elt_time = unsmob_music (gh_car (cursor_))->length_mom ();
-  here_mom_ += elt_time;
-  cursor_ =gh_cdr (cursor_);
+  /*
+    iter_p_->ok () is tautology, but what the heck.
+   */
+  if (iter_p_ && iter_p_->ok()) 
+    descend_to_child ();
+
 }
 
+
+/*
+  maintain invariants: change cursor, iter and here_mom_ in one fell
+  swoop.
+*/
 void
-Sequential_music_iterator::start_next_element()
+Sequential_music_iterator::next_element ()
 {
-  assert (!iter_p_);
-  iter_p_ = get_iterator_p (unsmob_music (gh_car (cursor_)));
+  here_mom_ += iter_p_->music_length_mom ();
+  delete iter_p_;
+  cursor_ = gh_cdr (cursor_);
+
+  if (gh_pair_p (cursor_))
+    iter_p_ = get_iterator_p (unsmob_music (gh_car (cursor_)));
+  else
+    iter_p_ = 0;
 }
 
+/*
+  move to context of child iterator if it is deeper down in the
+  hierarchy.
+  */
+
 void
-Sequential_music_iterator::set_sequential_music_translator()
+Sequential_music_iterator::descend_to_child ()
 {
   Translator_group  * child_report = child_report = iter_p_->report_to_l ();
   if (dynamic_cast<Grace_iterator*> (iter_p_))
@@ -93,92 +106,97 @@ Sequential_music_iterator::set_sequential_music_translator()
     set_translator (child_report);
 }
 
+
+/*
+  Retrieve all music (starting at HERE), until a music with length L >
+  0 is found.  From the precondition, we know that UNTIL is later than
+  the earliest event. Hence we know
+  
+  L >= (UNTIL - HERE)
+
+  so something that comes after this thing with L > 0 happens after
+
+  HERE + L >= HERE + (UNTIL - HERE) = UNTIL
+
+  Hence all events after the one with L>0 are uninteresting, so we
+  ignore them.
+  
+*/
+
 SCM
-Sequential_music_iterator::get_music ()
+Sequential_music_iterator::get_music (Moment until)const
 {
-  if (ok ())
-    return scm_listify (scm_cons (SCM_CAR (cursor_),
-                                 report_to_l ()->self_scm ()),
-                       SCM_UNDEFINED);
+  SCM s = SCM_EOL;
+  if (until <  pending_moment ())
+    return s;
+
+  Sequential_music_iterator * me =
+    dynamic_cast<Sequential_music_iterator*> (clone ());
+  while (me->ok ())
+    {
+      SCM nm = me->iter_p_->get_music (until - me->here_mom_);
+      s = gh_append2 (nm, s);
       
-  return SCM_EOL;
-}
+      Moment m = 0;
+      for (SCM i = nm; gh_pair_p(i); i = gh_cdr (i))
+       m = m >? unsmob_music (gh_car (i))->length_mom ();
+
+      if (m > Moment (0))
+       break ;
+      else
+       me->next_element ();
+    }
+  delete me;
   
-bool
-Sequential_music_iterator::next ()
+  return s;
+}
+/*
+  Skip events till UNTIL. We don't do any other side effects (such as
+  moving descending to child iterator contexts, because they might
+  depend on \context specs and \translator changes being executed
+    
+ */
+void
+Sequential_music_iterator::skip (Moment until)
 {
-#if 0
-  if (ok ())
+  while (ok ())
     {
-      bool b = false;
+      Moment l =iter_p_->music_length_mom ();
+      if (l >= until - here_mom_)
+       iter_p_->skip (until - here_mom_);
+
       if (iter_p_->ok ())
-       b = iter_p_->next ();
-      if (!b)
-       {
-         set_sequential_music_translator ();
-         leave_element ();
-         if (gh_pair_p (cursor_))
-           start_next_element ();
-         b = ok ();
-       }
-      return b;
-    }
-  return false;
-#else
-  if (ok ())
-    {
-      set_sequential_music_translator ();
-      leave_element ();
-      if (gh_pair_p (cursor_))
-       start_next_element ();
-      return ok ();
+       return ; 
+
+      next_element ();
     }
-  return false;
-#endif
 }
 
-/*
-  This should use get_music () and next ()
- */
 void
-Sequential_music_iterator::do_process (Moment until)
+Sequential_music_iterator::process (Moment until)
 {
-#if 1
-  return;
-#else
-  if (ok ())
+  while (iter_p_)
     {
-      //      while (1) 
-       {
-         Moment local_until = until - here_mom_;
-         while (iter_p_->ok ()) 
-           {
-             Moment here = iter_p_->next_moment ();
-             if (here != local_until)
-               return Music_iterator::do_process (until);
-             
-             iter_p_->process (local_until);
-           }
+      iter_p_->process (until - here_mom_);
+
+      /*
+       if the iter is still OK, there must be events left that have
+       
+         TIME > LEFT
          
-         if (!iter_p_->ok ()) 
-           {
-             set_sequential_music_translator ();
-             leave_element ();
-             
-             if (gh_pair_p (cursor_))
-               start_next_element ();
-             else 
-               return Music_iterator::do_process (until);
-           }
-       }
+      */
+      if (iter_p_->ok ())
+       return ;
+
+      descend_to_child ();
+      next_element ();
     }
-#endif
 }
 
 Moment
-Sequential_music_iterator::next_moment() const
+Sequential_music_iterator::pending_moment() const
 {
-  return iter_p_->next_moment() + here_mom_;
+  return iter_p_->pending_moment() + here_mom_;
 }