Require -std=c++11 and use std::shared_ptr instead of SharedHandle

1 files changed, 20 insertions, 20 deletions

diff --git a/src/DHTAbstractNodeLookupTask.h b/src/DHTAbstractNodeLookupTask.h
index 75994923..0d7333f3 100644
--- a/src/DHTAbstractNodeLookupTask.h
+++ b/src/DHTAbstractNodeLookupTask.h
@@ -67,31 +67,31 @@ class DHTAbstractNodeLookupTask:public DHTAbstractTask {
 private:
   unsigned char targetID_[DHT_ID_LENGTH];
 
-  std::deque<SharedHandle<DHTNodeLookupEntry> > entries_;
+  std::deque<std::shared_ptr<DHTNodeLookupEntry> > entries_;
 
   size_t inFlightMessage_;
 
   template<typename Container>
   void toEntries
-  (Container& entries, const std::vector<SharedHandle<DHTNode> >& nodes) const
+  (Container& entries, const std::vector<std::shared_ptr<DHTNode> >& nodes) const
   {
-    for(std::vector<SharedHandle<DHTNode> >::const_iterator i = nodes.begin(),
+    for(std::vector<std::shared_ptr<DHTNode> >::const_iterator i = nodes.begin(),
           eoi = nodes.end(); i != eoi; ++i) {
-      SharedHandle<DHTNodeLookupEntry> e(new DHTNodeLookupEntry(*i));
+      std::shared_ptr<DHTNodeLookupEntry> e(new DHTNodeLookupEntry(*i));
       entries.push_back(e);
     }
   }
 
   void sendMessage()
   {
-    for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i =
+    for(std::deque<std::shared_ptr<DHTNodeLookupEntry> >::iterator i =
           entries_.begin(), eoi = entries_.end();
         i != eoi && inFlightMessage_ < ALPHA; ++i) {
       if((*i)->used == false) {
         ++inFlightMessage_;
         (*i)->used = true;
-        SharedHandle<DHTMessage> m = createMessage((*i)->node);
-        SharedHandle<DHTMessageCallback> callback(createCallback());
+        std::shared_ptr<DHTMessage> m = createMessage((*i)->node);
+        std::shared_ptr<DHTMessageCallback> callback(createCallback());
         getMessageDispatcher()->addMessageToQueue(m, callback);
       }
     }
@@ -122,13 +122,13 @@ protected:
     return targetID_;
   }
 
-  const std::deque<SharedHandle<DHTNodeLookupEntry> >& getEntries() const
+  const std::deque<std::shared_ptr<DHTNodeLookupEntry> >& getEntries() const
   {
     return entries_;
   }
 
   virtual void getNodesFromMessage
-  (std::vector<SharedHandle<DHTNode> >& nodes,
+  (std::vector<std::shared_ptr<DHTNode> >& nodes,
    const ResponseMessage* message) = 0;
 
   virtual void onReceivedInternal
@@ -138,10 +138,10 @@ protected:
 
   virtual void onFinish() {}
 
-  virtual SharedHandle<DHTMessage> createMessage
-  (const SharedHandle<DHTNode>& remoteNode) = 0;
+  virtual std::shared_ptr<DHTMessage> createMessage
+  (const std::shared_ptr<DHTNode>& remoteNode) = 0;
 
-  virtual SharedHandle<DHTMessageCallback> createCallback() = 0;
+  virtual std::shared_ptr<DHTMessageCallback> createCallback() = 0;
 public:
   DHTAbstractNodeLookupTask(const unsigned char* targetID):
     inFlightMessage_(0)
@@ -153,7 +153,7 @@ public:
 
   virtual void startup()
   {
-    std::vector<SharedHandle<DHTNode> > nodes;
+    std::vector<std::shared_ptr<DHTNode> > nodes;
     getRoutingTable()->getClosestKNodes(nodes, targetID_);
     entries_.clear();
     toEntries(entries_, nodes);
@@ -174,7 +174,7 @@ public:
   {
     --inFlightMessage_;
     // Replace old Node ID with new Node ID.
-    for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i =
+    for(std::deque<std::shared_ptr<DHTNodeLookupEntry> >::iterator i =
           entries_.begin(), eoi = entries_.end(); i != eoi; ++i) {
       if((*i)->node->getIPAddress() == message->getRemoteNode()->getIPAddress()
          && (*i)->node->getPort() == message->getRemoteNode()->getPort()) {
@@ -182,13 +182,13 @@ public:
       }
     }
     onReceivedInternal(message);
-    std::vector<SharedHandle<DHTNode> > nodes;
+    std::vector<std::shared_ptr<DHTNode> > nodes;
     getNodesFromMessage(nodes, message);
-    std::vector<SharedHandle<DHTNodeLookupEntry> > newEntries;
+    std::vector<std::shared_ptr<DHTNodeLookupEntry> > newEntries;
     toEntries(newEntries, nodes);
 
     size_t count = 0;
-    for(std::vector<SharedHandle<DHTNodeLookupEntry> >::const_iterator i =
+    for(std::vector<std::shared_ptr<DHTNodeLookupEntry> >::const_iterator i =
           newEntries.begin(), eoi = newEntries.end(); i != eoi; ++i) {
       if(memcmp(getLocalNode()->getID(), (*i)->node->getID(),
                 DHT_ID_LENGTH) != 0) {
@@ -205,7 +205,7 @@ public:
     std::stable_sort(entries_.begin(), entries_.end(), DHTIDCloser(targetID_));
     entries_.erase
       (std::unique(entries_.begin(), entries_.end(),
-                   DerefEqualTo<SharedHandle<DHTNodeLookupEntry> >()),
+                   DerefEqualTo<std::shared_ptr<DHTNodeLookupEntry> >()),
        entries_.end());
     A2_LOG_DEBUG(fmt("%lu node lookup entries are unique.",
                      static_cast<unsigned long>(entries_.size())));
@@ -215,12 +215,12 @@ public:
     sendMessageAndCheckFinish();
   }
 
-  void onTimeout(const SharedHandle<DHTNode>& node)
+  void onTimeout(const std::shared_ptr<DHTNode>& node)
   {
     A2_LOG_DEBUG(fmt("node lookup message timeout for node ID=%s",
                      util::toHex(node->getID(), DHT_ID_LENGTH).c_str()));
     --inFlightMessage_;
-    for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i =
+    for(std::deque<std::shared_ptr<DHTNodeLookupEntry> >::iterator i =
           entries_.begin(), eoi = entries_.end(); i != eoi; ++i) {
       if(*(*i)->node == *node) {
         entries_.erase(i);