X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Flibr2c2%2Fblockallocator.cpp;h=fc2705cd58d81bc5e5ec8060b4f03653d753f6b0;hb=f730acd5fa2b4f0d0185770ff7950ab814aec47c;hp=c9cc5b44440fe6987dff33fb0939cfbf4ca79363;hpb=54392d65e2053d1eacb4cfcc435f1013993f2973;p=r2c2.git

diff --git a/source/libr2c2/blockallocator.cpp b/source/libr2c2/blockallocator.cpp
index c9cc5b4..fc2705c 100644
--- a/source/libr2c2/blockallocator.cpp
+++ b/source/libr2c2/blockallocator.cpp
@@ -1,9 +1,11 @@
 #include <msp/core/maputils.h>
 #include <msp/core/raii.h>
 #include "blockallocator.h"
+#include "block.h"
 #include "catalogue.h"
 #include "driver.h"
 #include "layout.h"
+#include "trackcircuit.h"
 #include "trackiter.h"
 #include "train.h"
 #include "vehicle.h"
@@ -13,21 +15,47 @@ using namespace Msp;
 
 namespace R2C2 {
 
+struct BlockAllocator::BlockMatch
+{
+	const Block &block;
+
+	BlockMatch(const Block &b): block(b) { }
+
+	bool operator()(const BlockIter &bi) const { return &*bi==&block; }
+};
+
+
 BlockAllocator::BlockAllocator(Train &t):
 	train(t),
 	cur_blocks_end(blocks.end()),
 	pending_block(0),
 	stop_at_block(0),
-	reserving(false)
+	reserving(false),
+	advancing(false)
 {
 	Layout &layout = train.get_layout();
 	layout.signal_block_reserved.connect(sigc::mem_fun(this, &BlockAllocator::block_reserved));
-	layout.signal_block_state_changed.connect(sigc::mem_fun(this, &BlockAllocator::block_state_changed));
+	layout.signal_sensor_state_changed.connect(sigc::mem_fun(this, &BlockAllocator::sensor_state_changed));
 
-	const set<Track *> &tracks = layout.get_tracks();
+	const set<Track *> &tracks = layout.get_all<Track>();
 	for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
 		if((*i)->get_turnout_id())
+		{
+			(*i)->signal_path_changing.connect(sigc::hide(sigc::bind(sigc::mem_fun(this, &BlockAllocator::turnout_path_changing), sigc::ref(**i))));
 			(*i)->signal_path_changed.connect(sigc::hide(sigc::bind(sigc::mem_fun(this, &BlockAllocator::turnout_path_changed), sigc::ref(**i))));
+		}
+}
+
+void BlockAllocator::set_active(bool a)
+{
+	active = a;
+	if(active)
+		reserve_more();
+	else
+	{
+		release_blocks_end(cur_blocks_end);
+		pending_block = 0;
+	}
 }
 
 void BlockAllocator::start_from(const BlockIter &block)
@@ -35,19 +63,27 @@ void BlockAllocator::start_from(const BlockIter &block)
 	if(!block)
 		throw invalid_argument("BlockAllocator::start_from");
 
-	release_blocks(blocks.begin(), blocks.end());
+	clear();
+	reserve_block(block);
+}
 
-	blocks.push_back(block);
-	if(!block->reserve(&train))
-	{
-		blocks.pop_back();
+void BlockAllocator::rewind_to(const Block &block)
+{
+	if(!active)
 		return;
+
+	BlockList::iterator i = find_if(cur_blocks_end, blocks.end(), BlockMatch(block));
+	if(i!=blocks.end())
+	{
+		release_blocks_end(i);
+		reserve_more();
 	}
 }
 
 void BlockAllocator::clear()
 {
-	release_blocks(blocks.begin(), blocks.end());
+	release_blocks_begin(blocks.end());
+	active = false;
 	pending_block = 0;
 	stop_at_block = 0;
 }
@@ -55,6 +91,8 @@ void BlockAllocator::clear()
 void BlockAllocator::stop_at(const Block *block)
 {
 	stop_at_block = block;
+	if(active && !block)
+		reserve_more();
 }
 
 const BlockIter &BlockAllocator::first() const
@@ -84,12 +122,23 @@ const BlockIter &BlockAllocator::last_current() const
 	return *--i;
 }
 
-int BlockAllocator::get_entry_to_block(const Block &block) const
+const BlockIter &BlockAllocator::iter_for(const Block &block) const
+{
+	BlockList::const_iterator i = find_if(blocks.begin(), blocks.end(), BlockMatch(block));
+	if(i==blocks.end())
+		throw key_error(&block);
+	return *i;
+}
+
+bool BlockAllocator::has_block(const Block &block) const
 {
-	for(BlockList::const_iterator i=blocks.begin(); i!=blocks.end(); ++i)
-		if(i->block()==&block)
-			return i->entry();
-	return -1;
+	return find_if(blocks.begin(), blocks.end(), BlockMatch(block))!=blocks.end();
+}
+
+bool BlockAllocator::is_block_current(const Block &block) const
+{
+	BlockList::const_iterator end = cur_blocks_end;
+	return find_if(blocks.begin(), end, BlockMatch(block))!=cur_blocks_end;
 }
 
 void BlockAllocator::reserve_more()
@@ -103,7 +152,7 @@ void BlockAllocator::reserve_more()
 	else if(&*start==pending_block)
 	{
 		TrackIter track = start.track_iter();
-		if(!track.endpoint().has_path(track->get_active_path()))
+		if(track->is_path_changing() || !track.endpoint().has_path(track->get_active_path()))
 			return;
 	}
 
@@ -143,10 +192,8 @@ void BlockAllocator::reserve_more()
 				break;
 		}
 
-		blocks.push_back(block);
-		if(!block->reserve(&train))
+		if(!reserve_block(block))
 		{
-			blocks.pop_back();
 			pending_block = &*block;
 			break;
 		}
@@ -199,66 +246,93 @@ void BlockAllocator::reserve_more()
 		++cur_blocks_end;
 }
 
-void BlockAllocator::release_until(const Block &block)
+bool BlockAllocator::reserve_block(const BlockIter &block)
 {
-	for(BlockList::iterator i=blocks.begin(); i!=cur_blocks_end; ++i)
-		if(i->block()==&block)
+	/* Add it to the list first to present a consistent state in block_reserved
+	signal. */
+	blocks.push_back(block);
+	try
+	{
+		if(!block->reserve(&train))
 		{
-			if(++i!=cur_blocks_end)
-				release_blocks(blocks.begin(), i);
-			return;
+			blocks.pop_back();
+			return false;
 		}
-}
 
-bool BlockAllocator::release_from(const Block &block)
-{
-	bool have_sensor = false;
-	for(BlockList::iterator i=cur_blocks_end; i!=blocks.end(); ++i)
+		return true;
+	}
+	catch(...)
 	{
-		if(i->block()==&block)
-		{
-			if(have_sensor)
-				release_blocks(i, blocks.end());
-			return have_sensor;
-		}
-		else if((*i)->get_sensor_id())
-			have_sensor = true;
+		blocks.pop_back();
+		throw;
 	}
-
-	return false;
 }
 
-void BlockAllocator::release_noncurrent()
+void BlockAllocator::release_blocks_begin(const BlockList::iterator &end)
 {
-	release_blocks(cur_blocks_end, blocks.end());
+	for(BlockList::iterator i=blocks.begin(); i!=end; )
+		release_block(i++);
 }
 
-void BlockAllocator::release_blocks(const BlockList::iterator &b, const BlockList::iterator &e)
+void BlockAllocator::release_blocks_end(const BlockList::iterator &begin)
 {
-	for(BlockList::iterator i=b; i!=e; )
-	{
-		if(cur_blocks_end==i)
-			cur_blocks_end = e;
+	// Guard against decrementing blocks.begin()
+	if(begin==blocks.begin())
+		return release_blocks_begin(blocks.end());
+
+	if(begin==blocks.end())
+		return;
 
-		Block &block = **i;
-		blocks.erase(i++);
-		block.reserve(0);
+	/* Release the blocks in reverse order so that a consistent state is
+	presented in block_reserved signal. */
+	bool done = false;
+	for(BlockList::iterator i=--blocks.end(); !done; )
+	{
+		done = (i==begin);
+		release_block(i--);
 	}
 }
 
+void BlockAllocator::release_block(const BlockList::iterator &i)
+{
+	if(advancing)
+		throw logic_error("cannot release while advancing");
+	if(i==cur_blocks_end)
+		++cur_blocks_end;
+	if(&**i==pending_block)
+		pending_block = 0;
+
+	Block &block = **i;
+	blocks.erase(i);
+	block.reserve(0);
+}
+
 void BlockAllocator::reverse()
 {
-	release_noncurrent();
+	release_blocks_end(cur_blocks_end);
 	blocks.reverse();
 	for(BlockList::iterator i=blocks.begin(); i!=blocks.end(); ++i)
 		*i = i->reverse();
+
+	if(active)
+		reserve_more();
+}
+
+void BlockAllocator::turnout_path_changing(Track &track)
+{
+	BlockList::iterator i = find_if(blocks.begin(), blocks.end(), BlockMatch(track.get_block()));
+	if(i!=blocks.end())
+	{
+		++i;
+		release_blocks_end(i);
+		pending_block = &track.get_block();
+	}
 }
 
 void BlockAllocator::turnout_path_changed(Track &track)
 {
-	for(list<BlockIter>::iterator i=blocks.begin(); i!=blocks.end(); ++i)
-		if((*i)->get_turnout_id()==track.get_turnout_id() && !reserving && &**i==pending_block)
-			reserve_more();
+	if(&track.get_block()==pending_block && !reserving)
+		reserve_more();
 }
 
 void BlockAllocator::block_reserved(Block &block, const Train *tr)
@@ -267,9 +341,13 @@ void BlockAllocator::block_reserved(Block &block, const Train *tr)
 		reserve_more();
 }
 
-void BlockAllocator::block_state_changed(Block &block, Block::State state)
+void BlockAllocator::sensor_state_changed(Sensor &sensor, Sensor::State state)
 {
-	if(state==Block::MAYBE_ACTIVE)
+	Block *block = sensor.get_block();
+	if(!block || block->get_train()!=&train)
+		return;
+
+	if(state==Sensor::MAYBE_ACTIVE)
 	{
 		// Find the first sensor block from our reserved blocks that isn't this sensor
 		BlockList::iterator end;
@@ -277,7 +355,7 @@ void BlockAllocator::block_state_changed(Block &block, Block::State state)
 		for(end=cur_blocks_end; end!=blocks.end(); ++end)
 			if((*end)->get_sensor_id())
 			{
-				if(&**end!=&block)
+				if(&**end!=block)
 				{
 					if(result==0)
 						result = 2;
@@ -292,39 +370,48 @@ void BlockAllocator::block_state_changed(Block &block, Block::State state)
 
 		if(result==1)
 		{
-			// Move blocks up to the next sensor to our current blocks
-			for(BlockList::iterator j=cur_blocks_end; j!=end; ++j)
-				train.signal_advanced.emit(**j);
+			/* Advance the train to the new blocks.  Update cur_blocks_end first
+			to keep things in sync. */
+			SetFlag setf(advancing);
+			BlockList::iterator i = cur_blocks_end;
 			cur_blocks_end = end;
+			for(; i!=end; ++i)
+				train.signal_advanced.emit(**i);
+			advancing = false;
+
+			if(active)
+				reserve_more();
 		}
 		else if(result==3)
 			train.get_layout().emergency("Sensor for "+train.get_name()+" triggered out of order");
 	}
-	else if(state==Block::INACTIVE)
+	else if(state==Sensor::INACTIVE)
 	{
-		const Vehicle &veh = train.get_controller().get_reverse() ? train.get_vehicle(0) : train.get_vehicle(train.get_n_vehicles()-1);
+		const Vehicle &veh = train.get_vehicle(train.get_controller().get_reverse() ? 0 : train.get_n_vehicles()-1);
+		const Block &veh_block = veh.get_track()->get_block();
+		const Driver &driver = train.get_layout().get_driver();
 
-		// Find the first sensor in our current blocks that's still active
-		BlockList::iterator end = blocks.begin();
+		/* Sensors aren't guaranteed to be detriggered in order.  Go through the
+		block list and locate the first sensor that's still active. */
+		BlockList::iterator end = blocks.end();
 		for(BlockList::iterator i=blocks.begin(); i!=cur_blocks_end; ++i)
 		{
-			if((*i)->has_track(*veh.get_track()))
+			// Avoid freeing blocks that still hold the train's vehicles
+			if(&**i==&veh_block)
 				break;
+
 			if((*i)->get_sensor_id())
 			{
-				if(train.get_layout().get_driver().get_sensor((*i)->get_sensor_id()))
+				if(driver.get_sensor((*i)->get_sensor_id()))
 					break;
 				else
-				{
 					end = i;
-					++end;
-				}
 			}
 		}
 		
-		if(end!=blocks.begin() && end!=cur_blocks_end)
+		if(end!=blocks.end())
 			// Free blocks up to the last inactive sensor
-			release_blocks(blocks.begin(), end);
+			release_blocks_begin(++end);
 	}
 }