Implemented the "Support for support enforcers only" quick selection.

Reduced some memory leaks due to the ConfigDef::default_value pointer.

src/libslic3r/Config.cpp

@@ -280,7 +280,7 @@ std::ostream& ConfigDef::print_cli_help(std::ostream& out, bool show_defaults, s
             
             // right: option description
             std::string descr = def.tooltip;
-            if (show_defaults && def.default_value != nullptr && def.type != coBool
+            if (show_defaults && def.default_value && def.type != coBool
                 && (def.type != coString || !def.default_value->serialize().empty())) {
                 descr += " (";
                 if (!def.sidetext.empty()) {
@@ -627,7 +627,7 @@ ConfigOption* DynamicConfig::optptr(const t_config_option_key &opt_key, bool cre
         // Let the parent decide what to do if the opt_key is not defined by this->def().
         return nullptr;
     ConfigOption *opt = nullptr;
-    if (optdef->default_value != nullptr) {
+    if (optdef->default_value) {
         opt = (optdef->default_value->type() == coEnum) ?
             // Special case: For a DynamicConfig, convert a templated enum to a generic enum.
             new ConfigOptionEnumGeneric(optdef->enum_keys_map, optdef->default_value->getInt()) :
@@ -783,8 +783,8 @@ void StaticConfig::set_defaults()
         for (const std::string &key : this->keys()) {
             const ConfigOptionDef   *def = defs->get(key);
             ConfigOption            *opt = this->option(key);
-            if (def != nullptr && opt != nullptr && def->default_value != nullptr)
-                opt->set(def->default_value);
+            if (def != nullptr && opt != nullptr && def->default_value)
+                opt->set(def->default_value.get());
         }
     }
 }

src/libslic3r/Config.hpp

@@ -12,6 +12,7 @@
 #include <string>
 #include <vector>
 #include "libslic3r.h"
+#include "clonable_ptr.hpp"
 #include "Point.hpp"
 
 #include <boost/format.hpp>
@@ -1010,7 +1011,8 @@ public:
     // What type? bool, int, string etc.
     ConfigOptionType                    type            = coNone;
     // Default value of this option. The default value object is owned by ConfigDef, it is released in its destructor.
-    const ConfigOption                 *default_value   = nullptr;
+    Slic3r::clonable_ptr<const ConfigOption> default_value   = nullptr;
+    void set_default_value(const ConfigOption* ptr) { this->default_value = Slic3r::clonable_ptr<const ConfigOption>(ptr); }
 
     // Usually empty. 
     // Special values - "i_enum_open", "f_enum_open" to provide combo box for int or float selection,
@@ -1099,12 +1101,6 @@ typedef std::map<t_config_option_key, ConfigOptionDef> t_optiondef_map;
 class ConfigDef
 {
 public:
-	~ConfigDef() { 
-		for (std::pair<const t_config_option_key, ConfigOptionDef> &def : this->options) 
-			delete def.second.default_value;
-        this->options.clear();
-	}
-
     t_optiondef_map         options;
 
     bool                    has(const t_config_option_key &opt_key) const { return this->options.count(opt_key) > 0; }

src/libslic3r/PrintConfig.hpp

@@ -307,8 +307,8 @@ protected:
                 m_keys.emplace_back(kvp.first);
                 const ConfigOptionDef *def = defs->get(kvp.first);
                 assert(def != nullptr);
-                if (def->default_value != nullptr)
-                    opt->set(def->default_value);
+                if (def->default_value)
+                    opt->set(def->default_value.get());
             }
         }
 

src/libslic3r/clonable_ptr.hpp

@@ -0,0 +1,168 @@
+// clonable_ptr: a smart pointer with a usage similar to unique_ptr, with the exception, that
+// the copy constructor / copy assignment operator work by calling the ->clone() method.
+
+// derived from https://github.com/SRombauts/shared_ptr/blob/master/include/unique_ptr.hpp
+/**
+ * @file  clonable_ptr.hpp
+ * @brief clonable_ptr is a fake implementation to use in place of a C++11 std::clonable_ptr when compiling on an older compiler.
+ *
+ * @see http://www.cplusplus.com/reference/memory/clonable_ptr/
+ *
+ * Copyright (c) 2014-2019 Sebastien Rombauts (sebastien.rombauts@gmail.com)
+ *
+ * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt
+ * or copy at http://opensource.org/licenses/MIT)
+ */
+
+#include "assert.h"
+
+namespace Slic3r {
+
+// Detect whether the compiler supports C++11 noexcept exception specifications.
+#if defined(_MSC_VER) && _MSC_VER < 1900 && ! defined(noexcept)
+    #define noexcept throw()
+#endif
+
+template<class T>
+class clonable_ptr
+{
+public:
+    /// The type of the managed object, aliased as member type
+    typedef T element_type;
+
+    /// @brief Default constructor
+    clonable_ptr() noexcept :
+        px(nullptr)
+    {
+    }
+    /// @brief Constructor with the provided pointer to manage
+    explicit clonable_ptr(T* p) noexcept :
+        px(p)
+    {
+    }
+    /// @brief Copy constructor, clones by calling the rhs.clone() method
+    clonable_ptr(const clonable_ptr& rhs) :
+		px(rhs ? rhs.px->clone() : nullptr)
+    {
+    }
+    /// @brief Move constructor, never throws
+    clonable_ptr(clonable_ptr&& rhs) noexcept :
+        px(rhs.px)
+    {
+        rhs.px = nullptr;
+    }
+    /// @brief Assignment operator
+    clonable_ptr& operator=(const clonable_ptr& rhs)
+    {
+		delete px;
+		px = rhs ? rhs.px->clone() : nullptr;
+        return *this;
+    }
+    /// @brief Move operator, never throws
+    clonable_ptr& operator=(clonable_ptr&& rhs)
+    {
+		delete px;
+        px = rhs.px;
+        rhs.px = nullptr;
+        return *this;
+    }
+    /// @brief the destructor releases its ownership and destroy the object
+    inline ~clonable_ptr() noexcept
+    {
+        destroy();
+    }
+    /// @brief this reset releases its ownership and destroy the object
+    inline void reset() noexcept
+    {
+        destroy();
+    }
+    /// @brief this reset release its ownership and re-acquire another one
+    void reset(T* p) noexcept
+    {
+        assert((nullptr == p) || (px != p)); // auto-reset not allowed
+        destroy();
+        px = p;
+    }
+
+    /// @brief Swap method for the copy-and-swap idiom (copy constructor and swap method)
+    void swap(clonable_ptr& rhs) noexcept
+    {
+        T *tmp = px;
+        px = rhs.px;
+        rhs.px = tmp;
+    }
+
+    /// @brief release the ownership of the px pointer without destroying the object!
+    inline void release() noexcept
+    {
+        px = nullptr;
+    }
+
+    // reference counter operations :
+    inline operator bool() const noexcept
+    {
+        return (nullptr != px); // TODO nullptrptr
+    }
+
+    // underlying pointer operations :
+    inline T& operator*()  const noexcept
+    {
+        assert(nullptr != px);
+        return *px;
+    }
+    inline T* operator->() const noexcept
+    {
+        assert(nullptr != px);
+        return px;
+    }
+    inline T* get()  const noexcept
+    {
+        // no assert, can return nullptr
+        return px;
+    }
+
+private:
+    /// @brief release the ownership of the px pointer and destroy the object
+    inline void destroy() noexcept
+    {
+        delete px;
+        px = nullptr;
+    }
+
+    /// @brief hack: const-cast release the ownership of the px pointer without destroying the object!
+    inline void release() const noexcept
+    {
+        px = nullptr;
+    }
+
+private:
+    T* px; //!< Native pointer
+};
+
+// comparison operators
+template<class T, class U> inline bool operator==(const clonable_ptr<T>& l, const clonable_ptr<U>& r) noexcept
+{
+    return (l.get() == r.get());
+}
+template<class T, class U> inline bool operator!=(const clonable_ptr<T>& l, const clonable_ptr<U>& r) noexcept
+{
+    return (l.get() != r.get());
+}
+template<class T, class U> inline bool operator<=(const clonable_ptr<T>& l, const clonable_ptr<U>& r) noexcept
+{
+    return (l.get() <= r.get());
+}
+template<class T, class U> inline bool operator<(const clonable_ptr<T>& l, const clonable_ptr<U>& r) noexcept
+{
+    return (l.get() < r.get());
+}
+template<class T, class U> inline bool operator>=(const clonable_ptr<T>& l, const clonable_ptr<U>& r) noexcept
+{
+    return (l.get() >= r.get());
+}
+template<class T, class U> inline bool operator>(const clonable_ptr<T>& l, const clonable_ptr<U>& r) noexcept
+{
+    return (l.get() > r.get());
+}
+
+} // namespace Slic3r