HintRouter: Use shared_ptr for Dcb-wrapper

The Dcb also accepts a null-value at creation, indicating an empty dcb.

server/modules/routing/hintrouter/dcb.cc

@@ -15,47 +15,34 @@
 #include <maxscale/atomic.h>
 #include <maxscale/service.h>
 
-
 Dcb::Dcb(DCB* pDcb)
-    : m_pDcb(pDcb)
-    , m_pRefs(NULL)
+    : m_sInner()
 {
-    try
+    // A null value for m_pDcb is allowed as a special non-existing dcb
+    if (pDcb)
     {
-        m_pRefs = new int (1);
-    }
-    catch (const std::exception&)
-    {
-        dcb_close(pDcb);
-        throw;
+        try
+        {
+            m_sInner = SDCB(pDcb, Dcb::deleter);
+        }
+        catch (const std::exception&)
+        {
+            dcb_close(pDcb);
+            throw;
+        }
     }
 }
 
-Dcb::Dcb(const Dcb& rhs)
-    : m_pDcb(rhs.m_pDcb)
-    , m_pRefs(rhs.m_pRefs)
+void Dcb::deleter(DCB* dcb)
 {
-    ++(*m_pRefs);
-}
-
-Dcb& Dcb::operator = (Dcb rhs)
-{
-    swap(rhs);
-    return *this;
-}
-
-void Dcb::dec()
-{
-    ss_dassert(*m_pRefs > 0);
-
-    if (--(*m_pRefs) == 0)
+    if (dcb)
     {
         HR_DEBUG("CLOSING dcb");
         // TODO: You should not need to manually adjust any
         // TODO: connections number, dcb_close should handle that.
-        SERVER_REF* pSref = m_pDcb->service->dbref;
+        SERVER_REF* pSref = dcb->service->dbref;
 
-        while (pSref && (pSref->server != m_pDcb->server))
+        while (pSref && (pSref->server != dcb->server))
         {
             pSref = pSref->next;
         }
@@ -64,9 +51,6 @@ void Dcb::dec()
         {
             atomic_add(&pSref->connections, -1);
         }
-
-        dcb_close(m_pDcb);
-
-        delete m_pRefs;
+        dcb_close(dcb);
     }
 }

server/modules/routing/hintrouter/dcb.hh

@@ -13,53 +13,46 @@
  */
 
 #include "hintrouterdefs.hh"
-#include <algorithm>
+
+#include <tr1/memory>
+
 #include <maxscale/dcb.h>
 
 class Dcb
 {
 public:
-    explicit Dcb(DCB* pDcb);
-    Dcb(const Dcb& rhs);
-    ~Dcb()
-    {
-        dec();
-    }
+    typedef std::tr1::shared_ptr<DCB> SDCB;
 
-    Dcb& operator = (Dcb rhs);
+    explicit Dcb(DCB* pDcb);
+
+    Dcb(const Dcb& rhs)
+        : m_sInner(rhs.m_sInner)
+    {};
+
+    Dcb& operator = (Dcb rhs)
+    {
+        m_sInner.swap(rhs.m_sInner);
+        return *this;
+    }
 
     struct server* server() const
     {
-        return m_pDcb->server;
+        return (this->m_sInner.get()) ? m_sInner.get()->server : NULL;
     }
 
     DCB* get() const
     {
-        return m_pDcb;
+        return m_sInner.get();
     }
 
-    bool write(GWBUF* pPacket)
+    bool write(GWBUF* pPacket) const
     {
-        ss_dassert(m_pDcb);
-        return m_pDcb->func.write(m_pDcb, pPacket) == 1;
+        ss_dassert(m_sInner.get());
+        return m_sInner.get()->func.write(m_sInner.get(), pPacket) == 1;
     }
 
 private:
-    void inc()
-    {
-        ++(*m_pRefs);
-    }
-
-    void dec();
-
-    void swap(Dcb& rhs)
-    {
-        std::swap(m_pDcb, rhs.m_pDcb);
-        std::swap(m_pRefs, rhs.m_pRefs);
-    }
-
-private:
-    DCB* m_pDcb;
-    int* m_pRefs;
+    static void deleter(DCB* dcb);
+    SDCB m_sInner;
 };