Separate out monarch and peasant, so they aren't so tightly coupled

src/tools/MonarchPeasantSample/Monarch.cpp

@@ -17,15 +17,22 @@ namespace winrt::MonarchPeasantSample::implementation
     Monarch::Monarch()
     {
         printf("Instantiated a Monarch\n");
-        _peasants = winrt::single_threaded_observable_map<uint64_t, winrt::MonarchPeasantSample::IPeasant>();
+        // _peasants = winrt::single_threaded_observable_map<uint64_t, winrt::MonarchPeasantSample::IPeasant>();
     }
+
     Monarch::~Monarch()
     {
         printf("~Monarch()\n");
         std::unique_lock<std::mutex> lk(m);
         dtored = true;
         cv.notify_one();
     }
+
+    uint64_t Monarch::GetPID()
+    {
+        return GetCurrentProcessId();
+    }
+
     uint64_t Monarch::AddPeasant(winrt::MonarchPeasantSample::IPeasant peasant)
     {
         // TODO: This whole algo is terrible. There's gotta be a better way of
@@ -42,8 +49,28 @@ namespace winrt::MonarchPeasantSample::implementation
             printf("Peasant already had an ID, %lld\n", peasant.GetID());
             _nextPeasantID = providedID >= _nextPeasantID ? providedID + 1 : _nextPeasantID;
         }
-        _peasants.Insert(peasant.GetID(), peasant);
+        _peasants[peasant.GetID()] = peasant;
         printf("(the next new peasant will get the ID %lld)\n", _nextPeasantID);
         return peasant.GetID();
     }
+
+    bool Monarch::IsInSingleInstanceMode()
+    {
+        return false;
+    }
+
+    winrt::MonarchPeasantSample::IPeasant Monarch::GetPeasant(uint64_t peasantID)
+    {
+        return _peasants.at(peasantID);
+    }
+
+    winrt::MonarchPeasantSample::IPeasant Monarch::GetMostRecentPeasant()
+    {
+        return nullptr;
+    }
+
+    void Monarch::SetSelfID(const uint64_t selfID)
+    {
+        _thisPeasantID = selfID;
+    }
 }

src/tools/MonarchPeasantSample/Monarch.h

@@ -14,23 +14,27 @@ constexpr GUID Monarch_clsid{
 
 namespace winrt::MonarchPeasantSample::implementation
 {
-    struct Monarch : public MonarchT<Monarch>, public PeasantBase
+    struct Monarch : public MonarchT<Monarch>
     {
         Monarch();
         ~Monarch();
 
+        uint64_t GetPID();
+
         uint64_t AddPeasant(winrt::MonarchPeasantSample::IPeasant peasant);
-        bool IsInSingleInstanceMode() { return false; }
-        winrt::MonarchPeasantSample::IPeasant GetPeasant(uint64_t peasantID)
-        {
-            peasantID;
-            return nullptr;
-        }
-        winrt::MonarchPeasantSample::IPeasant GetMostRecentPeasant() { return nullptr; }
+
+        bool IsInSingleInstanceMode();
+
+        winrt::MonarchPeasantSample::IPeasant GetPeasant(uint64_t peasantID);
+
+        winrt::MonarchPeasantSample::IPeasant GetMostRecentPeasant();
+
+        void SetSelfID(const uint64_t selfID);
 
     private:
         uint64_t _nextPeasantID{ 1 };
-        Windows::Foundation::Collections::IObservableMap<uint64_t, winrt::MonarchPeasantSample::IPeasant> _peasants{ nullptr };
+        uint64_t _thisPeasantID{ 0 };
+        std::unordered_map<uint64_t, winrt::MonarchPeasantSample::IPeasant> _peasants;
     };
 }
 

src/tools/MonarchPeasantSample/Monarch.idl

@@ -2,10 +2,10 @@ import "Peasant.idl";
 
 namespace MonarchPeasantSample
 {
-    [default_interface] runtimeclass Monarch : IPeasant
-    {
+    [default_interface] runtimeclass Monarch {
         Monarch();
 
+        UInt64 GetPID();
         UInt64 AddPeasant(IPeasant peasant);
         Boolean IsInSingleInstanceMode();
         IPeasant GetPeasant(UInt64 peasantID);

src/tools/MonarchPeasantSample/Peasant.cpp

@@ -14,4 +14,25 @@ namespace winrt::MonarchPeasantSample::implementation
     {
     }
 
+    void Peasant::AssignID(uint64_t id)
+    {
+        _id = id;
+    }
+    uint64_t Peasant::GetID()
+    {
+        return _id;
+    }
+
+    uint64_t Peasant::GetPID()
+    {
+        return GetCurrentProcessId();
+    }
+
+    bool Peasant::ExecuteCommandline(winrt::array_view<const winrt::hstring> args, winrt::hstring currentDirectory)
+    {
+        args;
+        currentDirectory;
+        return true;
+    }
+
 }

src/tools/MonarchPeasantSample/Peasant.h

@@ -13,28 +13,20 @@ constexpr GUID Peasant_clsid{
 
 namespace winrt::MonarchPeasantSample::implementation
 {
-    struct PeasantBase
+    struct Peasant : public PeasantT<Peasant>
     {
-        void AssignID(uint64_t id) { _id = id; }
-        uint64_t GetID() { return _id; }
-        uint64_t GetPID() { return GetCurrentProcessId(); }
-        bool ExecuteCommandline(winrt::array_view<const winrt::hstring> args, winrt::hstring currentDirectory)
-        {
-            args;
-            currentDirectory;
-            return true;
-        }
-        TYPED_EVENT(WindowActivated, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        Peasant();
 
-    private:
-        uint64_t _id{ 0 };
-    };
+        void AssignID(uint64_t id);
+        uint64_t GetID();
+        uint64_t GetPID();
 
-    struct Peasant : public PeasantT<Peasant>, public PeasantBase
-    {
-        Peasant();
+        bool ExecuteCommandline(winrt::array_view<const winrt::hstring> args, winrt::hstring currentDirectory);
+
+        TYPED_EVENT(WindowActivated, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
 
     private:
+        uint64_t _id{ 0 };
     };
 }
 

src/tools/MonarchPeasantSample/main.cpp

@@ -81,7 +81,7 @@ bool areWeTheKing(const winrt::MonarchPeasantSample::Monarch& monarch, const boo
     {
         if (ourPID == kingPID)
         {
-            printf(fmt::format("We're the king - our PID is {}\n", ourPID).c_str());
+            printf(fmt::format("We're the \x1b[33mking\x1b[m - our PID is {}\n", ourPID).c_str());
         }
         else
         {
@@ -91,20 +91,34 @@ bool areWeTheKing(const winrt::MonarchPeasantSample::Monarch& monarch, const boo
     return (ourPID == kingPID);
 }
 
-MonarchPeasantSample::IPeasant getOurPeasant(const winrt::MonarchPeasantSample::Monarch& monarch)
+void remindKingWhoTheyAre(const winrt::MonarchPeasantSample::Monarch& monarch,
+                          const winrt::MonarchPeasantSample::IPeasant& peasant)
 {
-    if (areWeTheKing(monarch))
+    winrt::com_ptr<MonarchPeasantSample::implementation::Monarch> monarchImpl;
+    monarchImpl.copy_from(winrt::get_self<MonarchPeasantSample::implementation::Monarch>(monarch));
+    if (monarchImpl)
     {
-        auto iPeasant = monarch.try_as<winrt::MonarchPeasantSample::IPeasant>();
-        return iPeasant;
+        auto ourID = peasant.GetID();
+        monarchImpl->SetSelfID(ourID);
+        printf("The king is peasant #%lld\n", ourID);
     }
     else
     {
-        auto peasant = winrt::make_self<MonarchPeasantSample::implementation::Peasant>();
-        auto ourID = monarch.AddPeasant(*peasant);
-        printf("The monarch assigned us the ID %llu\n", ourID);
-        return *peasant;
+        // printf("Shoot, we wanted to be able to get the impl here but couldnt\n");
+    }
+}
+
+MonarchPeasantSample::IPeasant createOurPeasant(const winrt::MonarchPeasantSample::Monarch& monarch)
+{
+    auto peasant = winrt::make_self<MonarchPeasantSample::implementation::Peasant>();
+    auto ourID = monarch.AddPeasant(*peasant);
+    printf("The monarch assigned us the ID %llu\n", ourID);
+
+    if (areWeTheKing(monarch))
+    {
+        remindKingWhoTheyAre(monarch, *peasant);
     }
+    return *peasant;
 }
 
 void printPeasants(const winrt::MonarchPeasantSample::Monarch& /*monarch*/)
@@ -199,22 +213,22 @@ bool peasantAppLoop(const winrt::MonarchPeasantSample::Monarch& monarch,
 
     while (!exitRequested)
     {
-        printf("Beginning wait...\n");
+        // printf("Beginning wait...\n");
         auto waitResult = WaitForMultipleObjects(2, handlesToWaitOn, false, INFINITE);
 
         switch (waitResult)
         {
         // handlesToWaitOn[0] was signaled
         case WAIT_OBJECT_0 + 0:
-            printf("First event was signaled.\n");
-            printf("THE KING IS DEAD\n");
+            // printf("First event was signaled.\n");
+            printf("THE KING IS \x1b[31mDEAD\x1b[m\n");
             // Return false here - this will trigger us to find the new monarch
             return false;
             break;
 
         // handlesToWaitOn[1] was signaled
         case WAIT_OBJECT_0 + 1:
-            printf("Second event was signaled.\n");
+            // printf("Second event was signaled.\n");
             exitRequested = peasantReadInput(monarch, peasant);
             break;
 
@@ -244,7 +258,7 @@ void app()
 
     auto monarch = instantiateAMonarch();
     bool isMonarch = areWeTheKing(monarch, true);
-    auto peasant = getOurPeasant(monarch);
+    auto peasant = createOurPeasant(monarch);
 
     while (!exitRequested)
     {
@@ -259,9 +273,12 @@ void app()
             {
                 monarch = instantiateAMonarch();
                 isMonarch = areWeTheKing(monarch, true);
-                printf("LONG LIVE THE KING\n");
+
+                printf("LONG LIVE THE %sKING\x1b[m\n", isMonarch ? "\x1b[33m" : "");
+
                 if (isMonarch)
                 {
+                    remindKingWhoTheyAre(monarch, peasant);
                     // TODO: If we've been elected monarch, then we need to make
                     // sure that we're one of the listed peasants (right?) We
                     // probably don't _only_ need to do this during the
@@ -298,5 +315,8 @@ int main(int /*argc*/, char** /*argv*/)
         printf("Error: %ls\n", e.message().c_str());
     }
 
+    printf("We've left the app. Press any key to close.\n");
+    const auto ch = _getch();
+    ch;
     printf("Exiting client\n");
 }