Merge remote-tracking branch 'origin/ptrs'HEADmain

4 files changed, 337 insertions, 55 deletions

diff --git a/test/test-assetFactory.cpp b/test/test-assetFactory.cpp
index 9bade82..68ce6a6 100644
--- a/test/test-assetFactory.cpp
+++ b/test/test-assetFactory.cpp
@@ -71,7 +71,7 @@ public:
 		sceneRenderer.render(*this);
 	}
 
-	Collection<const Renderable> objects;
+	SharedCollection<const Renderable> objects;
 
 private:
 	SceneRenderer sceneRenderer;
@@ -84,7 +84,7 @@ BOOST_AUTO_TEST_CASE(surfaces, *boost::unit_test::timeout(5))
 	BOOST_CHECK_EQUAL(4, mf->assets.size());
 	auto gravelAsset = mf->assets.at("terrain.surface.gravel");
 	BOOST_REQUIRE(gravelAsset);
-	auto gravel = std::dynamic_pointer_cast<Surface>(gravelAsset);
+	auto gravel = gravelAsset.dynamicCast<Surface>();
 	BOOST_REQUIRE(gravel);
 	BOOST_REQUIRE_EQUAL(gravel->name, "Gravel");
 	BOOST_REQUIRE_EQUAL(gravel->colorBias, RGB {.9F});
@@ -111,14 +111,14 @@ BOOST_AUTO_TEST_CASE(brush47xml, *boost::unit_test::timeout(5))
 	BOOST_CHECK_EQUAL(1, mf->assets.size());
 	auto brush47 = mf->assets.at("brush-47");
 	BOOST_REQUIRE(brush47);
-	auto brush47rvc = std::dynamic_pointer_cast<RailVehicleClass>(brush47);
+	auto brush47rvc = brush47.dynamicCast<RailVehicleClass>();
 	BOOST_REQUIRE(brush47rvc);
 	BOOST_REQUIRE(brush47rvc->bodyMesh);
 	BOOST_REQUIRE(brush47rvc->bogies.front());
 	BOOST_REQUIRE(brush47rvc->bogies.back());
 
 	auto railVehicle = std::make_shared<RailVehicle>(brush47rvc);
-	objects.objects.push_back(brush47rvc);
+	objects.emplace(brush47rvc);
 
 	render(10000);
 }
@@ -130,14 +130,14 @@ BOOST_AUTO_TEST_CASE(foliage, *boost::unit_test::timeout(5))
 	gameState.assets = mf->assets;
 	auto tree_01_1 = mf->assets.at("Tree-01-1");
 	BOOST_REQUIRE(tree_01_1);
-	auto tree_01_1_f = std::dynamic_pointer_cast<Foliage>(tree_01_1);
+	auto tree_01_1_f = tree_01_1.dynamicCast<Foliage>();
 	BOOST_REQUIRE(tree_01_1_f);
 
 	auto plant1 = std::make_shared<Plant>(tree_01_1_f, Location {{-2000, 2000, 0}, {0, 0, 0}});
 	auto plant2 = std::make_shared<Plant>(tree_01_1_f, Location {{3000, -4000, 0}, {0, 1, 0}});
 	auto plant3 = std::make_shared<Plant>(tree_01_1_f, Location {{-2000, -4000, 0}, {0, 2, 0}});
 	auto plant4 = std::make_shared<Plant>(tree_01_1_f, Location {{3000, 2000, 0}, {0, 3, 0}});
-	objects.objects.push_back(tree_01_1_f);
+	objects.emplace(tree_01_1_f);
 
 	render(6000);
 }
@@ -151,22 +151,22 @@ BOOST_AUTO_TEST_CASE(lights, *boost::unit_test::timeout(5))
 	BOOST_REQUIRE(rlight);
 	auto oldlamp = mf->assets.at("old-lamp");
 	BOOST_REQUIRE(oldlamp);
-	auto rlight_f = std::dynamic_pointer_cast<Illuminator>(rlight);
+	auto rlight_f = rlight.dynamicCast<Illuminator>();
 	BOOST_REQUIRE(rlight_f);
-	auto oldlamp_f = std::dynamic_pointer_cast<Illuminator>(oldlamp);
+	auto oldlamp_f = oldlamp.dynamicCast<Illuminator>();
 	BOOST_REQUIRE(oldlamp_f);
 
 	auto light1 = std::make_shared<Light>(oldlamp_f, Location {{0, 0, 0}, {0, 0, 0}});
 	auto light2 = std::make_shared<Light>(rlight_f, Location {{-4000, 0, 0}, {0, 2, 0}});
 	auto light3 = std::make_shared<Light>(rlight_f, Location {{-4000, -4000, 0}, {0, 1, 0}});
 	auto light4 = std::make_shared<Light>(oldlamp_f, Location {{3000, 4600, 0}, {0, 2, 0}});
-	objects.objects.push_back(rlight_f);
-	objects.objects.push_back(oldlamp_f);
+	objects.emplace(rlight_f);
+	objects.emplace(oldlamp_f);
 
 	// yes I'm hacking some floor to light up as though its a bush
-	auto floorf = std::dynamic_pointer_cast<Foliage>(mf->assets.at("floor"));
+	auto floorf = mf->assets.at("floor").dynamicCast<Foliage>();
 	auto floor = std::make_shared<Plant>(floorf, Location {});
-	objects.objects.push_back(floorf);
+	objects.emplace(floorf);
 
 	render(6000);
 }
diff --git a/test/test-collection.cpp b/test/test-collection.cpp
index 00204fc..620d3ab 100644
--- a/test/test-collection.cpp
+++ b/test/test-collection.cpp
@@ -21,6 +21,12 @@ public:
 		return false;
 	}
 
+	[[nodiscard]] virtual bool
+	yes() const
+	{
+		return true;
+	}
+
 	unsigned int total {0};
 };
 
@@ -34,27 +40,63 @@ public:
 	}
 };
 
-using TestCollection = Collection<Base>;
+class Sub1 : public Sub { };
+
+class Sub2 : public Sub { };
+
+class Base2 {
+public:
+	virtual ~Base2() = default;
+};
+
+class Multi : public Sub1, public Base2 { };
+
+using TestCollection = SharedCollection<Base, Sub>;
 
-BOOST_TEST_DONT_PRINT_LOG_VALUE(Collection<Base>::Objects::const_iterator)
-BOOST_TEST_DONT_PRINT_LOG_VALUE(Collection<Base>::Objects::const_reverse_iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestCollection::Objects::iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestCollection::Objects::const_iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestCollection::Objects::const_reverse_iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestCollection::OtherObjects<Sub>::iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestCollection::OtherObjects<Sub>::const_iterator)
 
 BOOST_FIXTURE_TEST_SUITE(tc, TestCollection)
 
 BOOST_AUTO_TEST_CASE(empty)
 {
+	BOOST_CHECK(TestCollection::empty());
 	BOOST_REQUIRE(!apply(&Base::add));
 	const auto i = applyOne(&Base::add);
 	BOOST_CHECK_EQUAL(i, end());
+	BOOST_CHECK(!find<Base>());
+	BOOST_CHECK(!find<Sub>());
+	BOOST_CHECK(!find<Sub1>());
 }
 
 BOOST_AUTO_TEST_CASE(a_base)
 {
 	auto b = create<Base>();
+	BOOST_CHECK_EQUAL(objects.size(), 1);
+	BOOST_CHECK(std::get<OtherObjects<Sub>>(otherObjects).empty());
 	BOOST_REQUIRE(apply(&Base::add));
 	BOOST_CHECK_EQUAL(b->total, 1);
 	const auto i = applyOne(&Base::add);
 	BOOST_CHECK_EQUAL(i, end());
+	BOOST_CHECK_EQUAL(b.get(), find<Base>());
+	BOOST_CHECK(!find<Sub>());
+	BOOST_CHECK(!find<Sub1>());
+}
+
+BOOST_AUTO_TEST_CASE(emplace_others)
+{
+	auto b = emplace(std::make_shared<Base>());
+	BOOST_CHECK_EQUAL(objects.size(), 1);
+	BOOST_CHECK(std::get<OtherObjects<Sub>>(otherObjects).empty());
+	auto s = emplace(std::make_shared<Sub>());
+	BOOST_CHECK_EQUAL(objects.size(), 2);
+	BOOST_CHECK_EQUAL(std::get<OtherObjects<Sub>>(otherObjects).size(), 1);
+	BOOST_CHECK_EQUAL(b.get(), find<Base>());
+	BOOST_CHECK_EQUAL(s.get(), find<Sub>());
+	BOOST_CHECK(!find<Sub1>());
 }
 
 BOOST_AUTO_TEST_CASE(a_rbase)
@@ -69,6 +111,8 @@ BOOST_AUTO_TEST_CASE(a_rbase)
 BOOST_AUTO_TEST_CASE(a_sub)
 {
 	auto s = create<Sub>();
+	BOOST_CHECK_EQUAL(objects.size(), 1);
+	BOOST_CHECK_EQUAL(std::get<OtherObjects<Sub>>(otherObjects).size(), 1);
 	BOOST_REQUIRE(apply(&Base::add));
 	BOOST_CHECK_EQUAL(s->total, 2);
 	const auto i = applyOne(&Base::add);
@@ -76,6 +120,243 @@ BOOST_AUTO_TEST_CASE(a_sub)
 	BOOST_CHECK_EQUAL(*i, s);
 }
 
+BOOST_AUTO_TEST_CASE(filter)
+{
+	static_assert(TestCollection::idx<Sub>() == 0);
+	static_assert(TestCollection::idx<const Sub>() == 0);
+	static_assert(TestCollection::idx<Sub1>() == 0);
+	static_assert(TestCollection::idx<const Sub1>() == 0);
+	create<Base>();
+	BOOST_CHECK_EQUAL(1, apply<Base>(&Base::yes));
+	BOOST_CHECK_EQUAL(0, apply<Sub>(&Base::yes));
+	BOOST_CHECK_EQUAL(0, apply<Sub1>(&Base::yes));
+	BOOST_CHECK_EQUAL(objects.begin(), applyOne<Base>(&Base::yes));
+	BOOST_CHECK_EQUAL(std::get<0>(otherObjects).end(), applyOne<Sub>(&Base::yes));
+	BOOST_CHECK_EQUAL(std::get<0>(otherObjects).end(), applyOne<Sub1>(&Base::yes));
+	create<Sub>();
+	BOOST_CHECK_EQUAL(2, apply<Base>(&Base::yes));
+	BOOST_CHECK_EQUAL(1, apply<Sub>(&Base::yes));
+	BOOST_CHECK_EQUAL(0, apply<Sub1>(&Base::yes));
+	BOOST_CHECK_EQUAL(objects.begin(), applyOne<Base>(&Base::yes));
+	BOOST_CHECK_EQUAL(std::get<0>(otherObjects).begin(), applyOne<Sub>(&Base::yes));
+	BOOST_CHECK_EQUAL(std::get<0>(otherObjects).end(), applyOne<Sub1>(&Base::yes));
+	create<Sub1>();
+	BOOST_CHECK_EQUAL(3, apply<Base>(&Base::yes));
+	BOOST_CHECK_EQUAL(2, apply<Sub>(&Base::yes));
+	BOOST_CHECK_EQUAL(1, apply<Sub1>(&Base::yes));
+	BOOST_CHECK_EQUAL(objects.begin(), applyOne<Base>(&Base::yes));
+	BOOST_CHECK_EQUAL(std::get<0>(otherObjects).begin(), applyOne<Sub>(&Base::yes));
+	BOOST_CHECK_EQUAL(std::get<0>(otherObjects).begin() + 1, applyOne<Sub1>(&Base::yes));
+
+	BOOST_CHECK_EQUAL(std::get<idx<Sub>()>(otherObjects).size(), 2);
+	BOOST_CHECK_EQUAL(std::get<idx<Sub1>()>(otherObjects).size(), 2);
+
+	BOOST_CHECK_EQUAL(&objects, &containerFor<Base>());
+	BOOST_CHECK_EQUAL(&std::get<0>(otherObjects), &containerFor<Sub>());
+	BOOST_CHECK_EQUAL(&std::get<0>(otherObjects), &containerFor<Sub1>());
+}
+
+BOOST_AUTO_TEST_CASE(begin_end)
+{
+	BOOST_CHECK_EQUAL(0, std::distance(begin(), end()));
+	create<Sub>();
+	create<Base>();
+	BOOST_CHECK_EQUAL(2, std::distance(begin(), end()));
+}
+
+BOOST_AUTO_TEST_CASE(rbegin_rend)
+{
+	BOOST_CHECK_EQUAL(0, std::distance(rbegin(), rend()));
+	create<Sub>();
+	create<Base>();
+	BOOST_CHECK_EQUAL(2, std::distance(rbegin(), rend()));
+}
+
+BOOST_AUTO_TEST_CASE(createCreate)
+{
+	auto b = findOrCreate<Base>();
+	BOOST_CHECK(b);
+	auto b2 = findOrCreate<Base>();
+	BOOST_CHECK_EQUAL(b, b2);
+	auto s = findOrCreate<Sub>();
+	BOOST_CHECK_NE(s, b);
+	auto s2 = findOrCreate<Sub>();
+	BOOST_CHECK_EQUAL(s, s2);
+}
+
+BOOST_AUTO_TEST_CASE(createCreateSub)
+{
+	auto s = findOrCreate<Sub>();
+	auto b = findOrCreate<Base>();
+	BOOST_CHECK_EQUAL(s, b);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+using TestUniqueCollection = UniqueCollection<Base, Sub>;
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestUniqueCollection::Objects::const_iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestUniqueCollection::Objects::const_reverse_iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestUniqueCollection::Objects::iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestUniqueCollection::Objects::reverse_iterator)
+
+BOOST_FIXTURE_TEST_SUITE(utc, TestUniqueCollection)
+
+BOOST_AUTO_TEST_CASE(unique_create)
+{
+	create<Base>();
+	BOOST_CHECK_EQUAL(objects.size(), 1);
+	BOOST_CHECK(std::get<OtherObjects<Sub>>(otherObjects).empty());
+	create<Sub>();
+	BOOST_CHECK_EQUAL(objects.size(), 2);
+	BOOST_CHECK_EQUAL(std::get<OtherObjects<Sub>>(otherObjects).size(), 1);
+}
+
+BOOST_AUTO_TEST_CASE(move_assign)
+{
+	create<Base>();
+	create<Sub>();
+
+	TestUniqueCollection::Objects other;
+	TestUniqueCollection::operator=(std::move(other));
+	BOOST_CHECK(objects.empty());
+	BOOST_CHECK(std::get<OtherObjects<Sub>>(otherObjects).empty());
+
+	other.push_back(std::make_unique<Sub>());
+	other.push_back(std::make_unique<Base>());
+	TestUniqueCollection::operator=(std::move(other));
+	BOOST_CHECK_EQUAL(objects.size(), 2);
+	BOOST_CHECK_EQUAL(std::get<OtherObjects<Sub>>(otherObjects).size(), 1);
+	BOOST_CHECK(other.empty());
+}
+
+BOOST_AUTO_TEST_CASE(clearAll)
+{
+	create<Base>();
+	create<Sub>();
+	emplace(std::make_unique<Base>());
+	emplace(std::make_unique<Sub>());
+
+	clear();
+	BOOST_CHECK(objects.empty());
+	BOOST_CHECK(std::get<OtherObjects<Sub>>(otherObjects).empty());
+}
+
+BOOST_AUTO_TEST_CASE(removeAllOfSub)
+{
+	create<Base>();
+	create<Sub>();
+	emplace(std::make_unique<Base>());
+	emplace(std::make_unique<Sub>());
+	emplace(std::make_unique<Sub1>());
+
+	BOOST_CHECK_EQUAL(removeAll<Sub>(), 3);
+	BOOST_CHECK_EQUAL(objects.size(), 2);
+	BOOST_CHECK(std::get<OtherObjects<Sub>>(otherObjects).empty());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_FIXTURE_TEST_SUITE(btc, UniqueCollection<Base>)
+
+BOOST_AUTO_TEST_CASE(no_others)
+{
+	create<Base>();
+	create<Sub>();
+	emplace(std::make_unique<Base>());
+	emplace(std::make_unique<Sub>());
+}
+
+BOOST_AUTO_TEST_CASE(applyAll)
+{
+	create<Base>();
+	BOOST_CHECK_EQUAL(0, apply<Sub>(&Base::add));
+	BOOST_CHECK_EQUAL(1, apply<Base>(&Base::add));
+	create<Sub>();
+	BOOST_CHECK_EQUAL(1, apply<Sub>(&Base::add));
+	BOOST_CHECK_EQUAL(2, apply<Base>(&Base::add));
+}
+
+BOOST_AUTO_TEST_CASE(applyOneType)
+{
+	create<Base>();
+	BOOST_CHECK_EQUAL(objects.end(), applyOne<Sub>(&Base::yes));
+	BOOST_CHECK_EQUAL(objects.begin(), applyOne<Base>(&Base::yes));
+	create<Sub>();
+	BOOST_CHECK_EQUAL(objects.begin() + 1, applyOne<Sub>(&Base::yes));
+	BOOST_CHECK_EQUAL(objects.begin(), applyOne<Base>(&Base::yes));
+	create<Sub1>();
+	BOOST_CHECK_EQUAL(objects.begin() + 2, applyOne<Sub1>(&Base::yes));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+using MultiCollection = Collection<std::unique_ptr<Base>, Multi, Sub, Base2>;
+
+BOOST_FIXTURE_TEST_SUITE(multi, MultiCollection)
+
+BOOST_AUTO_TEST_CASE(addMulti)
+{
+	static_assert(MultiCollection::idx<Multi>() == 0);
+	static_assert(MultiCollection::idx<Sub>() == 1);
+	static_assert(MultiCollection::idx<Base2>() == 2);
+	create<Base>();
+	BOOST_CHECK_EQUAL(objects.size(), 1);
+	BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 0);
+	BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 0);
+	BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 0);
+	create<Sub>();
+	BOOST_CHECK_EQUAL(objects.size(), 2);
+	BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 0);
+	BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 1);
+	BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 0);
+	create<Sub1>();
+	BOOST_CHECK_EQUAL(objects.size(), 3);
+	BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 0);
+	BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 2);
+	BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 0);
+	create<Sub2>();
+	BOOST_CHECK_EQUAL(objects.size(), 4);
+	BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 0);
+	BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 3);
+	BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 0);
+	create<Multi>();
+	BOOST_CHECK_EQUAL(size(), 5);
+	BOOST_CHECK_EQUAL(size<Multi>(), 1);
+	BOOST_CHECK_EQUAL(size<Sub>(), 4);
+	BOOST_CHECK_EQUAL(size<Base2>(), 1);
+}
+
+BOOST_AUTO_TEST_CASE(removeMulti)
+{
+	create<Base>();
+	create<Sub>();
+	create<Sub1>();
+	create<Sub2>();
+	create<Multi>();
+	BOOST_CHECK_EQUAL(objects.size(), 5);
+	BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 1);
+	BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 4);
+	BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 1);
+
+	BOOST_CHECK_EQUAL(removeAll<Multi>(), 1);
+	BOOST_CHECK_EQUAL(objects.size(), 4);
+	BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 0);
+	BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 3);
+	BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 0);
+
+	BOOST_CHECK_EQUAL(removeAll<Sub>(), 3);
+	BOOST_CHECK_EQUAL(objects.size(), 1);
+	BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 0);
+	BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 0);
+	BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 0);
+
+	BOOST_CHECK_EQUAL(removeAll<Base>(), 1);
+	BOOST_CHECK_EQUAL(objects.size(), 0);
+	BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 0);
+	BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 0);
+	BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 0);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 BOOST_AUTO_TEST_CASE(wrapped_ptr_file_cons)
diff --git a/test/test-network.cpp b/test/test-network.cpp
index 51fea8b..19a740e 100644
--- a/test/test-network.cpp
+++ b/test/test-network.cpp
@@ -139,83 +139,83 @@ BOOST_DATA_TEST_CASE(newNodeAt_new, INVALID_NODES, p)
 BOOST_AUTO_TEST_CASE(network_joins)
 {
 	// Ends
-	BOOST_CHECK(links.objects[2]->ends[1].nexts.empty());
+	BOOST_CHECK(links[2]->ends[1].nexts.empty());
 	// Join 0 <-> 1
-	BOOST_REQUIRE_EQUAL(links.objects[0]->ends[1].nexts.size(), 2);
-	BOOST_CHECK_EQUAL(links.objects[0]->ends[1].nexts[0].first.lock().get(), links.objects[1].get());
-	BOOST_CHECK_EQUAL(links.objects[0]->ends[1].nexts[0].second, 0);
-	BOOST_CHECK_EQUAL(links.objects[0]->ends[1].nexts[1].first.lock().get(), links.objects[5].get());
-	BOOST_CHECK_EQUAL(links.objects[0]->ends[1].nexts[1].second, 0);
-	BOOST_REQUIRE_EQUAL(links.objects[1]->ends[0].nexts.size(), 2);
-	BOOST_CHECK_EQUAL(links.objects[1]->ends[0].nexts[0].first.lock().get(), links.objects[0].get());
-	BOOST_CHECK_EQUAL(links.objects[1]->ends[0].nexts[0].second, 1);
-	BOOST_CHECK_EQUAL(links.objects[1]->ends[0].nexts[1].first.lock().get(), links.objects[5].get());
-	BOOST_CHECK_EQUAL(links.objects[1]->ends[0].nexts[1].second, 0);
+	BOOST_REQUIRE_EQUAL(links[0]->ends[1].nexts.size(), 2);
+	BOOST_CHECK_EQUAL(links[0]->ends[1].nexts[0].first.lock().get(), links[1].get());
+	BOOST_CHECK_EQUAL(links[0]->ends[1].nexts[0].second, 0);
+	BOOST_CHECK_EQUAL(links[0]->ends[1].nexts[1].first.lock().get(), links[5].get());
+	BOOST_CHECK_EQUAL(links[0]->ends[1].nexts[1].second, 0);
+	BOOST_REQUIRE_EQUAL(links[1]->ends[0].nexts.size(), 2);
+	BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[0].first.lock().get(), links[0].get());
+	BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[0].second, 1);
+	BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[1].first.lock().get(), links[5].get());
+	BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[1].second, 0);
 	// Join 1 <-> 2
-	BOOST_REQUIRE_EQUAL(links.objects[1]->ends[1].nexts.size(), 2);
-	BOOST_CHECK_EQUAL(links.objects[1]->ends[1].nexts[0].first.lock().get(), links.objects[2].get());
-	BOOST_CHECK_EQUAL(links.objects[1]->ends[1].nexts[0].second, 0);
-	BOOST_REQUIRE_EQUAL(links.objects[2]->ends[0].nexts.size(), 2);
-	BOOST_CHECK_EQUAL(links.objects[2]->ends[0].nexts[0].first.lock().get(), links.objects[1].get());
-	BOOST_CHECK_EQUAL(links.objects[2]->ends[0].nexts[0].second, 1);
+	BOOST_REQUIRE_EQUAL(links[1]->ends[1].nexts.size(), 2);
+	BOOST_CHECK_EQUAL(links[1]->ends[1].nexts[0].first.lock().get(), links[2].get());
+	BOOST_CHECK_EQUAL(links[1]->ends[1].nexts[0].second, 0);
+	BOOST_REQUIRE_EQUAL(links[2]->ends[0].nexts.size(), 2);
+	BOOST_CHECK_EQUAL(links[2]->ends[0].nexts[0].first.lock().get(), links[1].get());
+	BOOST_CHECK_EQUAL(links[2]->ends[0].nexts[0].second, 1);
 }
 
 BOOST_DATA_TEST_CASE(routeTo_nodeNotInNetwork, INVALID_NODES, dest)
 {
-	const auto & start = links.objects.front()->ends[1];
+	const auto & start = links[0]->ends[1];
 	BOOST_CHECK_THROW((void)routeFromTo(start, dest), std::out_of_range);
 }
 
 BOOST_AUTO_TEST_CASE(routeTo_noSteps)
 {
-	const auto & start = links.objects.front()->ends[1];
+	const auto & start = links[0]->ends[1];
 	auto r = this->routeFromTo(start, p100);
 	BOOST_CHECK(r.empty());
 }
 
 BOOST_AUTO_TEST_CASE(routeTo_upStream_to2)
 {
-	const auto & start = links.objects.front()->ends[1];
+	const auto & start = links[0]->ends[1];
 	auto r = this->routeFromTo(start, p200);
 	BOOST_REQUIRE_EQUAL(r.size(), 1);
-	BOOST_CHECK_EQUAL(r[0].first.lock().get(), links.objects[1].get());
+	BOOST_CHECK_EQUAL(r[0].first.lock().get(), links[1].get());
 }
 
 BOOST_AUTO_TEST_CASE(routeTo_upStream_to3)
 {
-	const auto & start = links.objects[0]->ends[1];
+	const auto & start = links[0]->ends[1];
 	auto r = this->routeFromTo(start, p300);
 	BOOST_REQUIRE_EQUAL(r.size(), 2);
-	BOOST_CHECK_EQUAL(r[0].first.lock().get(), links.objects[1].get());
-	BOOST_CHECK_EQUAL(r[1].first.lock().get(), links.objects[2].get());
+	BOOST_CHECK_EQUAL(r[0].first.lock().get(), links[1].get());
+	BOOST_CHECK_EQUAL(r[1].first.lock().get(), links[2].get());
 }
 
 BOOST_AUTO_TEST_CASE(routeTo_downStream_to0)
 {
-	const auto & start = links.objects[2]->ends[0];
+	const auto & start = links[2]->ends[0];
 	auto r = this->routeFromTo(start, p000);
 	BOOST_REQUIRE_EQUAL(r.size(), 2);
-	BOOST_CHECK_EQUAL(r[0].first.lock().get(), links.objects[1].get());
-	BOOST_CHECK_EQUAL(r[1].first.lock().get(), links.objects[0].get());
+	BOOST_CHECK_EQUAL(r[0].first.lock().get(), links[1].get());
+	BOOST_CHECK_EQUAL(r[1].first.lock().get(), links[0].get());
 }
 
 BOOST_AUTO_TEST_CASE(routeTo_upStream_3to300)
 {
-	const auto & start = links.objects[3]->ends[1];
+	const auto & start = links[3]->ends[1];
 	auto r = this->routeFromTo(start, p300);
 	BOOST_REQUIRE_EQUAL(r.size(), 2);
-	BOOST_CHECK_EQUAL(r[0].first.lock().get(), links.objects[4].get());
-	BOOST_CHECK_EQUAL(r[1].first.lock().get(), links.objects[2].get());
+	BOOST_CHECK_EQUAL(r[0].first.lock().get(), links[4].get());
+	BOOST_CHECK_EQUAL(r[1].first.lock().get(), links[2].get());
 }
 
 BOOST_AUTO_TEST_CASE(routeTo_downStream_3to300)
 {
-	const auto & start = links.objects[3]->ends[0];
+	const auto & start = links[3]->ends[0];
 	auto r = this->routeFromTo(start, p300);
 	BOOST_REQUIRE_EQUAL(r.size(), 3);
-	BOOST_CHECK_EQUAL(r[0].first.lock().get(), links.objects[0].get());
-	BOOST_CHECK_EQUAL(r[1].first.lock().get(), links.objects[1].get());
-	BOOST_CHECK_EQUAL(r[2].first.lock().get(), links.objects[2].get());
+	BOOST_CHECK_EQUAL(r[0].first.lock().get(), links[0].get());
+	BOOST_CHECK_EQUAL(r[1].first.lock().get(), links[1].get());
+	BOOST_CHECK_EQUAL(r[2].first.lock().get(), links[2].get());
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/test-render.cpp b/test/test-render.cpp
index 8390d25..a6e28bc 100644
--- a/test/test-render.cpp
+++ b/test/test-render.cpp
@@ -41,7 +41,7 @@ public:
 		terrain->point(GeoData::VertexHandle {517}).z = 100'000;
 		terrain->generateMeshes();
 		gameState->assets = AssetFactory::loadAll(RESDIR);
-		brush47rvc = std::dynamic_pointer_cast<RailVehicleClass>(gameState->assets.at("brush-47"));
+		brush47rvc = gameState->assets.at("brush-47").dynamicCast<RailVehicleClass>();
 		std::random_device randomdev {};
 		std::uniform_real_distribution<Angle> rotationDistribution {0, two_pi};
 		std::uniform_int_distribution<GlobalDistance> positionOffsetDistribution {-1500, +1500};
@@ -57,9 +57,10 @@ public:
 		train2->bogies.back().setPosition(train2->bogies.back().position() + train2->location.position());
 		for (auto x = 40000; x < 100000; x += 5000) {
 			for (auto y = 65000; y < 125000; y += 5000) {
-				gameState->world.create<Plant>(
-						std::dynamic_pointer_cast<Foliage>(gameState->assets.at(std::format(
-								"Tree-{:#02}-{}", treeDistribution(randomdev), treeVariantDistribution(randomdev)))),
+				gameState->world.create<Plant>(gameState->assets
+													   .at(std::format("Tree-{:#02}-{}", treeDistribution(randomdev),
+															   treeVariantDistribution(randomdev)))
+													   .dynamicCast<Foliage>(),
 						Location {{x + positionOffsetDistribution(randomdev), y + positionOffsetDistribution(randomdev),
 										  1},
 								{0, rotationDistribution(randomdev), 0}});
@@ -76,7 +77,7 @@ public:
 		water.render(shader, frustum);
 		rail.render(shader, frustum);
 		std::ranges::for_each(gameState->assets, [&shader, &frustum](const auto & asset) {
-			if (const auto renderable = std::dynamic_pointer_cast<const Renderable>(asset.second)) {
+			if (const auto renderable = asset.second.template getAs<const Renderable>()) {
 				renderable->render(shader, frustum);
 			}
 		});
@@ -98,7 +99,7 @@ public:
 	{
 		terrain->shadows(shadowMapper, frustum);
 		std::ranges::for_each(gameState->assets, [&shadowMapper, &frustum](const auto & asset) {
-			if (const auto renderable = std::dynamic_pointer_cast<const Renderable>(asset.second)) {
+			if (const auto renderable = asset.second.template getAs<const Renderable>()) {
 				renderable->shadows(shadowMapper, frustum);
 			}
 		});