Как создать динамический компоновщик?

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <stdexcept>
 
/**
 * Пример реализации репозитория связи многие-ко-многим, на основе которых можно построить связи один-ко-многим.
 * Можно лучше сделать, это пример.
 */
template<typename T>
struct ManyToManyRepository {
 
    ManyToManyRepository() {}
 
    // добавляет связь
    void add(const T &from, const T &to) {
        fromTo.insert({from, to});
        toFrom.insert({to, from});
    }
 
    // находит объекты, связанные с параметром
    std::vector<T> findFrom(const T &from) {
        auto items = fromTo.equal_range(from);
        std::vector<T> result;
        std::transform(items.first, items.second, std::back_inserter(result), [](auto &pair) { return pair.second; });
        return result;
    }
 
    // находит объекты, с которыми параметр связан
    std::vector<T> findTo(const T &to) {
        auto items = toFrom.equal_range(to);
        std::vector<T> result;
        std::transform(items.first, items.second, std::back_inserter(result), [](auto &pair) { return pair.second; });
        return result;
    }
 
    std::multimap<T, T> fromTo;
    std::multimap<T, T> toFrom;
 
};
 
// хранилище для объектов с айдишниками
// генератор айдишников позволит иметь айдишники, уникальные сквозь все записи, например.
template<typename Id, typename T, typename IdGenerator>
class Repository {
public:
    Repository(IdGenerator &idGenerator) : idGenerator(idGenerator) {}
 
    const T save(const T &t) {
        T saved = t;
        if (saved.id == 0) {
            saved.id = idGenerator();
        }
        data[saved.id] = saved;
        return saved;
    }
 
    T findById(const Id &id) {
        auto result = data.find(id);
        if (result == data.end()) {
            throw std::invalid_argument("No object with passed id found.");
        }
        return result->second;
    }
 
    std::vector<T> findAll() {
        std::vector<T> result;
        std::transform(data.begin(), data.end(), std::back_inserter(result), [](const auto &e) { return e.second; });
        return result;
    }
 
private:
    IdGenerator &idGenerator;
    std::map<Id, T> data;
};
 
std::size_t idGenerator() {
    static std::size_t lastId = 0;
    return ++lastId;
}
 
 
struct Army {
    std::size_t id;
    std::string name;
};
 
struct Corps {
    std::size_t id;
    std::string name;
};
 
struct Division {
    std::size_t id;
    std::string name;
};
 
std::ostream &operator<<(std::ostream &out, const Army &value) {
    return out << "Army{id=" << value.id << ", name='" << value.name << "'}";
}
 
std::ostream &operator<<(std::ostream &out, const Corps &value) {
    return out << "Corps{id=" << value.id << ", name='" << value.name << "'}";
}
 
std::ostream &operator<<(std::ostream &out, const Division &value) {
    return out << "Division{id=" << value.id << ", name='" << value.name << "'}";
}
 
int main() {
 
 
    Repository<std::size_t, Army, typeof idGenerator> armies(idGenerator);
    Repository<std::size_t, Corps, typeof idGenerator> corpses(idGenerator);
    Repository<std::size_t, Division, typeof idGenerator> divisions(idGenerator);
 
    // в идеале иметь такой репозиторий для каждой пары,
    // но если нужно иметь гибкость, например, в армии есть и корпус и дивизия,
    // то можно и один на всех. Тогда айдишники должны быть насквозь уникальные.
    ManyToManyRepository<std::size_t> links;
 
    // создание армии
    // собственно это можно откуда-то считать
    std::string firstArmyName = "First Army";
 
    auto armyOne = armies.save({0, firstArmyName}); // создаём армию, присваивая айди
    std::cout << "Army created: " << armyOne << std::endl; // оглашаем айди
 
 
    // создание корпуса
    std::string corpsName = "First army First corps"; // можно считать
    std::size_t armyId = armyOne.id; // тоже можно прочитать где-то, не забудьте проверить, что это валидный айди
 
    // сохраняем корпус в репозиторий
    auto corpsOneArmyOne = corpses.save({0, corpsName});
    std::cout << "Corps created: " << corpsOneArmyOne << std::endl;
 
    // линкуем корпус и армию
    links.add(armyId, corpsOneArmyOne.id);
    std::cout << "Corps " << corpsOneArmyOne << " was linked to " << armyOne << std::endl;
 
    // создание дивизии, в общем-то тоже самое, что и корпуса, разве что для линковки нужен айди уже дивизии
    // опять же, эти данные можно считать с консоли
    std::string divisionName = "First army, First corps, First Division";
    std::size_t corpsId = corpsOneArmyOne.id;
 
    // создаем
    auto divisionOneCorpsOne = divisions.save({0, divisionName});
    std::cout << "Division created: " << divisionOneCorpsOne << std::endl;
    // линкуем
    links.add(corpsId, divisionOneCorpsOne.id);
    std::cout << "Division " << divisionOneCorpsOne << " was linked to " << corpsOneArmyOne << std::endl;
 
 
    // просто подобавляю разных объектов для большего вывода
    auto corpsTwo = corpses.save({0, "First Army, Second Corps"});
    links.add(armyOne.id, corpsTwo.id);
    links.add(corpsTwo.id, divisions.save({0, "First Army, Second Corps, First Division"}).id);
    links.add(corpsOneArmyOne.id, divisions.save({0, "First Army, First Corps, Second Division"}).id);
    links.add(corpsOneArmyOne.id, divisions.save({0, "First Army, First Corps, Third Division"}).id);
 
    std::cout << "MILITARY:" << std::endl;
 
    // ну и полный обход получившейся структуры:
    auto allArmies = armies.findAll();
    for (const auto &army : allArmies) {
        std::cout << army << std::endl;
        auto armyCorpseIds = links.findFrom(army.id);
        for (auto &corpsId : armyCorpseIds) {
            auto corps = corpses.findById(corpsId);
            std::cout << "-- " << corps << std::endl;
            auto divisionIds = links.findFrom(corps.id);
            for (auto &divisionId : divisionIds) {
                auto division = divisions.findById(divisionId);
                std::cout << "---- " << division << std::endl;
            }
        }
    }
 
    return 0;
}