rename TransportFSM::FSMEvent to TransportFSM::Event (c/o the Department of Redundanc...

diff --git a/libs/ardour/ardour/transport_fsm.h b/libs/ardour/ardour/transport_fsm.h
index 570271ee3b11e451e9fd8d57c45daced6e845f3d..004141a27ad500b7a562a4a04b812af306756c3a 100644 (file)
--- a/libs/ardour/ardour/transport_fsm.h
+++ b/libs/ardour/ardour/transport_fsm.h
@@ -40,7 +40,7 @@ struct TransportFSM
                LocateDone
        };
 
-       struct FSMEvent : public boost::intrusive::list_base_hook<> {
+       struct Event : public boost::intrusive::list_base_hook<> {
                EventType type;
                union {
                        bool abort; /* for stop */
@@ -55,7 +55,7 @@ struct TransportFSM
                bool with_loop;
                bool force;
 
-               FSMEvent (EventType t)
+               Event (EventType t)
                        : type (t)
                        , with_roll (false)
                        , with_flush (false)
@@ -63,14 +63,14 @@ struct TransportFSM
                        , with_loop (false)
                        , force (false)
                {}
-               FSMEvent (EventType t, bool ab, bool cl)
+               Event (EventType t, bool ab, bool cl)
                        : type (t)
                        , abort (ab)
                        , clear_state (cl)
                {
                        assert (t == StopTransport);
                }
-               FSMEvent (EventType t, samplepos_t pos, bool r, bool fl, bool lp, bool f4c)
+               Event (EventType t, samplepos_t pos, bool r, bool fl, bool lp, bool f4c)
                        : type (t)
                        , with_roll (r)
                        , with_flush (fl)
@@ -132,10 +132,10 @@ struct TransportFSM
        void stop_playback ();
        void start_saved_locate ();
        void roll_after_locate ();
-       void start_locate (FSMEvent const &);
-       void interrupt_locate (FSMEvent const &);
-       void save_locate_and_start_declick (FSMEvent const &);
-       void start_declick (FSMEvent const &);
+       void start_locate (Event const &);
+       void interrupt_locate (Event const &);
+       void save_locate_and_start_declick (Event const &);
+       void start_declick (Event const &);
 
        /* guards */
 
@@ -149,7 +149,7 @@ struct TransportFSM
        bool waiting_for_butler()            { return _butler_state == WaitingForButler; }
        bool declick_in_progress()           { return _motion_state == DeclickToLocate || _motion_state == DeclickToStop; }
 
-       void enqueue (FSMEvent* ev) {
+       void enqueue (Event* ev) {
                queued_events.push_back (*ev);
                if (!processing) {
                        process_events ();
@@ -162,19 +162,19 @@ struct TransportFSM
        void transition (ButlerState bs);
 
        void process_events ();
-       bool process_event (FSMEvent&);
+       bool process_event (Event&);
 
-       FSMEvent _last_locate;
-       FSMEvent _last_stop;
+       Event _last_locate;
+       Event _last_stop;
 
        TransportAPI* api;
-       typedef boost::intrusive::list<FSMEvent> EventList;
+       typedef boost::intrusive::list<Event> EventList;
        EventList queued_events;
        EventList deferred_events;
        int processing;
 
-       void defer (FSMEvent& ev);
-       void bad_transition (FSMEvent const &);
+       void defer (Event& ev);
+       void bad_transition (Event const &);
 };
 
 } /* end namespace ARDOUR */

diff --git a/libs/ardour/globals.cc b/libs/ardour/globals.cc
index 2a47fd9dea7faf3f783b77d751aa735173d2d5c4..0f8ae9a4f28b7830e2e452d2d5e401e528b7e7ed 100644 (file)
--- a/libs/ardour/globals.cc
+++ b/libs/ardour/globals.cc
@@ -468,7 +468,7 @@ ARDOUR::init (bool use_windows_vst, bool try_optimization, const char* localedir
 #endif
 
        SessionEvent::init_event_pool ();
-       TransportFSM::FSMEvent::init_pool ();
+       TransportFSM::Event::init_pool ();
 
        Operations::make_operations_quarks ();
        SessionObject::make_property_quarks ();

diff --git a/libs/ardour/session_process.cc b/libs/ardour/session_process.cc
index fbcf4c648e26e01d026767c0fee7adecd07da8cc..356f46d66c54404baa025de8d44b8f027c903b3e 100644 (file)
--- a/libs/ardour/session_process.cc
+++ b/libs/ardour/session_process.cc
@@ -59,9 +59,9 @@ using namespace ARDOUR;
 using namespace PBD;
 using namespace std;
 
-#define TFSM_EVENT(evtype) { _transport_fsm->enqueue (new TransportFSM::FSMEvent (evtype)); }
-#define TFSM_STOP(abort,clear) { _transport_fsm->enqueue (new TransportFSM::FSMEvent (TransportFSM::StopTransport,abort,clear)); }
-#define TFSM_LOCATE(target,roll,flush,loop,force) { _transport_fsm->enqueue (new TransportFSM::FSMEvent (TransportFSM::Locate,target,roll,flush,loop,force)); }
+#define TFSM_EVENT(evtype) { _transport_fsm->enqueue (new TransportFSM::Event (evtype)); }
+#define TFSM_STOP(abort,clear) { _transport_fsm->enqueue (new TransportFSM::Event (TransportFSM::StopTransport,abort,clear)); }
+#define TFSM_LOCATE(target,roll,flush,loop,force) { _transport_fsm->enqueue (new TransportFSM::Event (TransportFSM::Locate,target,roll,flush,loop,force)); }
 
 
 /** Called by the audio engine when there is work to be done with JACK.

diff --git a/libs/ardour/session_time.cc b/libs/ardour/session_time.cc
index 185a86bf4cda51745d12bd8daef44c4d041e40e6..e68c4766a95afac0e439925783428c150a28e2a0 100644 (file)
--- a/libs/ardour/session_time.cc
+++ b/libs/ardour/session_time.cc
@@ -43,7 +43,7 @@ using namespace std;
 using namespace ARDOUR;
 using namespace PBD;
 
-#define TFSM_EVENT(evtype) { _transport_fsm->enqueue (new TransportFSM::FSMEvent (evtype)); }
+#define TFSM_EVENT(evtype) { _transport_fsm->enqueue (new TransportFSM::Event (evtype)); }
 
 /* BBT TIME*/
 

diff --git a/libs/ardour/session_transport.cc b/libs/ardour/session_transport.cc
index e9f6ed6bbe92c4cec144580ca5a22a01bca59498..b0f7c0b41410d1b78ab0e557dfbf7e9284303c16 100644 (file)
--- a/libs/ardour/session_transport.cc
+++ b/libs/ardour/session_transport.cc
@@ -82,9 +82,9 @@ using namespace PBD;
 #endif
 
 
-#define TFSM_EVENT(evtype) { _transport_fsm->enqueue (new TransportFSM::FSMEvent (evtype)); }
-#define TFSM_STOP(abort,clear) { _transport_fsm->enqueue (new TransportFSM::FSMEvent (TransportFSM::StopTransport,abort,clear)); }
-#define TFSM_LOCATE(target,roll,flush,loop,force) { _transport_fsm->enqueue (new TransportFSM::FSMEvent (TransportFSM::Locate,target,roll,flush,loop,force)); }
+#define TFSM_EVENT(evtype) { _transport_fsm->enqueue (new TransportFSM::Event (evtype)); }
+#define TFSM_STOP(abort,clear) { _transport_fsm->enqueue (new TransportFSM::Event (TransportFSM::StopTransport,abort,clear)); }
+#define TFSM_LOCATE(target,roll,flush,loop,force) { _transport_fsm->enqueue (new TransportFSM::Event (TransportFSM::Locate,target,roll,flush,loop,force)); }
 
 /* *****************************************************************************
  * REALTIME ACTIONS (to be called on state transitions)

diff --git a/libs/ardour/transport_fsm.cc b/libs/ardour/transport_fsm.cc
index 2b0234685247f6cf6b7c4d1b8bcfc74660fd880f..5f394f9bd73cbfd45a6a509c513502738b4c20ad 100644 (file)
--- a/libs/ardour/transport_fsm.cc
+++ b/libs/ardour/transport_fsm.cc
@@ -29,22 +29,22 @@
 using namespace ARDOUR;
 using namespace PBD;
 
-Pool* TransportFSM::FSMEvent::pool = 0;
+Pool* TransportFSM::Event::pool = 0;
 
 void
-TransportFSM::FSMEvent::init_pool ()
+TransportFSM::Event::init_pool ()
 {
-       pool = new Pool (X_("FSMEvents"), sizeof (FSMEvent), 128);
+       pool = new Pool (X_("Events"), sizeof (Event), 128);
 }
 
 void*
-TransportFSM::FSMEvent::operator new (size_t)
+TransportFSM::Event::operator new (size_t)
 {
        return pool->alloc();
  }
 
 void
-TransportFSM::FSMEvent::operator delete (void *ptr, size_t /*size*/)
+TransportFSM::Event::operator delete (void *ptr, size_t /*size*/)
 {
        return pool->release (ptr);
 }
@@ -87,7 +87,7 @@ TransportFSM::process_events ()
                                        DEBUG_TRACE (DEBUG::TFSMEvents, string_compose ("processing %1 deferred events\n", deferred_events.size()));
 
                                        for (EventList::iterator e = deferred_events.begin(); e != deferred_events.end(); ) {
-                                               FSMEvent* deferred_ev = &(*e);
+                                               Event* deferred_ev = &(*e);
                                                if (process_event (*e)) { /* event processed, remove from deferred */
                                                        e = deferred_events.erase (e);
                                                        delete deferred_ev;
@@ -99,7 +99,7 @@ TransportFSM::process_events ()
                        }
                }
 
-               FSMEvent* ev = &queued_events.front();
+               Event* ev = &queued_events.front();
                queued_events.pop_front ();
                delete ev;
        }
@@ -166,14 +166,14 @@ TransportFSM::current_state () const
 }
 
 void
-TransportFSM::bad_transition (FSMEvent const & ev)
+TransportFSM::bad_transition (Event const & ev)
 {
        error << "bad transition, current state = " << current_state() << " event = " << enum_2_string (ev.type) << endmsg;
        std::cerr << "bad transition, current state = " << current_state() << " event = " << enum_2_string (ev.type) << std::endl;
 }
 
 bool
-TransportFSM::process_event (FSMEvent& ev)
+TransportFSM::process_event (Event& ev)
 {
        DEBUG_TRACE (DEBUG::TFSMEvents, string_compose ("process %1\n", enum_2_string (ev.type)));
 
@@ -305,7 +305,7 @@ TransportFSM::start_playback ()
 }
 
 void
-TransportFSM::start_declick (FSMEvent const & s)
+TransportFSM::start_declick (Event const & s)
 {
        assert (s.type == StopTransport);
        DEBUG_TRACE (DEBUG::TFSMEvents, "tfsm::start_declick\n");
@@ -320,16 +320,16 @@ TransportFSM::stop_playback ()
 }
 
 void
-TransportFSM::save_locate_and_start_declick (FSMEvent const & l)
+TransportFSM::save_locate_and_start_declick (Event const & l)
 {
        assert (l.type == Locate);
        DEBUG_TRACE (DEBUG::TFSMEvents, "tfsm::save_locate_and_stop\n");
        _last_locate = l;
-       _last_stop = FSMEvent (StopTransport, false, false);
+       _last_stop = Event (StopTransport, false, false);
 }
 
 void
-TransportFSM::start_locate (FSMEvent const & l)
+TransportFSM::start_locate (Event const & l)
 {
        assert (l.type == Locate);
        DEBUG_TRACE (DEBUG::TFSMEvents, "tfsm::start_locate\n");
@@ -344,7 +344,7 @@ TransportFSM::start_saved_locate ()
 }
 
 void
-TransportFSM::interrupt_locate (FSMEvent const & l)
+TransportFSM::interrupt_locate (Event const & l)
 {
        assert (l.type == Locate);
        DEBUG_TRACE (DEBUG::TFSMEvents, "tfsm::interrupt\n");
@@ -376,7 +376,7 @@ TransportFSM::roll_after_locate ()
 }
 
 void
-TransportFSM::defer (FSMEvent& ev)
+TransportFSM::defer (Event& ev)
 {
        DEBUG_TRACE (DEBUG::TFSMEvents, string_compose ("Defer %1 during %2\n", enum_2_string (ev.type), current_state()));
        deferred_events.push_back (ev);