X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Flibr2c2%2Fblockallocator.cpp;h=ed32193f3e1d116b65b557d9bb8619f82dc0bf41;hb=9cb5f9ef3c0eaac499ef5d045c513116d6809e56;hp=ff5776d3281f1b166af785b708b2e4e0a267424d;hpb=83c2811157e9861a72e1ece34160cb014ef35fb5;p=r2c2.git diff --git a/source/libr2c2/blockallocator.cpp b/source/libr2c2/blockallocator.cpp index ff5776d..ed32193 100644 --- a/source/libr2c2/blockallocator.cpp +++ b/source/libr2c2/blockallocator.cpp @@ -1,5 +1,6 @@ #include #include +#include "beamgate.h" #include "blockallocator.h" #include "block.h" #include "catalogue.h" @@ -27,7 +28,9 @@ struct BlockAllocator::BlockMatch BlockAllocator::BlockAllocator(Train &t): train(t), + active(false), cur_blocks_end(blocks.end()), + next_sensor(0), pending_block(0), stop_at_block(0), reserving(false), @@ -39,7 +42,7 @@ BlockAllocator::BlockAllocator(Train &t): const set &tracks = layout.get_all(); for(set::const_iterator i=tracks.begin(); i!=tracks.end(); ++i) - if((*i)->get_turnout_id()) + if((*i)->get_type().is_turnout()) { (*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)))); @@ -58,13 +61,53 @@ void BlockAllocator::set_active(bool a) } } -void BlockAllocator::start_from(const BlockIter &block) +bool BlockAllocator::start_from(const BlockIter &block) { if(!block) throw invalid_argument("BlockAllocator::start_from"); + float remaining_length = 0; + unsigned n_vehs = train.get_n_vehicles(); + for(unsigned i=0; iget_train()) + break; + blocks_to_reserve.push_back(b); + for(TrackIter t=b.track_iter(); (t && &t->get_block()==&*b); t=t.next()) + remaining_length -= t->get_path_length(); + if(remaining_length<=0) + break; + } + + if(remaining_length>0) + return false; + + for(BlockList::iterator i=blocks_to_reserve.begin(); i!=blocks_to_reserve.end(); ++i) + { + blocks.push_back(*i); + try + { + (*i)->reserve(&train); + } + catch(...) + { + blocks.pop_back(); + while(i!=blocks_to_reserve.begin()) + { + blocks.pop_back(); + (*--i)->reserve(0); + } + throw; + } + } + + return true; } void BlockAllocator::rewind_to(const Block &block) @@ -84,6 +127,7 @@ void BlockAllocator::clear() { release_blocks_begin(blocks.end()); active = false; + next_sensor = 0; pending_block = 0; stop_at_block = 0; } @@ -152,7 +196,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; } @@ -163,7 +207,7 @@ void BlockAllocator::reserve_more() float dist = 0; for(BlockList::const_iterator i=cur_blocks_end; i!=blocks.end(); ++i) { - if((*i)->get_sensor_id()) + if((*i)->get_sensor_address()) ++nsens; if(nsens>0) dist += (*i)->get_path_length(i->entry()); @@ -184,7 +228,7 @@ void BlockAllocator::reserve_more() // The track ends here break; - if(block->get_turnout_id() && !prev->get_turnout_id()) + if(block->get_turnout_address() && !prev->get_turnout_address()) { /* We are arriving at a turnout. See if we have enough blocks and distance reserved. */ @@ -235,15 +279,18 @@ void BlockAllocator::reserve_more() if(&*block==stop_at_block) break; - if(block->get_sensor_id()) + if(block->get_sensor_address()) ++nsens; if(nsens>0) dist += block->get_path_length(block.entry()); } - // Make any sensorless blocks at the beginning immediately current - while(cur_blocks_end!=blocks.end() && !(*cur_blocks_end)->get_sensor_id()) - ++cur_blocks_end; + if(!next_sensor) + { + update_next_sensor(0); + // Immediately advance to just before the next sensor + advance_front(next_sensor); + } } bool BlockAllocator::reserve_block(const BlockIter &block) @@ -251,10 +298,17 @@ bool BlockAllocator::reserve_block(const BlockIter &block) /* Add it to the list first to present a consistent state in block_reserved signal. */ blocks.push_back(block); + + bool first_reserve = (cur_blocks_end==blocks.end()); + if(first_reserve) + --cur_blocks_end; + try { if(!block->reserve(&train)) { + if(first_reserve) + cur_blocks_end = blocks.end(); blocks.pop_back(); return false; } @@ -263,11 +317,102 @@ bool BlockAllocator::reserve_block(const BlockIter &block) } catch(...) { + if(first_reserve) + cur_blocks_end = blocks.end(); blocks.pop_back(); throw; } } +void BlockAllocator::advance_front(const Block *block, bool inclusive) +{ + BlockList::iterator end; + if(block) + { + end = cur_blocks_end; + if(inclusive) + --end; + end = find_if(end, blocks.end(), BlockMatch(*block)); + if(inclusive && end!=blocks.end()) + ++end; + } + else + end = blocks.end(); + + if(end==blocks.end() && blocks.back().block()==pending_block) + --end; + + SetFlag setf(advancing); + BlockList::iterator i = cur_blocks_end; + // Update cur_blocks_end first to keep things consistent. + cur_blocks_end = end; + for(; i!=end; ++i) + train.signal_advanced.emit(**i); +} + +void BlockAllocator::advance_front(const Sensor *sensor) +{ + if(sensor) + advance_front(sensor->get_block(), dynamic_cast(sensor)); + else + advance_front(0, false); +} + +void BlockAllocator::advance_back() +{ + bool rev = train.get_controller().get_reverse(); + const Vehicle &veh = train.get_vehicle(rev ? 0 : train.get_n_vehicles()-1); + const Block &veh_block = veh.get_placement().get_position(rev ? VehiclePlacement::FRONT_AXLE : VehiclePlacement::BACK_AXLE)->get_block(); + + /* 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) + { + Block *block = &**i; + list sensors; + + /* Collect all sensors from the block in the order they are expected to + detrigger. */ + for(TrackIter j=i->track_iter(); (j && &j->get_block()==block); j=j.next()) + if(!j->get_attachments().empty()) + { + Track::AttachmentList attachments = j->get_attachments_ordered(j.entry()); + for(Track::AttachmentList::const_iterator k=attachments.begin(); k!=attachments.end(); ++k) + if(BeamGate *gate = dynamic_cast(*k)) + sensors.push_back(gate); + } + + if(Sensor *sensor = (*i)->get_sensor()) + sensors.push_back(sensor); + + /* See if any sensor is still active, and record the position of the + last inactive sensor. */ + bool active_sensor = false; + for(list::const_iterator j=sensors.begin(); (!active_sensor && j!=sensors.end()); ++j) + { + if((*j)->get_state()) + active_sensor = true; + else + end = i; + } + + // Stop if we encounter an active sensor or the train's last vehicle + if(block==&veh_block || active_sensor) + { + if(end!=blocks.end()) + { + /* If the last inactive sensor was in an earlier block, release + that block as well. */ + if(i!=end) + ++end; + release_blocks_begin(end); + } + return; + } + } +} + void BlockAllocator::release_blocks_begin(const BlockList::iterator &end) { for(BlockList::iterator i=blocks.begin(); i!=end; ) @@ -299,6 +444,8 @@ void BlockAllocator::release_block(const BlockList::iterator &i) throw logic_error("cannot release while advancing"); if(i==cur_blocks_end) ++cur_blocks_end; + if(next_sensor && &**i==next_sensor->get_block()) + next_sensor = 0; if(&**i==pending_block) pending_block = 0; @@ -320,7 +467,7 @@ void BlockAllocator::reverse() void BlockAllocator::turnout_path_changing(Track &track) { - BlockList::iterator i = find_if(blocks.begin(), blocks.end(), BlockMatch(track.get_block())); + BlockList::iterator i = find_if(cur_blocks_end, blocks.end(), BlockMatch(track.get_block())); if(i!=blocks.end()) { ++i; @@ -343,81 +490,73 @@ void BlockAllocator::block_reserved(Block &block, const Train *tr) void BlockAllocator::sensor_state_changed(Sensor &sensor, Sensor::State state) { - Block *block = 0; - if(TrackCircuit *tc = dynamic_cast(&sensor)) - block = &tc->get_block(); - else - return; - - if(block->get_train()!=&train) + 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; - unsigned result = 0; - for(end=cur_blocks_end; end!=blocks.end(); ++end) - if((*end)->get_sensor_id()) - { - if(&**end!=block) - { - if(result==0) - result = 2; - else if(result==1) - break; - } - else if(result==0) - result = 1; - else if(result==2) - result = 3; - } - - if(result==1) + if(&sensor==next_sensor) { - /* 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; + update_next_sensor(next_sensor); + advance_front(next_sensor); if(active) reserve_more(); } - else if(result==3) - train.get_layout().emergency("Sensor for "+train.get_name()+" triggered out of order"); + else if(!is_block_current(*block)) + train.get_layout().emergency(block, "Sensor for "+train.get_name()+" triggered out of order"); } else if(state==Sensor::INACTIVE) + advance_back(); +} + +void BlockAllocator::update_next_sensor(Sensor *after) +{ + BeamGate *after_gate = dynamic_cast(after); + + BlockList::iterator i = cur_blocks_end; + if(after) { - 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(); - - /* 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) - { - // Avoid freeing blocks that still hold the train's vehicles - if(&**i==&veh_block) - break; + if(after_gate) + --i; + i = find_if(i, blocks.end(), BlockMatch(*after->get_block())); + } - if((*i)->get_sensor_id()) + for(; i!=blocks.end(); ++i) + { + if(Sensor *sensor = (*i)->get_sensor()) + { + if(!after_gate && sensor!=next_sensor) { - if(driver.get_sensor((*i)->get_sensor_id())) - break; - else - end = i; + next_sensor = sensor; + return; } } - - if(end!=blocks.end()) - // Free blocks up to the last inactive sensor - release_blocks_begin(++end); + + Block *block = &**i; + for(TrackIter j=i->track_iter(); (j && &j->get_block()==block); j=j.next()) + if(!j->get_attachments().empty()) + { + Track::AttachmentList attachments = j->get_attachments_ordered(j.entry()); + for(Track::AttachmentList::const_iterator k=attachments.begin(); k!=attachments.end(); ++k) + if(BeamGate *gate = dynamic_cast(*k)) + { + if(after_gate) + { + if(gate==after_gate) + after_gate = 0; + } + else + { + next_sensor = gate; + return; + } + } + } } + + next_sensor = 0; } void BlockAllocator::save(list &st) const @@ -475,8 +614,8 @@ void BlockAllocator::Loader::block(unsigned id) obj.blocks.push_back(BlockIter(blk, entry)); blk->reserve(&obj.train); - if(blk->get_sensor_id()) - obj.train.get_layout().get_driver().set_sensor(blk->get_sensor_id(), true); + if(blk->get_sensor_address()) + obj.train.get_layout().get_driver().set_sensor(blk->get_sensor_address(), true); prev_block = blk; }