#include "trackcircuit.h"
#include "tracktype.h"
#include "train.h"
+#include "vehicle.h"
#include "vehicletype.h"
#include "zone.h"
delete *routes.begin();
while(!zones.empty())
delete *zones.begin();
- while(!signals.empty())
- delete *signals.begin();
- while(!tracks.empty())
- delete *tracks.begin();
+ objects.del<Signal>();
+ objects.del<Track>();
while(!blocks.empty())
delete *blocks.begin();
}
return *driver;
}
-void Layout::add_track(Track &t)
+void Layout::add(Object &o)
{
- if(tracks.insert(&t).second)
+ if(objects.insert(o))
+ signal_object_added.emit(o);
+}
+
+void Layout::add(Track &t)
+{
+ if(objects.insert(t))
{
+ // Blocks must be recreated first
create_blocks();
- signal_track_added.emit(t);
+ signal_object_added.emit(t);
}
}
-Track *Layout::pick_track(const Ray &ray)
+template<>
+const set<Object *> &Layout::get_all<Object>() const
{
- return pick(tracks, ray);
+ return objects.get();
}
-void Layout::remove_track(Track &t)
+template<>
+const set<Track *> &Layout::get_all<Track>() const
{
- if(tracks.erase(&t))
- {
- create_blocks(t);
- signal_track_removed.emit(t);
- }
+ return objects.get<Track>();
}
-unsigned Layout::allocate_turnout_id()
+template<>
+const set<Signal *> &Layout::get_all<Signal>() const
{
- set<unsigned> used_ids;
- for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
- if((*i)->get_turnout_id())
- used_ids.insert((*i)->get_turnout_id());
-
- unsigned result = next_turnout_id;
- while(used_ids.count(result))
- ++result;
- next_turnout_id = result+1;
-
- return result;
+ return objects.get<Signal>();
}
-void Layout::add_signal(Signal &s)
+template<>
+const set<Vehicle *> &Layout::get_all<Vehicle>() const
{
- if(signals.insert(&s).second)
- signal_signal_added.emit(s);
+ return objects.get<Vehicle>();
}
-Signal *Layout::pick_signal(const Ray &ray)
+template<typename T>
+T *Layout::pick(const Ray &ray)
{
- return pick(signals, ray);
+ const set<Object *> &objs = objects.get();
+ for(set<Object *>::const_iterator i=objs.begin(); i!=objs.end(); ++i)
+ if(T *t = dynamic_cast<T *>(*i))
+ if(t->collide_ray(ray))
+ return t;
+
+ return 0;
}
-void Layout::remove_signal(Signal &s)
+template Object *Layout::pick<Object>(const Ray &);
+template Track *Layout::pick<Track>(const Ray &);
+template Signal *Layout::pick<Signal>(const Ray &);
+template Vehicle *Layout::pick<Vehicle>(const Ray &);
+
+void Layout::remove(Object &o)
{
- if(signals.erase(&s))
- signal_signal_removed.emit(s);
+ if(objects.erase(o))
+ signal_object_removed.emit(o);
}
-Object *Layout::pick_object(const Ray &ray)
+void Layout::remove(Track &t)
{
- if(Object *obj = pick_track(ray))
- return obj;
- else if((obj = pick_signal(ray)))
- return obj;
- return 0;
+ if(objects.erase(t))
+ {
+ // Blocks must be recreated first
+ create_blocks(t);
+ signal_object_removed.emit(t);
+ }
}
-template<typename T>
-T *Layout::pick(const set<T *> &objs, const Ray &ray)
+unsigned Layout::allocate_turnout_id()
{
- for(typename set<T *>::const_iterator i=objs.begin(); i!=objs.end(); ++i)
- if((*i)->collide_ray(ray))
- return *i;
+ set<unsigned> used_ids;
+ const set<Track *> &tracks = objects.get<Track>();
+ for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
+ if((*i)->get_turnout_id())
+ used_ids.insert((*i)->get_turnout_id());
- return 0;
+ unsigned result = next_turnout_id;
+ while(used_ids.count(result))
+ ++result;
+ next_turnout_id = result+1;
+
+ return result;
}
void Layout::add_block(Block &b)
used_tracks.insert(btracks.begin(), btracks.end());
}
+ const set<Track *> &tracks = objects.get<Track>();
for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
if(used_tracks.count(*i)==0)
{
signal_train_removed.emit(t);
}
-void Layout::add_vehicle(Vehicle &v)
-{
- if(vehicles.insert(&v).second)
- signal_vehicle_added.emit(v);
-}
-
-void Layout::remove_vehicle(Vehicle &v)
-{
- if(vehicles.erase(&v))
- signal_vehicle_removed.emit(v);
-}
-
void Layout::add_sensor(Sensor &s)
{
if(sensors.insert(&s).second)
for(set<Sensor *>::iterator i=sensors.begin(); i!=sensors.end(); ++i)
(*i)->tick(dt);
+ const set<Signal *> &signals = objects.get<Signal>();
for(set<Signal *>::iterator i=signals.begin(); i!=signals.end(); ++i)
(*i)->tick(dt);
for(map<unsigned, Train *>::iterator i=trains.begin(); i!=trains.end(); ++i)
if(!base.empty())
writer.write((DataFile::Statement("base"), base));
+ const set<Track *> &tracks = objects.get<Track>();
for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
{
DataFile::Statement st("track");
writer.write(st);
}
+ const set<Signal *> &signals = objects.get<Signal>();
for(set<Signal *>::const_iterator i=signals.begin(); i!=signals.end(); ++i)
{
DataFile::Statement st("signal");
IO::BufferedFile out(fn, IO::M_WRITE);
DataFile::Writer writer(out);
+ const set<Track *> &tracks = objects.get<Track>();
for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
if(unsigned tid = (*i)->get_turnout_id())
writer.write((DataFile::Statement("turnout"), tid, (*i)->get_active_path()));
}
+template<typename B>
+Layout::Storage<B>::~Storage()
+{
+ while(!base.empty())
+ delete *base.begin();
+}
+
+template<typename B>
+bool Layout::Storage<B>::insert(B &b)
+{
+ bool result = base.insert(&b).second;
+ if(result)
+ caches.clear();
+ return result;
+}
+
+template<typename B>
+bool Layout::Storage<B>::erase(B &b)
+{
+ bool result = base.erase(&b);
+ if(result)
+ caches.clear();
+ return result;
+}
+
+template<typename B>
+template<typename T>
+const set<T *> &Layout::Storage<B>::get() const
+{
+ for(list<Variant>::const_iterator i=caches.begin(); i!=caches.end(); ++i)
+ if(i->check_type<set<T *> >())
+ return i->value<set<T *> >();
+
+ caches.push_back(set<T *>());
+ set<T *> &result = caches.back().value<set<T *> >();
+ for(typename set<B *>::const_iterator i=base.begin(); i!=base.end(); ++i)
+ if(T *t = dynamic_cast<T *>(*i))
+ result.insert(t);
+
+ return result;
+}
+
+template<typename B>
+template<typename T>
+void Layout::Storage<B>::del()
+{
+ set<T *> ts = get<T>();
+ for(typename set<T *>::iterator i=ts.begin(); i!=ts.end(); ++i)
+ if(base.count(*i))
+ delete *i;
+}
+
+
Layout::Loader::Loader(Layout &l):
DataFile::ObjectLoader<Layout>(l),
new_tracks(false)
Track *trk = new Track(obj, obj.catalogue.get_track(art_nr));
load_sub(*trk);
new_tracks = true;
- for(set<Track *>::iterator i=obj.tracks.begin(); i!=obj.tracks.end(); ++i)
+ const set<Track *> &tracks = obj.objects.get<Track>();
+ for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
if(*i!=trk)
trk->link_to(**i);
}
projects / r2c2.git / blobdiff