Refactor get/set_property to take the item as first argument

lily/dynamic-engraver.cc

 /*
   This file is part of LilyPond, the GNU music typesetter.
 
   Copyright (C) 2008--2020 Han-Wen Nienhuys <hanwen@lilypond.org>
 
   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 63 matching lines @@
 
 void
 Dynamic_engraver::listen_absolute_dynamic (Stream_event *ev)
 {
   ASSIGN_EVENT_ONCE (script_event_, ev);
 }
 
 void
 Dynamic_engraver::listen_span_dynamic (Stream_event *ev)
 {
-  Direction d = to_dir (ev->get_property ("span-direction"));
+  Direction d = to_dir (get_property (ev, "span-direction"));
 
   ASSIGN_EVENT_ONCE (accepted_spanevents_drul_[d], ev);
 }
 
 void
 Dynamic_engraver::listen_break_span (Stream_event *event)
 {
   if (event->in_event_class ("break-dynamic-span-event"))
     {
       // Case 1: Already have a start dynamic event -> break applies to new
       //         spanner (created later) -> set a flag
       // Case 2: no new spanner, but spanner already active -> break it now
       if (accepted_spanevents_drul_[START])
         end_new_spanner_ = true;
       else if (current_spanner_)
-        current_spanner_->set_property ("spanner-broken", SCM_BOOL_T);
+        set_property (current_spanner_, "spanner-broken", SCM_BOOL_T);
     }
 }
 
 SCM
 Dynamic_engraver::get_property_setting (Stream_event *evt,
                                         char const *evprop,
                                         char const *ctxprop)
 {
-  SCM spanner_type = evt->get_property (evprop);
+  SCM spanner_type = get_property (evt, evprop);
   if (scm_is_null (spanner_type))
-    spanner_type = get_property (ctxprop);
+    spanner_type = get_property (this, ctxprop);
   return spanner_type;
 }
 
 void
 Dynamic_engraver::process_music ()
 {
   if (current_spanner_
       && (accepted_spanevents_drul_[STOP]
           || script_event_
           || accepted_spanevents_drul_[START]))
@@ skipping 21 matching lines @@
 
       if (scm_is_eq (cresc_type, ly_symbol2scm ("text")))
         {
           current_spanner_
             = make_spanner ("DynamicTextSpanner",
                             accepted_spanevents_drul_[START]->self_scm ());
 
           SCM text = get_property_setting (current_span_event_, "span-text",
                                            (start_type + "Text").c_str ());
           if (Text_interface::is_markup (text))
-            current_spanner_->set_property ("text", text);
+            set_property (current_spanner_, "text", text);
           /*
             If the line of a text spanner is hidden, end the alignment spanner
             early: this allows dynamics to be spaced individually instead of
             being linked together.
           */
-          if (scm_is_eq (current_spanner_->get_property ("style"),
+          if (scm_is_eq (get_property (current_spanner_, "style"),
                          ly_symbol2scm ("none")))
-            current_spanner_->set_property ("spanner-broken", SCM_BOOL_T);
+            set_property (current_spanner_, "spanner-broken", SCM_BOOL_T);
         }
       else
         {
           if (!scm_is_eq (cresc_type, ly_symbol2scm ("hairpin")))
             {
               string as_string = ly_scm_write_string (cresc_type);
               current_span_event_
               ->origin ()->warning (_f ("unknown crescendo style: %s\ndefaulting to hairpin.", as_string.c_str ()));
             }
           current_spanner_ = make_spanner ("Hairpin",
                                            current_span_event_->self_scm ());
         }
       // if we have a break-dynamic-span event right after the start dynamic, break the new spanner immediately
       if (end_new_spanner_)
         {
-          current_spanner_->set_property ("spanner-broken", SCM_BOOL_T);
+          set_property (current_spanner_, "spanner-broken", SCM_BOOL_T);
           end_new_spanner_ = false;
         }
       if (finished_spanner_)
         {
           if (has_interface<Hairpin> (finished_spanner_))
             Pointer_group_interface::add_grob (finished_spanner_,
                                                ly_symbol2scm ("adjacent-spanners"),
                                                current_spanner_);
           if (has_interface<Hairpin> (current_spanner_))
             Pointer_group_interface::add_grob (current_spanner_,
                                                ly_symbol2scm ("adjacent-spanners"),
                                                finished_spanner_);
         }
     }
 
   if (script_event_)
     {
       script_ = make_item ("DynamicText", script_event_->self_scm ());
-      script_->set_property ("text",
-                             script_event_->get_property ("text"));
+      set_property (script_, "text",
+                             get_property (script_event_, "text"));
 
       if (finished_spanner_)
         finished_spanner_->set_bound (RIGHT, script_);
       if (current_spanner_)
         current_spanner_->set_bound (LEFT, script_);
     }
 }
 
 void
 Dynamic_engraver::stop_translation_timestep ()
 {
   if (finished_spanner_ && !finished_spanner_->get_bound (RIGHT))
     finished_spanner_
     ->set_bound (RIGHT,
-                 unsmob<Grob> (get_property ("currentMusicalColumn")));
+                 unsmob<Grob> (get_property (this, "currentMusicalColumn")));
 
   if (current_spanner_ && !current_spanner_->get_bound (LEFT))
     current_spanner_
     ->set_bound (LEFT,
-                 unsmob<Grob> (get_property ("currentMusicalColumn")));
+                 unsmob<Grob> (get_property (this, "currentMusicalColumn")));
   script_ = 0;
   script_event_ = 0;
   accepted_spanevents_drul_.set (0, 0);
   finished_spanner_ = 0;
   end_new_spanner_ = false;
 }
 
 void
 Dynamic_engraver::finalize ()
 {
   if (current_spanner_
       && !current_spanner_->is_live ())
     current_spanner_ = 0;
   if (current_spanner_)
     {
       current_span_event_
       ->origin ()->warning (_f ("unterminated %s",
                                 get_spanner_type (current_span_event_)
                                 .c_str ()));
       current_spanner_->suicide ();
       current_spanner_ = 0;
     }
 }
 
 string
 Dynamic_engraver::get_spanner_type (Stream_event *ev)
 {
   string type;
-  SCM start_sym = scm_car (ev->get_property ("class"));
+  SCM start_sym = scm_car (get_property (ev, "class"));
 
   if (scm_is_eq (start_sym, ly_symbol2scm ("decrescendo-event")))
     type = "decrescendo";
   else if (scm_is_eq (start_sym, ly_symbol2scm ("crescendo-event")))
     type = "crescendo";
   else
     programming_error ("unknown dynamic spanner type");
 
   return type;
 }
 
 void
 Dynamic_engraver::acknowledge_note_column (Grob_info info)
 {
   if (script_ && !script_->get_parent (X_AXIS))
     {
       extract_grob_set (info.grob (), "note-heads", heads);
       /*
         Spacing constraints may require dynamics to be attached to rests,
         so check for a rest if this note column has no note heads.
       */
       Grob *x_parent = (heads.size ()
                         ? info.grob ()
-                        : unsmob<Grob> (info.grob ()->get_object ("rest")));
+                        : unsmob<Grob> (get_object (info.grob (), "rest")));
       if (x_parent)
         script_->set_parent (x_parent, X_AXIS);
     }
 
   if (current_spanner_ && !current_spanner_->get_bound (LEFT))
     current_spanner_->set_bound (LEFT, info.grob ());
   if (finished_spanner_ && !finished_spanner_->get_bound (RIGHT))
     finished_spanner_->set_bound (RIGHT, info.grob ());
 }
 
@@ skipping 18 matching lines @@
                 /* read */
                 "crescendoSpanner "
                 "crescendoText "
                 "currentMusicalColumn "
                 "decrescendoSpanner "
                 "decrescendoText ",
 
                 /* write */
                 ""
                );