X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Flibr2c2%2Fblockallocator.cpp;h=7e992e00f41b65f6aecdc6afd6e89ec03e899bd0;hb=7f63edbdf0d3c08893bdd2341ec3e50fb1ccc6f8;hp=8d3381da20ecada6172781d064b9feba998e669a;hpb=c4daf1cc6b53cae34e46d4125a993ceed500de1a;p=r2c2.git diff --git a/source/libr2c2/blockallocator.cpp b/source/libr2c2/blockallocator.cpp index 8d3381d..7e992e0 100644 --- a/source/libr2c2/blockallocator.cpp +++ b/source/libr2c2/blockallocator.cpp @@ -28,6 +28,7 @@ struct BlockAllocator::BlockMatch BlockAllocator::BlockAllocator(Train &t): train(t), + active(false), cur_blocks_end(blocks.end()), next_sensor(0), pending_block(0), @@ -41,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)))); @@ -60,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) @@ -166,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()); @@ -187,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. */ @@ -212,33 +253,23 @@ void BlockAllocator::reserve_more() } else { - const TrackType::Endpoint &entry_ep = track.endpoint(); unsigned path = track->get_active_path(); - if(!entry_ep.has_path(path)) + if(!track.endpoint().has_path(path)) { - const TrackType::Endpoint &exit_ep = track.reverse().endpoint(); - if(entry_ep.has_common_paths(exit_ep)) + path = track->get_type().coerce_path(track.entry(), path); + track->set_active_path(path); + if(track->is_path_changing()) { - unsigned mask = entry_ep.paths&exit_ep.paths; - for(path=0; mask>1; ++path, mask>>=1) ; - - track->set_active_path(path); - if(track->is_path_changing()) - { - pending_block = &*block; - break; - } - } - else - // XXX Do something here + pending_block = &*block; break; + } } } 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()); @@ -257,10 +288,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; } @@ -269,6 +307,8 @@ bool BlockAllocator::reserve_block(const BlockIter &block) } catch(...) { + if(first_reserve) + cur_blocks_end = blocks.end(); blocks.pop_back(); throw; } @@ -289,12 +329,15 @@ void BlockAllocator::advance_front(const Block *block, bool inclusive) 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); + signal_advanced.emit(**i, (*i)->get_sensor()); } void BlockAllocator::advance_front(const Sensor *sensor) @@ -307,19 +350,22 @@ void BlockAllocator::advance_front(const Sensor *sensor) 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(); + 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(); + + bool pending_cleared = false; /* Sensors aren't guaranteed to be detriggered in order. Go through the block list and locate the first sensor that's still active. */ - Sensor *last_inactive = 0; - for(BlockList::iterator i=blocks.begin(); (i!=cur_blocks_end && i->block()!=&veh_block); ++i) + BlockList::iterator end = blocks.end(); + for(BlockList::iterator i=blocks.begin(); i!=cur_blocks_end; ++i) { + Block *block = &**i; list sensors; - if(Sensor *sensor = (*i)->get_sensor()) - sensors.push_back(sensor); - Block *block = &**i; + /* 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()) { @@ -329,20 +375,40 @@ void BlockAllocator::advance_back() sensors.push_back(gate); } - for(list::const_iterator j=sensors.begin(); j!=sensors.end(); ++j) + 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; + } + + if(block==pending_block) + pending_cleared = true; + + // Stop if we encounter an active sensor or the train's last vehicle + if(block==&veh_block || active_sensor) + { + if(end!=blocks.end()) { - if(last_inactive) - { - if(dynamic_cast(*j)) - ++i; - release_blocks_begin(i); - } - return; + /* If the last inactive sensor was in an earlier block, release + that block as well. */ + if(i!=end) + ++end; + release_blocks_begin(end); + signal_rear_advanced.emit(*last()); } - else - last_inactive = *j; + + if(pending_cleared) + reserve_more(); + + return; } } } @@ -401,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; @@ -432,6 +498,8 @@ void BlockAllocator::sensor_state_changed(Sensor &sensor, Sensor::State state) { if(&sensor==next_sensor) { + if(is_block_current(*block)) + signal_advanced.emit(*block, &sensor); update_next_sensor(next_sensor); advance_front(next_sensor); @@ -439,7 +507,7 @@ void BlockAllocator::sensor_state_changed(Sensor &sensor, Sensor::State state) reserve_more(); } else if(!is_block_current(*block)) - train.get_layout().emergency("Sensor for "+train.get_name()+" triggered out of order"); + train.get_layout().emergency(block, "Sensor for "+train.get_name()+" triggered out of order"); } else if(state==Sensor::INACTIVE) advance_back(); @@ -548,8 +616,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; }