Remove a queued block reservation if the block is released

[r2c2.git] / source / libr2c2 / layout.cpp

diff --git a/source/libr2c2/layout.cpp b/source/libr2c2/layout.cpp
index 0901382b91d0f140bb8ddf39010bf41228b33bfb..bc149dff1f904a014a0518052dacb36818a62fe6 100644 (file)
--- a/source/libr2c2/layout.cpp
+++ b/source/libr2c2/layout.cpp
@@ -1,5 +1,6 @@
 #include <algorithm>
 #include <msp/core/maputils.h>
+#include <msp/core/raii.h>
 #include <msp/core/refptr.h>
 #include <msp/datafile/parser.h>
 #include <msp/datafile/writer.h>
@@ -40,7 +41,8 @@ namespace R2C2 {
 Layout::Layout(Catalogue &c, Driver *d):
        catalogue(c),
        driver(d),
-       next_turnout_addr(0x800)
+       next_turnout_addr(0x800),
+       emitting_block_reserved(false)
 {
        clock.set_rate(60);
 }
@@ -69,31 +71,69 @@ Driver &Layout::get_driver() const
 void Layout::add(Object &o)
 {
        if(objects.insert(o))
-               signal_object_added.emit(o);
+       {
+               try
+               {
+                       signal_object_added.emit(o);
+               }
+               catch(...)
+               {
+                       objects.erase(o);
+                       throw;
+               }
+       }
 }
 
 void Layout::add(Track &t)
 {
        if(objects.insert(t))
        {
-               // Blocks must be recreated first
-               create_blocks();
-               signal_object_added.emit(t);
+               try
+               {
+                       // Blocks must be recreated first
+                       create_blocks();
+                       signal_object_added.emit(t);
+               }
+               catch(...)
+               {
+                       objects.erase(t);
+                       create_blocks();
+                       throw;
+               }
        }
 }
 
 void Layout::add(TrackChain &g)
 {
        if(track_chains.insert(g))
-               signal_track_chain_added.emit(g);
+       {
+               try
+               {
+                       signal_track_chain_added.emit(g);
+               }
+               catch(...)
+               {
+                       track_chains.erase(g);
+                       throw;
+               }
+       }
 }
 
 void Layout::add(Block &b)
 {
        if(track_chains.insert(b))
        {
-               b.signal_reserved.connect(sigc::bind<0>(signal_block_reserved, sigc::ref(b)));
-               signal_track_chain_added.emit(b);
+               sigc::connection conn = b.signal_reserved.connect(sigc::bind<0>(sigc::mem_fun(this, &Layout::block_reserved), sigc::ref(b)));
+               try
+               {
+                       signal_track_chain_added.emit(b);
+               }
+               catch(...)
+               {
+                       track_chains.erase(b);
+                       conn.disconnect();
+                       throw;
+               }
        }
 }
 
@@ -374,7 +414,7 @@ void Layout::remove_train(Train &t)
                signal_train_removed.emit(t);
 }
 
-void Layout::tick()
+void Layout::tick(float speed)
 {
        if(driver)
                driver->tick();
@@ -385,6 +425,15 @@ void Layout::tick()
                dt = t-last_tick;
        last_tick = t;
 
+       dt *= speed;
+       unsigned count = dt/(10*Time::msec)+1;
+       dt /= count;
+       while(count--)
+               step(dt);
+}
+
+void Layout::step(const Time::TimeDelta &dt)
+{
        if(!driver || !driver->is_halted())
                clock.tick(dt);
 
@@ -485,7 +534,12 @@ void Layout::save_dynamic(const string &fn) const
        const set<Track *> &tracks = objects.get<Track>();
        for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
                if((*i)->get_type().is_turnout())
-                       writer.write((DataFile::Statement("turnout"), (*i)->get_turnout_address(), (*i)->get_active_path()));
+               {
+                       DataFile::Statement st("turnout");
+                       st.append((*i)->get_turnout_address());
+                       (*i)->save_dynamic(st.sub);
+                       writer.write(st);
+               }
 
        for(map<unsigned, Train *>::const_iterator i=trains.begin(); i!=trains.end(); ++i)
        {
@@ -508,6 +562,35 @@ void Layout::sensor_state_changed(Sensor &sensor, Sensor::State state)
        }
 }
 
+void Layout::block_reserved(Block &block, Train *train)
+{
+       if(emitting_block_reserved)
+       {
+               if(!train)
+               {
+                       for(deque<BlockReservation>::iterator i=block_reserve_queue.end(); i!=block_reserve_queue.begin(); )
+                               if((--i)->block==&block)
+                               {
+                                       block_reserve_queue.erase(i);
+                                       return;
+                               }
+               }
+
+               block_reserve_queue.push_back(BlockReservation(block, train));
+       }
+       else
+       {
+               SetFlag setf(emitting_block_reserved);
+               signal_block_reserved.emit(block, train);
+               while(!block_reserve_queue.empty())
+               {
+                       BlockReservation br = block_reserve_queue.front();
+                       block_reserve_queue.pop_front();
+                       signal_block_reserved.emit(*br.block, br.train);
+               }
+       }
+}
+
 
 template<typename B>
 Layout::Storage<B>::~Storage()
@@ -562,6 +645,12 @@ void Layout::Storage<B>::del()
 }
 
 
+Layout::BlockReservation::BlockReservation(Block &b, Train *t):
+       block(&b),
+       train(t)
+{ }
+
+
 Layout::Loader::Loader(Layout &l):
        DataFile::ObjectLoader<Layout>(l)
 {
@@ -575,6 +664,9 @@ Layout::Loader::Loader(Layout &l):
        add("train", &Loader::train);
        add("turnout", &Loader::turnout);
        add("zone",  &Loader::zone);
+
+       // Deprecated
+       add("turnout", &Loader::turnout2);
 }
 
 void Layout::Loader::beamgate()
@@ -622,8 +714,24 @@ void Layout::Loader::train(const string &n, unsigned addr, const std::string &pr
        load_sub(*trn);
 }
 
-void Layout::Loader::turnout(unsigned addr, unsigned path)
+void Layout::Loader::turnout(unsigned addr)
+{
+       /* Kinda slow, but maintaining a map of turnouts seems more trouble than
+       it's worth at this point. */
+       const set<Track *> &tracks = obj.objects.get<Track>();
+       for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
+               if((*i)->get_turnout_address()==addr)
+               {
+                       load_sub(**i);
+                       return;
+               }
+
+       throw key_error(addr);
+}
+
+void Layout::Loader::turnout2(unsigned addr, unsigned path)
 {
+       // XXX Discrepancy between ids and addresses
        if(obj.driver)
                obj.driver->set_turnout(addr, path);
 }