Refactor get/set_property to take the item as first argument

lily/music.cc

 /*
   This file is part of LilyPond, the GNU music typesetter.
 
   Copyright (C) 1997--2020 Han-Wen Nienhuys <hanwen@xs4all.nl>
 
   LilyPond is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
@@ skipping 22 matching lines @@
 /*
   Music is anything that has (possibly zero) duration and supports
   both time compression and transposition.
 
   In Lily, everything that can be thought to have a length and a pitch
   (which has a duration which can be transposed) is considered "music".
 */
 bool
 Music::internal_is_music_type (SCM k) const
 {
-  SCM ifs = get_property ("types");
+  SCM ifs = get_property (this, "types");
 
   return scm_is_true (scm_c_memq (k, ifs));
 }
 
 Preinit_Music::Preinit_Music ()
 {
   length_callback_ = SCM_EOL;
   start_callback_ = SCM_EOL;
 }
 
 Music::Music (SCM init)
   : Prob (ly_symbol2scm ("Music"), init)
 {
-  length_callback_ = get_property ("length-callback");
+  length_callback_ = get_property (this, "length-callback");
   if (!ly_is_procedure (length_callback_))
     length_callback_ = duration_length_callback_proc;
 
-  start_callback_ = get_property ("start-callback");
+  start_callback_ = get_property (this, "start-callback");
 }
 
 void
 Music::derived_mark () const
 {
   scm_gc_mark (length_callback_);
   scm_gc_mark (start_callback_);
 }
 
 SCM
@@ skipping 11 matching lines @@
 Music::Music (Music const &m)
   : Prob (m)
 {
   length_callback_ = m.length_callback_;
   start_callback_ = m.start_callback_;
 }
 
 Moment
 Music::get_length () const
 {
-  SCM lst = get_property ("length");
+  SCM lst = get_property (this, "length");
   if (unsmob<Moment> (lst))
     return *unsmob<Moment> (lst);
 
   if (ly_is_procedure (length_callback_))
     {
       SCM res = scm_call_1 (length_callback_, self_scm ());
       return *unsmob<Moment> (res);
     }
 
   return Moment (0);
@@ skipping 22 matching lines @@
       scm_display (scm_caar (s), port);
       scm_puts (" = ", port);
       scm_write (scm_cdar (s), port);
       scm_puts ("\n", port);
     }
 }
 
 Pitch
 Music::generic_to_relative_octave (Pitch last)
 {
-  SCM elt = get_property ("element");
-  Pitch *old_pit = unsmob<Pitch> (get_property ("pitch"));
+  SCM elt = get_property (this, "element");
+  Pitch *old_pit = unsmob<Pitch> (get_property (this, "pitch"));
   if (old_pit)
     {
       Pitch new_pit = *old_pit;
       new_pit = new_pit.to_relative_octave (last);
 
-      SCM check = get_property ("absolute-octave");
+      SCM check = get_property (this, "absolute-octave");
       if (scm_is_number (check)
           && new_pit.get_octave () != scm_to_int (check))
         {
           Pitch expected_pit (scm_to_int (check),
                               new_pit.get_notename (),
                               new_pit.get_alteration ());
           origin ()->warning (_f ("octave check failed; expected \"%s\", found: \"%s\"",
                                   expected_pit.to_string (),
                                   new_pit.to_string ()));
           new_pit = expected_pit;
         }
 
-      set_property ("pitch", new_pit.smobbed_copy ());
+      set_property (this, "pitch", new_pit.smobbed_copy ());
 
       last = new_pit;
     }
 
   if (Music *m = unsmob<Music> (elt))
     last = m->to_relative_octave (last);
 
-  (void) music_list_to_relative (get_property ("articulations"), last, true);
-  last = music_list_to_relative (get_property ("elements"), last, false);
+  (void) music_list_to_relative (get_property (this, "articulations"), last, true);
+  last = music_list_to_relative (get_property (this, "elements"), last, false);
   return last;
 }
 
 Pitch
 Music::to_relative_octave (Pitch last)
 {
-  SCM callback = get_property ("to-relative-callback");
+  SCM callback = get_property (this, "to-relative-callback");
   if (ly_is_procedure (callback))
     {
       Pitch *p = unsmob<Pitch> (scm_call_2 (callback, self_scm (),
                                             last.smobbed_copy ()));
       return *p;
     }
 
   return generic_to_relative_octave (last);
 }
 
 void
 Music::compress (Rational factor)
 {
-  SCM elt = get_property ("element");
+  SCM elt = get_property (this, "element");
 
   if (Music *m = unsmob<Music> (elt))
     m->compress (factor);
 
-  compress_music_list (get_property ("elements"), factor);
-  Duration *d = unsmob<Duration> (get_property ("duration"));
+  compress_music_list (get_property (this, "elements"), factor);
+  Duration *d = unsmob<Duration> (get_property (this, "duration"));
   if (d)
-    set_property ("duration",
+    set_property (this, "duration",
                   d->compressed (factor).smobbed_copy ());
 }
 
 /*
   This mutates alist.  Hence, make sure that it is not shared
 */
 
 void
 Prob::transpose (Pitch delta)
 {
-  if (to_boolean (get_property ("untransposable")))
+  if (to_boolean (get_property (this, "untransposable")))
     return;
 
   for (SCM s = mutable_property_alist_; scm_is_pair (s); s = scm_cdr (s))
     {
       SCM entry = scm_car (s);
       SCM prop = scm_car (entry);
       SCM val = scm_cdr (entry);
       SCM new_val = val;
 
       if (Pitch *p = unsmob<Pitch> (val))
@@ skipping 19 matching lines @@
         new_val = ly_transpose_key_alist (val, delta.smobbed_copy ());
 
       if (!scm_is_eq (val, new_val))
         scm_set_cdr_x (entry, new_val);
     }
 }
 
 void
 Music::set_spot (Input ip)
 {
-  set_property ("origin", ip.smobbed_copy ());
+  set_property (this, "origin", ip.smobbed_copy ());
 }
 
 Input *
 Music::origin () const
 {
-  Input *ip = unsmob<Input> (get_property ("origin"));
+  Input *ip = unsmob<Input> (get_property (this, "origin"));
   return ip ? ip : &dummy_input_global;
 }
 
 /*
   ES TODO: This method should probably be reworked or junked.
 */
 Stream_event *
 Music::to_event () const
 {
-  SCM class_name = ly_camel_case_2_lisp_identifier (get_property ("name"));
+  SCM class_name = ly_camel_case_2_lisp_identifier (get_property (this, "name"));
 
   // catch programming mistakes.
   if (!internal_is_music_type (class_name))
     programming_error ("Not a music type");
 
   Stream_event *e = new Stream_event
   (Lily::ly_make_event_class (class_name),
    mutable_property_alist_);
   Moment length = get_length ();
   if (length.to_bool ())
-    e->set_property ("length", length.smobbed_copy ());
+    set_property (e, "length", length.smobbed_copy ());
 
   // articulations as events.
-  SCM art_mus = e->get_property ("articulations");
+  SCM art_mus = get_property (e, "articulations");
   if (scm_is_pair (art_mus))
     {
       SCM art_ev = SCM_EOL;
       for (; scm_is_pair (art_mus); art_mus = scm_cdr (art_mus))
         {
           Music *m = unsmob<Music> (scm_car (art_mus));
           art_ev = scm_cons (m->to_event ()->unprotect (), art_ev);
         }
-      e->set_property ("articulations", scm_reverse_x (art_ev, SCM_EOL));
+      set_property (e, "articulations", scm_reverse_x (art_ev, SCM_EOL));
     }
 
   /*
     ES TODO: This is a temporary fix. Stream_events should not be
     aware of music.
   */
-  e->set_property ("music-cause", self_scm ());
+  set_property (e, "music-cause", self_scm ());
 
   return e;
 }
 
 void
 Music::send_to_context (Context *c)
 {
   Stream_event *ev = to_event ();
   c->event_source ()->broadcast (ev);
   ev->unprotect ();
 }
 
 Music *
 make_music_by_name (SCM sym)
 {
   SCM rv = Lily::make_music (sym);
 
   /* UGH. */
   Music *m = unsmob<Music> (rv);
   m->protect ();
   return m;
 }
 
 MAKE_SCHEME_CALLBACK (Music, duration_length_callback, 1);
 SCM
 Music::duration_length_callback (SCM m)
 {
   Music *me = unsmob<Music> (m);
-  Duration *d = unsmob<Duration> (me->get_property ("duration"));
+  Duration *d = unsmob<Duration> (get_property (me, "duration"));
 
   Moment mom;
   if (d)
     mom = d->get_length ();
   return mom.smobbed_copy ();
 }
 
 SCM
 music_deep_copy (SCM m)
 {
@@ skipping 21 matching lines @@
 
 void
 set_origin (SCM m, SCM origin)
 {
   while (scm_is_pair (m))
     {
       set_origin (scm_car (m), origin);
       m = scm_cdr (m);
     }
   if (Music *mus = unsmob<Music> (m))
-    mus->set_property ("origin", origin);
-}
+    set_property (mus, "origin", origin);
+}