enhance SimpleContainer to use with fallback container

iface/common/container.hh

@@ -64,6 +64,25 @@ class Container {
   }
 };
 
+template <typename I>
+class NullContainer : public Container<I> {
+ public:
+  static std::shared_ptr<NullContainer> instance()
+  try {
+    static const auto kInstance = std::make_shared<NullContainer>();
+    return kInstance;
+  } catch (const std::bad_alloc&) {
+    throw Exception {"memory shortage"};
+  }
+
+ public:
+  NullContainer() = default;
+
+ public:
+  std::shared_ptr<I> Get(std::type_index) override { return nullptr; }
+  bool installed(std::type_index) const noexcept override { return false; }
+};
+
 template <typename I>
 class SimpleContainer : public Container<I> {
  public:
@@ -95,8 +114,9 @@ class SimpleContainer : public Container<I> {
   }
 
   SimpleContainer() = delete;
-  explicit SimpleContainer(FactoryMap&& factories) noexcept
-      : factories_(std::move(factories)) { }
+  SimpleContainer(FactoryMap&& factories,
+                  Container<I>& fb = *NullContainer<I>::instance()) noexcept
+      : fallback_(fb), factories_(std::move(factories)) { }
 
   std::shared_ptr<I> Get(std::type_index idx) override {
     const auto obj_itr = objs_.find(idx);
@@ -122,11 +142,11 @@ class SimpleContainer : public Container<I> {
         throw Exception {"memory shortage"};
       }
     }
-    return nullptr;
+    return fallback_.Get(idx);
   }
 
   bool installed(std::type_index idx) const noexcept override {
-    return factories_.contains(idx);
+    return factories_.contains(idx) || fallback_.installed(idx);
   }
 
   using Container<I>::Get;
@@ -134,6 +154,8 @@ class SimpleContainer : public Container<I> {
   using Container<I>::installed;
 
  private:
+  Container<I>& fallback_;
+
   FactoryMap factories_;
   ObjectMap  objs_;
 

iface/common/container_test.cc

@@ -66,6 +66,28 @@ TEST(SimpleContainer, CheckInstalled) {
   EXPECT_FALSE(sut.installed<IB>());
 }
 
+TEST(SimpleContainer, FetchWithFallback) {
+  SUT fb {{
+    SUT::MakePair<IA, A>(),
+  }};
+  SUT sut {{}, fb};
+  auto ptr = sut.Get<IA>();
+  EXPECT_TRUE(std::dynamic_pointer_cast<A>(ptr));
+}
+TEST(SimpleContainer, FetchUnknownWithFallback) {
+  SUT fb {{}};
+  SUT sut {{}, fb};
+  EXPECT_THROW(sut.Get<IA>(), nf7::Exception);
+}
+TEST(SimpleContainer, CheckInstalledWithFallback) {
+  SUT fb {{
+    SUT::MakePair<IA, A>(),
+  }};
+  SUT sut {{}, fb};
+  EXPECT_TRUE(sut.installed<IA>());
+  EXPECT_FALSE(sut.installed<IB>());
+}
+
 #if !defined(NDEBUG)
 TEST(SimpleContainer, DeathByFetchRecursive) {
   SUT sut {{