Refactored register_preamble (#149)

anutosh491 · web-flow · commit 24c9a41fc4c7 · 2024-06-18T13:09:03.000+03:00
diff --git a/include/xeus-cpp/xholder.hpp b/include/xeus-cpp/xholder.hpp
@@ -30,12 +30,12 @@ namespace xcpp
         ~xholder_preamble();
         xholder_preamble(const xholder_preamble& rhs);
         xholder_preamble(xholder_preamble&& rhs);
-        xholder_preamble(xpreamble* holder);
+        xholder_preamble(std::unique_ptr<xpreamble> holder);
 
         xholder_preamble& operator=(const xholder_preamble& rhs);
         xholder_preamble& operator=(xholder_preamble&& rhs);
 
-        xholder_preamble& operator=(xpreamble* holder);
+        xholder_preamble& operator=(std::unique_ptr<xpreamble> holder);
 
         void swap(xholder_preamble& rhs)
         {
@@ -53,7 +53,7 @@ namespace xcpp
 
     private:
 
-        xpreamble* p_holder;
+        std::unique_ptr<xpreamble> p_holder;
     };
 }
 #endif
diff --git a/include/xeus-cpp/xmanager.hpp b/include/xeus-cpp/xmanager.hpp
@@ -31,9 +31,9 @@ namespace xcpp
         std::map<std::string, xholder_preamble> preamble;
 
         template <typename preamble_type>
-        void register_preamble(const std::string& name, preamble_type* pre)
+        void register_preamble(const std::string& name, std::unique_ptr<preamble_type> pre)
         {
-            preamble[name] = xholder_preamble(pre);
+            preamble[name] = xholder_preamble(std::move(pre));
         }
 
         void unregister_preamble(const std::string& name)
@@ -186,9 +186,9 @@ namespace xcpp
             }
         }
 
-        virtual xpreamble* clone() const override
+        [[nodiscard]] std::unique_ptr<xpreamble> clone() const override
         {
-            return new xmagics_manager(*this);
+            return std::make_unique<xmagics_manager>(*this);
         }
 
     private:
diff --git a/include/xeus-cpp/xpreamble.hpp b/include/xeus-cpp/xpreamble.hpp
@@ -30,7 +30,7 @@ namespace xcpp
         }
 
         virtual void apply(const std::string& s, nl::json& kernel_res) = 0;
-        virtual xpreamble* clone() const = 0;
+        virtual std::unique_ptr<xpreamble> clone() const = 0;
         virtual ~xpreamble(){};
     };
 }
diff --git a/src/xholder.cpp b/src/xholder.cpp
@@ -24,23 +24,22 @@ namespace xcpp
     {
     }
 
-    xholder_preamble::xholder_preamble(xpreamble* holder)
-        : p_holder(holder)
+    xholder_preamble::xholder_preamble(std::unique_ptr<xpreamble> holder)
+        : p_holder(std::move(holder))
     {
     }
 
     xholder_preamble::~xholder_preamble()
     {
-        delete p_holder;
     }
 
     xholder_preamble::xholder_preamble(const xholder_preamble& rhs)
-        : p_holder(rhs.p_holder ? rhs.p_holder->clone() : nullptr)
+        : p_holder(rhs.p_holder ? std::move(rhs.p_holder->clone()) : nullptr)
     {
     }
 
     xholder_preamble::xholder_preamble(xholder_preamble&& rhs)
-        : p_holder(rhs.p_holder)
+        : p_holder(std::move(rhs.p_holder))
     {
         rhs.p_holder = nullptr;
     }
@@ -59,10 +58,9 @@ namespace xcpp
         return *this;
     }
 
-    xholder_preamble& xholder_preamble::operator=(xpreamble* holder)
+    xholder_preamble& xholder_preamble::operator=(std::unique_ptr<xpreamble> holder)
     {
-        delete p_holder;
-        p_holder = holder;
+        p_holder = std::move(holder);
         return *this;
     }
 
diff --git a/src/xinspect.hpp b/src/xinspect.hpp
@@ -279,9 +279,9 @@ namespace xcpp
             inspect(to_inspect[1], kernel_res);
         }
 
-        virtual xpreamble* clone() const override
+        [[nodiscard]] std::unique_ptr<xpreamble> clone() const override
         {
-            return new xintrospection(*this);
+            return std::make_unique<xintrospection>(*this);
         }
     };
 
diff --git a/src/xinterpreter.cpp b/src/xinterpreter.cpp
@@ -391,11 +391,10 @@ __get_cxx_version ()
 
     void interpreter::init_preamble()
     {
-        // FIXME: Make register_preamble take a unique_ptr.
         //NOLINTBEGIN(cppcoreguidelines-owning-memory)
-        preamble_manager.register_preamble("introspection", new xintrospection());
-        preamble_manager.register_preamble("magics", new xmagics_manager());
-        preamble_manager.register_preamble("shell", new xsystem());
+        preamble_manager.register_preamble("introspection", std::make_unique<xintrospection>());
+        preamble_manager.register_preamble("magics", std::make_unique<xmagics_manager>());
+        preamble_manager.register_preamble("shell", std::make_unique<xsystem>());
         //NOLINTEND(cppcoreguidelines-owning-memory)
     }
 
diff --git a/src/xsystem.hpp b/src/xsystem.hpp
@@ -67,9 +67,9 @@ namespace xcpp
             }
         }
 
-        virtual xpreamble* clone() const override
+        [[nodiscard]] std::unique_ptr<xpreamble> clone() const override
         {
-            return new xsystem(*this);
+            return std::make_unique<xsystem>(*this);
         }
     };
 }
diff --git a/test/test_interpreter.cpp b/test/test_interpreter.cpp
@@ -407,7 +407,7 @@ TEST_SUITE("clone_magics_manager")
     {
         xcpp::xmagics_manager manager;
 
-        xcpp::xpreamble* clone = manager.clone();
+        std::unique_ptr<xcpp::xpreamble> clone = manager.clone();
 
         REQUIRE(clone != nullptr);
     }
@@ -419,11 +419,9 @@ TEST_SUITE("clone_magics_manager")
     {
         xcpp::xmagics_manager manager;
 
-        xcpp::xpreamble* clone = manager.clone();
+        std::unique_ptr<xcpp::xpreamble> clone = manager.clone();
 
-        REQUIRE(dynamic_cast<xcpp::xmagics_manager*>(clone) != nullptr);
-
-        delete clone;
+        REQUIRE(clone.get() != nullptr);
     }
 }
 
@@ -436,12 +434,13 @@ TEST_SUITE("xpreamble_manager_operator")
     {
         std::string name = "test";
         xcpp::xpreamble_manager manager;
-        xcpp::xmagics_manager* magics = new xcpp::xmagics_manager();
-        manager.register_preamble(name, magics);
+        std::unique_ptr<xcpp::xmagics_manager> magics = std::make_unique<xcpp::xmagics_manager>();
+        auto* raw_ptr = magics.get();
+        manager.register_preamble(name, std::move(magics));
 
         xcpp::xholder_preamble& result = manager.operator[](name);
 
-        REQUIRE(&(result.get_cast<xcpp::xmagics_manager>()) == magics);
+        REQUIRE(&(result.get_cast<xcpp::xmagics_manager>()) == raw_ptr);
     }
 }
 
@@ -642,7 +641,7 @@ TEST_SUITE("xsystem_clone")
     {
         xcpp::xsystem system;
 
-        xcpp::xpreamble* clone = system.clone();
+        std::unique_ptr<xcpp::xpreamble> clone = system.clone();
 
         REQUIRE(clone != nullptr);
     }
@@ -651,9 +650,9 @@ TEST_SUITE("xsystem_clone")
     {
         xcpp::xsystem system;
 
-        xcpp::xpreamble* clone = system.clone();
+        std::unique_ptr<xcpp::xpreamble> clone = system.clone();
 
-        REQUIRE(dynamic_cast<xcpp::xsystem*>(clone) != nullptr);
+        REQUIRE(clone.get() != nullptr);
 
     }
 }
@@ -727,7 +726,7 @@ TEST_SUITE("xmagics_apply"){
 
         xcpp::xpreamble_manager preamble_manager;
 
-        preamble_manager.register_preamble("magics", new xcpp::xmagics_manager());
+        preamble_manager.register_preamble("magics", std::make_unique<xcpp::xmagics_manager>());
 
         preamble_manager["magics"].get_cast<xcpp::xmagics_manager>().register_magic("magic2", MyMagicCell());
 
@@ -742,7 +741,7 @@ TEST_SUITE("xmagics_apply"){
 
         xcpp::xpreamble_manager preamble_manager;
 
-        preamble_manager.register_preamble("magics", new xcpp::xmagics_manager());
+        preamble_manager.register_preamble("magics", std::make_unique<xcpp::xmagics_manager>());
 
         preamble_manager["magics"].get_cast<xcpp::xmagics_manager>().register_magic("magic1", MyMagicLine());
 

Original file line number	Diff line number	Diff line change
`@@ -31,9 +31,9 @@ namespace xcpp`
`31`	`31`	`std::map<std::string, xholder_preamble> preamble;`
`32`	`32`
`33`	`33`	`template <typename preamble_type>`
`34`		`- void register_preamble(const std::string& name, preamble_type* pre)`
	`34`	`+ void register_preamble(const std::string& name, std::unique_ptr<preamble_type> pre)`
`35`	`35`	`{`
`36`		`- preamble[name] = xholder_preamble(pre);`
	`36`	`+ preamble[name] = xholder_preamble(std::move(pre));`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`void unregister_preamble(const std::string& name)`
`@@ -186,9 +186,9 @@ namespace xcpp`
`186`	`186`	`}`
`187`	`187`	`}`
`188`	`188`
`189`		`- virtual xpreamble* clone() const override`
	`189`	`+ [[nodiscard]] std::unique_ptr<xpreamble> clone() const override`
`190`	`190`	`{`
`191`		`- return new xmagics_manager(*this);`
	`191`	`+ return std::make_unique<xmagics_manager>(*this);`
`192`	`192`	`}`
`193`	`193`
`194`	`194`	`private:`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ namespace xcpp`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`virtual void apply(const std::string& s, nl::json& kernel_res) = 0;`
`33`		`- virtual xpreamble* clone() const = 0;`
	`33`	`+ virtual std::unique_ptr<xpreamble> clone() const = 0;`
`34`	`34`	`virtual ~xpreamble(){};`
`35`	`35`	`};`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,23 +24,22 @@ namespace xcpp`
`24`	`24`	`{`
`25`	`25`	`}`
`26`	`26`
`27`		`- xholder_preamble::xholder_preamble(xpreamble* holder)`
`28`		`- : p_holder(holder)`
	`27`	`+ xholder_preamble::xholder_preamble(std::unique_ptr<xpreamble> holder)`
	`28`	`+ : p_holder(std::move(holder))`
`29`	`29`	`{`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`xholder_preamble::~xholder_preamble()`
`33`	`33`	`{`
`34`		`- delete p_holder;`
`35`	`34`	`}`
`36`	`35`
`37`	`36`	`xholder_preamble::xholder_preamble(const xholder_preamble& rhs)`
`38`		`- : p_holder(rhs.p_holder ? rhs.p_holder->clone() : nullptr)`
	`37`	`+ : p_holder(rhs.p_holder ? std::move(rhs.p_holder->clone()) : nullptr)`
`39`	`38`	`{`
`40`	`39`	`}`
`41`	`40`
`42`	`41`	`xholder_preamble::xholder_preamble(xholder_preamble&& rhs)`
`43`		`- : p_holder(rhs.p_holder)`
	`42`	`+ : p_holder(std::move(rhs.p_holder))`
`44`	`43`	`{`
`45`	`44`	`rhs.p_holder = nullptr;`
`46`	`45`	`}`
`@@ -59,10 +58,9 @@ namespace xcpp`
`59`	`58`	`return *this;`
`60`	`59`	`}`
`61`	`60`
`62`		`- xholder_preamble& xholder_preamble::operator=(xpreamble* holder)`
	`61`	`+ xholder_preamble& xholder_preamble::operator=(std::unique_ptr<xpreamble> holder)`
`63`	`62`	`{`
`64`		`- delete p_holder;`
`65`		`- p_holder = holder;`
	`63`	`+ p_holder = std::move(holder);`
`66`	`64`	`return *this;`
`67`	`65`	`}`
`68`	`66`
Original file line number	Diff line number	Diff line change
`@@ -279,9 +279,9 @@ namespace xcpp`
`279`	`279`	`inspect(to_inspect[1], kernel_res);`
`280`	`280`	`}`
`281`	`281`
`282`		`- virtual xpreamble* clone() const override`
	`282`	`+ [[nodiscard]] std::unique_ptr<xpreamble> clone() const override`
`283`	`283`	`{`
`284`		`- return new xintrospection(*this);`
	`284`	`+ return std::make_unique<xintrospection>(*this);`
`285`	`285`	`}`
`286`	`286`	`};`
`287`	`287`
Original file line number	Diff line number	Diff line change
`@@ -391,11 +391,10 @@ __get_cxx_version ()`
`391`	`391`
`392`	`392`	`void interpreter::init_preamble()`
`393`	`393`	`{`
`394`		`- // FIXME: Make register_preamble take a unique_ptr.`
`395`	`394`	`//NOLINTBEGIN(cppcoreguidelines-owning-memory)`
`396`		`- preamble_manager.register_preamble("introspection", new xintrospection());`
`397`		`- preamble_manager.register_preamble("magics", new xmagics_manager());`
`398`		`- preamble_manager.register_preamble("shell", new xsystem());`
	`395`	`+ preamble_manager.register_preamble("introspection", std::make_unique<xintrospection>());`
	`396`	`+ preamble_manager.register_preamble("magics", std::make_unique<xmagics_manager>());`
	`397`	`+ preamble_manager.register_preamble("shell", std::make_unique<xsystem>());`
`399`	`398`	`//NOLINTEND(cppcoreguidelines-owning-memory)`
`400`	`399`	`}`
`401`	`400`
Original file line number	Diff line number	Diff line change
`@@ -67,9 +67,9 @@ namespace xcpp`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
`70`		`- virtual xpreamble* clone() const override`
	`70`	`+ [[nodiscard]] std::unique_ptr<xpreamble> clone() const override`
`71`	`71`	`{`
`72`		`- return new xsystem(*this);`
	`72`	`+ return std::make_unique<xsystem>(*this);`
`73`	`73`	`}`
`74`	`74`	`};`
`75`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -407,7 +407,7 @@ TEST_SUITE("clone_magics_manager")`
`407`	`407`	`{`
`408`	`408`	`xcpp::xmagics_manager manager;`
`409`	`409`
`410`		`- xcpp::xpreamble* clone = manager.clone();`
	`410`	`+ std::unique_ptr<xcpp::xpreamble> clone = manager.clone();`
`411`	`411`
`412`	`412`	`REQUIRE(clone != nullptr);`
`413`	`413`	`}`
`@@ -419,11 +419,9 @@ TEST_SUITE("clone_magics_manager")`
`419`	`419`	`{`
`420`	`420`	`xcpp::xmagics_manager manager;`
`421`	`421`
`422`		`- xcpp::xpreamble* clone = manager.clone();`
	`422`	`+ std::unique_ptr<xcpp::xpreamble> clone = manager.clone();`
`423`	`423`
`424`		`- REQUIRE(dynamic_cast<xcpp::xmagics_manager*>(clone) != nullptr);`
`425`		`-`
`426`		`- delete clone;`
	`424`	`+ REQUIRE(clone.get() != nullptr);`
`427`	`425`	`}`
`428`	`426`	`}`
`429`	`427`
`@@ -436,12 +434,13 @@ TEST_SUITE("xpreamble_manager_operator")`
`436`	`434`	`{`
`437`	`435`	`std::string name = "test";`
`438`	`436`	`xcpp::xpreamble_manager manager;`
`439`		`- xcpp::xmagics_manager* magics = new xcpp::xmagics_manager();`
`440`		`- manager.register_preamble(name, magics);`
	`437`	`+ std::unique_ptr<xcpp::xmagics_manager> magics = std::make_unique<xcpp::xmagics_manager>();`
	`438`	`+ auto* raw_ptr = magics.get();`
	`439`	`+ manager.register_preamble(name, std::move(magics));`
`441`	`440`
`442`	`441`	`xcpp::xholder_preamble& result = manager.operator[](name);`
`443`	`442`
`444`		`- REQUIRE(&(result.get_cast<xcpp::xmagics_manager>()) == magics);`
	`443`	`+ REQUIRE(&(result.get_cast<xcpp::xmagics_manager>()) == raw_ptr);`
`445`	`444`	`}`
`446`	`445`	`}`
`447`	`446`
`@@ -642,7 +641,7 @@ TEST_SUITE("xsystem_clone")`
`642`	`641`	`{`
`643`	`642`	`xcpp::xsystem system;`
`644`	`643`
`645`		`- xcpp::xpreamble* clone = system.clone();`
	`644`	`+ std::unique_ptr<xcpp::xpreamble> clone = system.clone();`
`646`	`645`
`647`	`646`	`REQUIRE(clone != nullptr);`
`648`	`647`	`}`
`@@ -651,9 +650,9 @@ TEST_SUITE("xsystem_clone")`
`651`	`650`	`{`
`652`	`651`	`xcpp::xsystem system;`
`653`	`652`
`654`		`- xcpp::xpreamble* clone = system.clone();`
	`653`	`+ std::unique_ptr<xcpp::xpreamble> clone = system.clone();`
`655`	`654`
`656`		`- REQUIRE(dynamic_cast<xcpp::xsystem*>(clone) != nullptr);`
	`655`	`+ REQUIRE(clone.get() != nullptr);`
`657`	`656`
`658`	`657`	`}`
`659`	`658`	`}`
`@@ -727,7 +726,7 @@ TEST_SUITE("xmagics_apply"){`
`727`	`726`
`728`	`727`	`xcpp::xpreamble_manager preamble_manager;`
`729`	`728`
`730`		`- preamble_manager.register_preamble("magics", new xcpp::xmagics_manager());`
	`729`	`+ preamble_manager.register_preamble("magics", std::make_unique<xcpp::xmagics_manager>());`
`731`	`730`
`732`	`731`	`preamble_manager["magics"].get_cast<xcpp::xmagics_manager>().register_magic("magic2", MyMagicCell());`
`733`	`732`
`@@ -742,7 +741,7 @@ TEST_SUITE("xmagics_apply"){`
`742`	`741`
`743`	`742`	`xcpp::xpreamble_manager preamble_manager;`
`744`	`743`
`745`		`- preamble_manager.register_preamble("magics", new xcpp::xmagics_manager());`
	`744`	`+ preamble_manager.register_preamble("magics", std::make_unique<xcpp::xmagics_manager>());`
`746`	`745`
`747`	`746`	`preamble_manager["magics"].get_cast<xcpp::xmagics_manager>().register_magic("magic1", MyMagicLine());`
`748`	`747`