X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Flibr2c2%2Fblockallocator.cpp;h=347960ee2ec584029a7bc66dffaaabb56de0cdad;hb=d41f66805bc9fe0b33e3d46b47f52e67b5782028;hp=ff5776d3281f1b166af785b708b2e4e0a267424d;hpb=83c2811157e9861a72e1ece34160cb014ef35fb5;p=r2c2.git diff --git a/source/libr2c2/blockallocator.cpp b/source/libr2c2/blockallocator.cpp index ff5776d..347960e 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" @@ -28,6 +29,7 @@ struct BlockAllocator::BlockMatch BlockAllocator::BlockAllocator(Train &t): train(t), cur_blocks_end(blocks.end()), + next_sensor(0), pending_block(0), stop_at_block(0), reserving(false), @@ -84,6 +86,7 @@ void BlockAllocator::clear() { release_blocks_begin(blocks.end()); active = false; + next_sensor = 0; pending_block = 0; stop_at_block = 0; } @@ -152,7 +155,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; } @@ -241,9 +244,12 @@ void BlockAllocator::reserve_more() 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 +257,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 +276,98 @@ 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(); + + 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() +{ + 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(); + + /* 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 +399,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 +422,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 +445,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) + else if(!is_block_current(*block)) train.get_layout().emergency("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