FGFS-4.1/simgear
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

SGSubsystem classes: Renaming of the subsystem ID variables and functions.

Browse Source
This commit is contained in:
Edward d'Auvergne 2018-05-04 14:16:42 +02:00
parent 10662e4ca5
commit d7323f5f19
5 changed files with 78 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
simgear/sound/soundmgr.hxx
View File

@ -60,7 +60,7 @@ public:
void update(double dt) override; void update(double dt) override;
// Subsystem identification. // Subsystem identification.
static const char* subsystemName() { return "sound"; } static const char* staticSubsystemClassId() { return "sound"; }
void stop(); void stop();

1
simgear/structure/event_mgr.cxx
View File

@ -47,7 +47,6 @@ SGEventMgr::SGEventMgr() :
_inited(false), _inited(false),
_shutdown(false) _shutdown(false)
{ {
_name = "EventMgr";
} }
SGEventMgr::~SGEventMgr() SGEventMgr::~SGEventMgr()

58
simgear/structure/subsystem_mgr.cxx
View File

@ -138,28 +138,28 @@ void SGSubsystem::stamp(const string& name)
void SGSubsystem::set_name(const std::string &n) void SGSubsystem::set_name(const std::string &n)
{ {
assert(_name.empty()); assert(_subsystemId.empty());
_name = n; _subsystemId = n;
} }
std::string SGSubsystem::typeName() const std::string SGSubsystem::subsystemClassId() const
{ {
auto pos = _name.find(SUBSYSTEM_NAME_SEPARATOR); auto pos = _subsystemId.find(SUBSYSTEM_NAME_SEPARATOR);
if (pos == std::string::npos) { if (pos == std::string::npos) {
return _name; return _subsystemId;
} }
return _name.substr(0, pos); return _subsystemId.substr(0, pos);
} }
std::string SGSubsystem::instanceName() const std::string SGSubsystem::subsystemInstanceId() const
{ {
auto pos = _name.find(SUBSYSTEM_NAME_SEPARATOR); auto pos = _subsystemId.find(SUBSYSTEM_NAME_SEPARATOR);
if (pos == std::string::npos) { if (pos == std::string::npos) {
return {}; return {};
} }
return _name.substr(pos+1); return _subsystemId.substr(pos+1);
} }
void SGSubsystem::set_group(SGSubsystemGroup* group) void SGSubsystem::set_group(SGSubsystemGroup* group)
@ -175,7 +175,7 @@ SGSubsystemGroup* SGSubsystem::get_group() const
SGSubsystemMgr* SGSubsystem::get_manager() const SGSubsystemMgr* SGSubsystem::get_manager() const
{ {
if (!get_group()) if (!get_group())
throw sg_exception("SGSubsystem::get_manager: subsystem " + name() + " has no group"); throw sg_exception("SGSubsystem::get_manager: subsystem " + subsystemId() + " has no group");
return get_group()->get_manager(); return get_group()->get_manager();
} }
@ -474,7 +474,7 @@ void SGSubsystem::reportTimingStats(TimerStats *__lastValues) {
if (reportDeltas) { if (reportDeltas) {
auto deltaT = _executionTime - _lastExecutionTime; auto deltaT = _executionTime - _lastExecutionTime;
if (deltaT != 0) { if (deltaT != 0) {
t << name() << "(+" << std::setprecision(2) << std::right << deltaT << "ms)."; t << subsystemInstanceId() << "(+" << std::setprecision(2) << std::right << deltaT << "ms).";
_name = t.str(); _name = t.str();
} }
} }
@ -506,7 +506,7 @@ void SGSubsystem::reportTimingStats(TimerStats *__lastValues) {
void SGSubsystemGroup::reportTimingStats(TimerStats *_lastValues) { void SGSubsystemGroup::reportTimingStats(TimerStats *_lastValues) {
SGSubsystem::reportTimingStats(_lastValues); SGSubsystem::reportTimingStats(_lastValues);
std::string _name = name(); std::string _name = subsystemInstanceId();
if (!_name.size()) if (!_name.size())
_name = typeid(this).name(); _name = typeid(this).name();
if (_lastValues) { if (_lastValues) {
@ -514,11 +514,11 @@ void SGSubsystemGroup::reportTimingStats(TimerStats *_lastValues) {
if (deltaT != 0) { if (deltaT != 0) {
SG_LOG(SG_EVENT, SG_ALERT, SG_LOG(SG_EVENT, SG_ALERT,
" +" << std::setw(6) << std::setprecision(4) << std::right << deltaT << "ms " " +" << std::setw(6) << std::setprecision(4) << std::right << deltaT << "ms "
<< name() ); << subsystemInstanceId() );
} }
} }
else else
SG_LOG(SG_EVENT, SG_ALERT, "SubSystemGroup: " << name() << " " << std::setw(6) << std::setprecision(4) << std::right << _executionTime / 1000.0 << "s"); SG_LOG(SG_EVENT, SG_ALERT, "SubSystemGroup: " << subsystemInstanceId() << " " << std::setw(6) << std::setprecision(4) << std::right << _executionTime / 1000.0 << "s");
for (auto member : _members) { for (auto member : _members) {
member->reportTimingStats(_lastValues); member->reportTimingStats(_lastValues);
} }
@ -575,11 +575,11 @@ SGSubsystemGroup::set_subsystem (const string &name, SGSubsystem * subsystem,
if (name.empty()) { if (name.empty()) {
SG_LOG(SG_GENERAL, SG_DEV_WARN, "adding subsystem to group without a name"); SG_LOG(SG_GENERAL, SG_DEV_WARN, "adding subsystem to group without a name");
// TODO, make this an exception in the future // TODO, make this an exception in the future
} else if (subsystem->name().empty()) { } else if (subsystem->subsystemId().empty()) {
subsystem->set_name(name); subsystem->set_name(name);
} else if (name != subsystem->name()) { } else if (name != subsystem->subsystemId()) {
SG_LOG(SG_GENERAL, SG_DEV_WARN, "adding subsystem to group with name '" << name SG_LOG(SG_GENERAL, SG_DEV_WARN, "adding subsystem to group with name '" << name
<< "', but name() returns '" << subsystem->name() << "'"); << "', but subsystemId() returns '" << subsystem->subsystemId() << "'");
} }
notifyWillChange(subsystem, State::ADD); notifyWillChange(subsystem, State::ADD);
@ -615,7 +615,7 @@ SGSubsystemGroup::set_subsystem (const string &name, SGSubsystem * subsystem,
void void
SGSubsystemGroup::set_subsystem (SGSubsystem * subsystem, double min_step_sec) SGSubsystemGroup::set_subsystem (SGSubsystem * subsystem, double min_step_sec)
{ {
set_subsystem(subsystem->name(), subsystem, min_step_sec); set_subsystem(subsystem->subsystemId(), subsystem, min_step_sec);
} }
SGSubsystem * SGSubsystem *
@ -1039,9 +1039,9 @@ SGSubsystemMgr::get_subsystem (const string &name) const
} }
SGSubsystem* SGSubsystem*
SGSubsystemMgr::get_subsystem(const std::string &name, const std::string& instanceName) const SGSubsystemMgr::get_subsystem(const std::string &name, const std::string& subsystemInstanceId) const
{ {
return get_subsystem(name + SUBSYSTEM_NAME_SEPARATOR + instanceName); return get_subsystem(name + SUBSYSTEM_NAME_SEPARATOR + subsystemInstanceId);
} }
@ -1174,7 +1174,7 @@ SGSubsystemMgr::create(const std::string& name)
} }
SGSubsystemRef SGSubsystemRef
SGSubsystemMgr::createInstance(const std::string& name, const std::string& instanceName) SGSubsystemMgr::createInstance(const std::string& name, const std::string& subsystemInstanceId)
{ {
auto it = findRegistration(name); auto it = findRegistration(name);
auto &global_registrations = getGlobalRegistrations(); auto &global_registrations = getGlobalRegistrations();
@ -1191,7 +1191,7 @@ SGSubsystemMgr::createInstance(const std::string& name, const std::string& insta
throw sg_exception("SGSubsystemMgr::create: functor failed to create an instsance of " + name); throw sg_exception("SGSubsystemMgr::create: functor failed to create an instsance of " + name);
} }
const auto combinedName = name + SUBSYSTEM_NAME_SEPARATOR + instanceName; const auto combinedName = name + SUBSYSTEM_NAME_SEPARATOR + subsystemInstanceId;
ref->set_name(combinedName); ref->set_name(combinedName);
return ref; return ref;
} }
@ -1276,7 +1276,7 @@ namespace {
// allow override of the name but defaultt o the subsystem name // allow override of the name but defaultt o the subsystem name
std::string name = arg->getStringValue("name"); std::string name = arg->getStringValue("name");
std::string instanceName = arg->getStringValue("instance"); std::string subsystemInstanceId = arg->getStringValue("instance");
if (name.empty()) { if (name.empty()) {
// default name to subsystem name, but before we parse any instance name // default name to subsystem name, but before we parse any instance name
@ -1285,19 +1285,19 @@ namespace {
auto separatorPos = subsystem.find(SUBSYSTEM_NAME_SEPARATOR); auto separatorPos = subsystem.find(SUBSYSTEM_NAME_SEPARATOR);
if (separatorPos != std::string::npos) { if (separatorPos != std::string::npos) {
if (!instanceName.empty()) { if (!subsystemInstanceId.empty()) {
SG_LOG(SG_GENERAL, SG_WARN, "Specified a composite subsystem name and an instance name, please do one or the other: " SG_LOG(SG_GENERAL, SG_WARN, "Specified a composite subsystem name and an instance name, please do one or the other: "
<< instanceName << " and " << subsystem); << subsystemInstanceId << " and " << subsystem);
return false; return false;
} }
instanceName = subsystem.substr(separatorPos + 1); subsystemInstanceId = subsystem.substr(separatorPos + 1);
subsystem = subsystem.substr(0, separatorPos); subsystem = subsystem.substr(0, separatorPos);
} }
SGSubsystem* sub = nullptr; SGSubsystem* sub = nullptr;
if (!instanceName.empty()) { if (!subsystemInstanceId.empty()) {
sub = manager->createInstance(subsystem, instanceName); sub = manager->createInstance(subsystem, subsystemInstanceId);
} else { } else {
sub = manager->create(subsystem); sub = manager->create(subsystem);
} }
@ -1313,7 +1313,7 @@ namespace {
double minTime = arg->getDoubleValue("min-time-sec", 0.0); double minTime = arg->getDoubleValue("min-time-sec", 0.0);
const auto combinedName = subsystem + SUBSYSTEM_NAME_SEPARATOR + instanceName; const auto combinedName = subsystem + SUBSYSTEM_NAME_SEPARATOR + subsystemInstanceId;
manager->add(combinedName.c_str(), manager->add(combinedName.c_str(),
sub, sub,
group, group,

47
simgear/structure/subsystem_mgr.hxx
View File

@ -282,19 +282,19 @@ public:
/** /**
* composite name for this subsystem (type name & optional instance name) * composite name for this subsystem (type name & optional instance name)
*/ */
std::string name() const std::string subsystemId() const
{ return _name; } { return _subsystemId; }
/** /**
* @brief the type (class)-specific part of the subsystem name. * @brief the type (class)-specific part of the subsystem name.
*/ */
std::string typeName() const; std::string subsystemClassId() const;
/** /**
* @brief the instance part of the subsystem name. Empty if this * @brief the instance part of the subsystem name. Empty if this
* subsystem is not instanced * subsystem is not instanced
*/ */
std::string instanceName() const; std::string subsystemInstanceId() const;
virtual bool is_group() const virtual bool is_group() const
{ return false; } { return false; }
@ -363,6 +363,11 @@ protected:
static int maxTimePerFrame_ms; static int maxTimePerFrame_ms;
private: private:
/// composite name for the subsystem (type name and instance name if this
/// is an instanced subsystem. (Since this member was originally defined as
/// protected, not private, we can't rename it easily)
std::string _subsystemId;
SGSubsystemGroup* _group = nullptr; SGSubsystemGroup* _group = nullptr;
protected: protected:
TimerStats _timerStats, _lastTimerStats; TimerStats _timerStats, _lastTimerStats;
@ -426,7 +431,7 @@ public:
template<class T> template<class T>
T* get_subsystem() T* get_subsystem()
{ {
return dynamic_cast<T*>(get_subsystem(T::subsystemName())); return dynamic_cast<T*>(get_subsystem(T::staticSubsystemClassId()));
} }
bool is_group() const override bool is_group() const override
@ -535,7 +540,7 @@ public:
SGSubsystem* get_subsystem(const std::string &name) const; SGSubsystem* get_subsystem(const std::string &name) const;
SGSubsystem* get_subsystem(const std::string &name, const std::string& instanceName) const; SGSubsystem* get_subsystem(const std::string &name, const std::string& subsystemInstanceId) const;
void reportTiming(); void reportTiming();
void setReportTimingCb(void* userData, SGSubsystemTimingCb cb) { reportTimingCb = cb; reportTimingUserData = userData; } void setReportTimingCb(void* userData, SGSubsystemTimingCb cb) { reportTimingCb = cb; reportTimingUserData = userData; }
@ -556,21 +561,21 @@ public:
template<class T> template<class T>
T* get_subsystem() const T* get_subsystem() const
{ {
return dynamic_cast<T*>(get_subsystem(T::subsystemName())); return dynamic_cast<T*>(get_subsystem(T::staticSubsystemClassId()));
} }
// instanced overloads, for both raw char* and std::string // instanced overloads, for both raw char* and std::string
// these concatenate the subsystem type name with the instance name // these concatenate the subsystem type name with the instance name
template<class T> template<class T>
T* get_subsystem(const char* instanceName) const T* get_subsystem(const char* subsystemInstanceId) const
{ {
return dynamic_cast<T*>(get_subsystem(T::subsystemName(), instanceName)); return dynamic_cast<T*>(get_subsystem(T::staticSubsystemClassId(), subsystemInstanceId));
} }
template<class T> template<class T>
T* get_subsystem(const std::string& instanceName) const T* get_subsystem(const std::string& subsystemInstanceId) const
{ {
return dynamic_cast<T*>(get_subsystem(T::subsystemName(), instanceName)); return dynamic_cast<T*>(get_subsystem(T::staticSubsystemClassId(), subsystemInstanceId));
} }
struct Dependency { struct Dependency {
@ -606,7 +611,7 @@ public:
std::initializer_list<Dependency> deps = {}) std::initializer_list<Dependency> deps = {})
{ {
SubsystemFactoryFunctor factory = [](){ return new T; }; SubsystemFactoryFunctor factory = [](){ return new T; };
SGSubsystemMgr::registerSubsystem(T::subsystemName(), SGSubsystemMgr::registerSubsystem(T::staticSubsystemClassId(),
factory, group, factory, group,
false, updateInterval, false, updateInterval,
deps); deps);
@ -624,7 +629,7 @@ public:
std::initializer_list<Dependency> deps = {}) std::initializer_list<Dependency> deps = {})
{ {
SubsystemFactoryFunctor factory = [](){ return new T; }; SubsystemFactoryFunctor factory = [](){ return new T; };
SGSubsystemMgr::registerSubsystem(T::subsystemName(), SGSubsystemMgr::registerSubsystem(T::staticSubsystemClassId(),
factory, group, factory, group,
true, updateInterval, true, updateInterval,
deps); deps);
@ -640,14 +645,14 @@ public:
template <class T> template <class T>
SGSharedPtr<T> add(GroupType customGroup = INVALID, double customInterval = 0.0) SGSharedPtr<T> add(GroupType customGroup = INVALID, double customInterval = 0.0)
{ {
auto ref = create(T::subsystemName()); auto ref = create(T::staticSubsystemClassId());
const GroupType group = (customGroup == INVALID) ? const GroupType group = (customGroup == INVALID) ?
defaultGroupFor(T::subsystemName()) : customGroup; defaultGroupFor(T::staticSubsystemClassId()) : customGroup;
const double interval = (customInterval == 0.0) ? const double interval = (customInterval == 0.0) ?
defaultUpdateIntervalFor(T::subsystemName()) : customInterval; defaultUpdateIntervalFor(T::staticSubsystemClassId()) : customInterval;
add(ref->name().c_str(), ref.ptr(), group, interval); add(ref->subsystemId().c_str(), ref.ptr(), group, interval);
return dynamic_cast<T*>(ref.ptr()); return dynamic_cast<T*>(ref.ptr());
} }
@ -658,20 +663,20 @@ public:
template <class T> template <class T>
SGSharedPtr<T> create() SGSharedPtr<T> create()
{ {
auto ref = create(T::subsystemName()); auto ref = create(T::staticSubsystemClassId());
return dynamic_cast<T*>(ref.ptr()); return dynamic_cast<T*>(ref.ptr());
} }
SGSubsystemRef create(const std::string& name); SGSubsystemRef create(const std::string& name);
template <class T> template <class T>
SGSharedPtr<T> createInstance(const std::string& instanceName) SGSharedPtr<T> createInstance(const std::string& subsystemInstanceId)
{ {
auto ref = createInstance(T::subsystemName(), instanceName); auto ref = createInstance(T::staticSubsystemClassId(), subsystemInstanceId);
return dynamic_cast<T*>(ref.ptr()); return dynamic_cast<T*>(ref.ptr());
} }
SGSubsystemRef createInstance(const std::string& name, const std::string& instanceName); SGSubsystemRef createInstance(const std::string& name, const std::string& subsystemInstanceId);
static GroupType defaultGroupFor(const char* name); static GroupType defaultGroupFor(const char* name);
static double defaultUpdateIntervalFor(const char* name); static double defaultUpdateIntervalFor(const char* name);

41
simgear/structure/subsystem_test.cxx
View File

@ -20,7 +20,7 @@ using std::endl;
class MySub1 : public SGSubsystem class MySub1 : public SGSubsystem
{ {
public: public:
static const char* subsystemName() { return "mysub"; } static const char* staticSubsystemClassId() { return "mysub"; }
void init() override void init() override
{ {
@ -45,7 +45,7 @@ public:
class AnotherSub : public SGSubsystem class AnotherSub : public SGSubsystem
{ {
public: public:
static const char* subsystemName() { return "anothersub"; } static const char* staticSubsystemClassId() { return "anothersub"; }
void init() override void init() override
{ {
@ -70,7 +70,7 @@ public:
class FakeRadioSub : public SGSubsystem class FakeRadioSub : public SGSubsystem
{ {
public: public:
static const char* subsystemName() { return "fake-radio"; } static const char* staticSubsystemClassId() { return "fake-radio"; }
void init() override void init() override
{ {
@ -89,8 +89,9 @@ public:
class InstrumentGroup : public SGSubsystemGroup class InstrumentGroup : public SGSubsystemGroup
{ {
public: public:
static const char* subsystemName() { return "instruments"; } InstrumentGroup() : SGSubsystemGroup(InstrumentGroup::staticSubsystemClassId()) {}
InstrumentGroup() : SGSubsystemGroup(InstrumentGroup::subsystemName()) {} static const char* staticSubsystemClassId() { return "instruments"; }
virtual ~InstrumentGroup() virtual ~InstrumentGroup()
{ {
} }
@ -119,11 +120,11 @@ class RecorderDelegate : public SGSubsystemMgr::Delegate
public: public:
void willChange(SGSubsystem* sub, SGSubsystem::State newState) override void willChange(SGSubsystem* sub, SGSubsystem::State newState) override
{ {
events.push_back({sub->name(), false, newState}); events.push_back({sub->subsystemId(), false, newState});
} }
void didChange(SGSubsystem* sub, SGSubsystem::State newState) override void didChange(SGSubsystem* sub, SGSubsystem::State newState) override
{ {
events.push_back({sub->name(), true, newState}); events.push_back({sub->subsystemId(), true, newState});
} }
struct Event { struct Event {
@ -168,10 +169,10 @@ void testRegistrationAndCreation()
auto anotherSub = manager->create<AnotherSub>(); auto anotherSub = manager->create<AnotherSub>();
SG_VERIFY(anotherSub); SG_VERIFY(anotherSub);
SG_CHECK_EQUAL(anotherSub->name(), AnotherSub::subsystemName()); SG_CHECK_EQUAL(anotherSub->subsystemId(), AnotherSub::staticSubsystemClassId());
SG_CHECK_EQUAL(anotherSub->name(), std::string("anothersub")); SG_CHECK_EQUAL(anotherSub->subsystemId(), std::string("anothersub"));
SG_CHECK_EQUAL(anotherSub->typeName(), std::string("anothersub")); SG_CHECK_EQUAL(anotherSub->subsystemClassId(), std::string("anothersub"));
SG_CHECK_EQUAL(anotherSub->instanceName(), std::string()); SG_CHECK_EQUAL(anotherSub->subsystemInstanceId(), std::string());
auto radio1 = manager->createInstance<FakeRadioSub>("nav1"); auto radio1 = manager->createInstance<FakeRadioSub>("nav1");
auto radio2 = manager->createInstance<FakeRadioSub>("nav2"); auto radio2 = manager->createInstance<FakeRadioSub>("nav2");
@ -187,8 +188,8 @@ void testAddGetRemove()
auto anotherSub = manager->add<AnotherSub>(); auto anotherSub = manager->add<AnotherSub>();
SG_VERIFY(anotherSub); SG_VERIFY(anotherSub);
SG_CHECK_EQUAL(anotherSub->name(), AnotherSub::subsystemName()); SG_CHECK_EQUAL(anotherSub->subsystemId(), AnotherSub::staticSubsystemClassId());
SG_CHECK_EQUAL(anotherSub->name(), std::string("anothersub")); SG_CHECK_EQUAL(anotherSub->subsystemId(), std::string("anothersub"));
SG_VERIFY(d->hasEvent("anothersub-will-add")); SG_VERIFY(d->hasEvent("anothersub-will-add"));
SG_VERIFY(d->hasEvent("anothersub-did-add")); SG_VERIFY(d->hasEvent("anothersub-did-add"));
@ -200,14 +201,14 @@ void testAddGetRemove()
// manual create & add // manual create & add
auto mySub = manager->create<MySub1>(); auto mySub = manager->create<MySub1>();
manager->add(MySub1::subsystemName(), mySub.ptr(), SGSubsystemMgr::DISPLAY, 0.1234); manager->add(MySub1::staticSubsystemClassId(), mySub.ptr(), SGSubsystemMgr::DISPLAY, 0.1234);
SG_VERIFY(d->hasEvent("mysub-will-add")); SG_VERIFY(d->hasEvent("mysub-will-add"));
SG_VERIFY(d->hasEvent("mysub-did-add")); SG_VERIFY(d->hasEvent("mysub-did-add"));
SG_CHECK_EQUAL(manager->get_subsystem<MySub1>(), mySub); SG_CHECK_EQUAL(manager->get_subsystem<MySub1>(), mySub);
bool ok = manager->remove(AnotherSub::subsystemName()); bool ok = manager->remove(AnotherSub::staticSubsystemClassId());
SG_VERIFY(ok); SG_VERIFY(ok);
SG_VERIFY(d->hasEvent("anothersub-will-remove")); SG_VERIFY(d->hasEvent("anothersub-will-remove"));
SG_VERIFY(d->hasEvent("anothersub-did-remove")); SG_VERIFY(d->hasEvent("anothersub-did-remove"));
@ -219,7 +220,7 @@ void testAddGetRemove()
// re-add of removed, and let's test overriding // re-add of removed, and let's test overriding
auto another2 = manager->add<AnotherSub>(SGSubsystemMgr::SOUND); auto another2 = manager->add<AnotherSub>(SGSubsystemMgr::SOUND);
SG_CHECK_EQUAL(another2->name(), AnotherSub::subsystemName()); SG_CHECK_EQUAL(another2->subsystemId(), AnotherSub::staticSubsystemClassId());
auto soundGroup = manager->get_group(SGSubsystemMgr::SOUND); auto soundGroup = manager->get_group(SGSubsystemMgr::SOUND);
SG_CHECK_EQUAL(soundGroup->get_subsystem("anothersub"), another2); SG_CHECK_EQUAL(soundGroup->get_subsystem("anothersub"), another2);
@ -238,10 +239,10 @@ void testSubGrouping()
auto radio1 = manager->createInstance<FakeRadioSub>("nav1"); auto radio1 = manager->createInstance<FakeRadioSub>("nav1");
auto radio2 = manager->createInstance<FakeRadioSub>("nav2"); auto radio2 = manager->createInstance<FakeRadioSub>("nav2");
SG_CHECK_EQUAL(radio1->name(), std::string("fake-radio.nav1")); SG_CHECK_EQUAL(radio1->subsystemId(), std::string("fake-radio.nav1"));
SG_CHECK_EQUAL(radio2->name(), std::string("fake-radio.nav2")); SG_CHECK_EQUAL(radio2->subsystemId(), std::string("fake-radio.nav2"));
SG_CHECK_EQUAL(radio1->typeName(), std::string("fake-radio")); SG_CHECK_EQUAL(radio1->subsystemClassId(), std::string("fake-radio"));
SG_CHECK_EQUAL(radio2->instanceName(), std::string("nav2")); SG_CHECK_EQUAL(radio2->subsystemInstanceId(), std::string("nav2"));
instruments->set_subsystem(radio1); instruments->set_subsystem(radio1);
instruments->set_subsystem(radio2); instruments->set_subsystem(radio2);