#include <algorithm>
+#include <msp/strings/format.h>
#include <msp/time/units.h>
#include "block.h"
#include "driver.h"
#include "layout.h"
#include "route.h"
+#include "trackcircuit.h"
#include "trackiter.h"
#include "tracktype.h"
namespace R2C2 {
Block::Block(Layout &l, Track &start):
- layout(l),
+ TrackChain(l),
id(0),
- sensor_id(start.get_sensor_id()),
- turnout_id(start.get_turnout_id()),
- state(INACTIVE),
+ sensor_addr(start.get_sensor_address()),
+ turnout_addr(start.get_turnout_address()),
+ conflict(false),
+ sensor(0),
train(0)
{
- tracks.insert(&start);
- start.set_block(this);
+ add_track(start);
- list<Track *> queue;
- queue.push_back(&start);
-
- while(!queue.empty())
+ if(start.get_type().is_turnout())
{
- Track *track = queue.front();
- queue.erase(queue.begin());
-
- const vector<Track *> &links = track->get_links();
- for(unsigned i=0; i<links.size(); ++i)
- if(links[i] && !tracks.count(links[i]))
- {
- if(links[i]->get_sensor_id()==sensor_id && links[i]->get_turnout_id()==turnout_id)
- {
- queue.push_back(links[i]);
- tracks.insert(links[i]);
- links[i]->set_block(this);
- }
- else
- endpoints.push_back(Endpoint(track, i));
- }
+ unsigned nls = start.get_n_link_slots();
+ for(unsigned i=0; i<nls; ++i)
+ endpoints.push_back(Endpoint(&start, i));
+ }
+ else
+ {
+ unsigned nls = start.get_n_link_slots();
+ for(unsigned i=0; i<nls; ++i)
+ {
+ TrackIter iter = TrackIter(&start, i).flip();
+ for(; (iter && check_validity(*iter)==VALID); iter=iter.next())
+ add_track(*iter);
+ if((iter = iter.flip()))
+ endpoints.push_back(Endpoint(iter.track(), iter.entry()));
+ }
}
determine_id();
- for(unsigned i=0; i<endpoints.size(); ++i)
- {
- unsigned path = 1<<i;
- endpoints[i].paths |= path;
- find_paths(TrackIter(endpoints[i].track, endpoints[i].track_ep), path);
- }
+ const set<Block *> &blocks = layout.get_all<Block>();
+ for(set<Block *>::const_iterator i=blocks.begin(); (!conflict && i!=blocks.end()); ++i)
+ conflict = (id==(*i)->get_id());
- if(sensor_id && layout.has_driver())
- layout.get_driver().signal_sensor.connect(sigc::mem_fun(this, &Block::sensor_event));
+ if(!conflict && sensor_addr)
+ sensor = new TrackCircuit(layout, *this);
- layout.add_block(*this);
+ layout.add(*this);
}
Block::~Block()
blk->break_link(*this);
}
- layout.remove_block(*this);
+ layout.remove(*this);
+
+ delete sensor;
+}
+
+void Block::set_name(const string &)
+{
+ throw logic_error("Block names can't be set");
+}
+
+void Block::on_track_added(Track &track)
+{
+ track.set_block(this);
}
-bool Block::has_track(Track &t) const
+TrackChain::Validity Block::check_validity(Track &track) const
{
- return tracks.count(&t);
+ if(track.get_sensor_address()!=sensor_addr || track.get_turnout_address()!=turnout_addr)
+ return INCOMPATIBLE;
+
+ return TrackChain::check_validity(track);
}
const Block::Endpoint &Block::get_endpoint(unsigned i) const
{
if(i>=endpoints.size())
- throw InvalidParameterValue("Endpoint index out of range");
+ throw out_of_range("Block::get_endpoint");
return endpoints[i];
}
float Block::get_path_length(unsigned entry, const Route *route) const
{
if(entry>=endpoints.size())
- throw InvalidParameterValue("Endpoint index out of range");
+ throw out_of_range("Block::get_path_length");
- TrackIter t_iter(endpoints[entry].track, endpoints[entry].track_ep);
+ TrackIter t_iter = endpoints[entry].track_iter();
float result = 0;
while(t_iter && has_track(*t_iter))
Block *Block::get_link(unsigned epi) const
{
if(epi>=endpoints.size())
- throw InvalidParameterValue("Endpoint index out of range");
+ throw out_of_range("Block::get_link");
return endpoints[epi].link;
}
return false;
}
-void Block::tick(const Time::TimeDelta &dt)
+void Block::determine_id()
{
- if(state_confirm_timeout)
+ string n;
+ if(sensor_addr)
{
- state_confirm_timeout -= dt;
- if(state_confirm_timeout<=Time::zero)
- {
- if(state==MAYBE_INACTIVE)
- state = INACTIVE;
- else if(state==MAYBE_ACTIVE)
- state = ACTIVE;
- state_confirm_timeout = Time::zero;
- signal_state_changed.emit(state);
- }
+ id = 0x1000|sensor_addr;
+ n = format("Sensor %d", sensor_addr);
+ }
+ else if(turnout_addr)
+ {
+ id = 0x2000|turnout_addr;
+ n = format("Turnout %d", turnout_addr);
}
-}
-
-void Block::find_paths(TrackIter track, unsigned path)
-{
- unsigned mask = track.endpoint().paths;
- for(unsigned i=0; mask>>i; ++i)
- if(mask&(1<<i))
- {
- TrackIter next = track.next(i);
- if(!next)
- continue;
- else if(has_track(*next))
- find_paths(track.next(i), path);
- else
- {
- next = next.flip();
- for(vector<Endpoint>::iterator j=endpoints.begin(); j!=endpoints.end(); ++j)
- if(j->track==next.track() && j->track_ep==next.entry())
- j->paths |= path;
- }
- }
-}
-
-void Block::determine_id()
-{
- if(sensor_id)
- id = 0x1000|sensor_id;
- else if(turnout_id)
- id = 0x2000|turnout_id;
else if(endpoints.size()==2)
{
unsigned id1 = endpoints[0].link ? endpoints[0].link->get_id() : 1;
unsigned id1 = endpoints[0].link ? endpoints[0].link->get_id() : 1;
id = 0x10000 | id1;
}
+
+ if(n.empty())
+ n = format("Block %x", id);
+
+ name = n;
+ signal_name_changed.emit(name);
}
-void Block::sensor_event(unsigned addr, bool s)
+DataFile::Statement Block::save_reference() const
{
- if(addr==sensor_id)
- {
- if(s && state<MAYBE_ACTIVE)
- {
- state = MAYBE_ACTIVE;
- state_confirm_timeout = 300*Time::msec;
- signal_state_changed.emit(state);
- }
- else if(!s && state>MAYBE_INACTIVE)
- {
- state = MAYBE_INACTIVE;
- state_confirm_timeout = 700*Time::msec;
- signal_state_changed.emit(state);
- }
- }
+ return (DataFile::Statement("block"), id);
}
Block::Endpoint::Endpoint(Track *t, unsigned e):
track(t),
track_ep(e),
- link(0),
- paths(0)
+ link(0)
{ }
+TrackIter Block::Endpoint::track_iter() const
+{
+ return TrackIter(track, track_ep);
+}
+
} // namespace R2C2