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

1 files changed, 26 insertions, 26 deletions

diff --git a/src/DHTBucket.cc b/src/DHTBucket.cc
index a84e76a8..16292ea4 100644
--- a/src/DHTBucket.cc
+++ b/src/DHTBucket.cc
@@ -54,7 +54,7 @@ namespace aria2 {
 DHTBucket::DHTBucket
 (size_t prefixLength,
  const unsigned char* max, const unsigned char* min,
- const SharedHandle<DHTNode>& localNode)
+ const std::shared_ptr<DHTNode>& localNode)
   : prefixLength_(prefixLength),
     localNode_(localNode),
     lastUpdated_(global::wallclock())
@@ -63,7 +63,7 @@ DHTBucket::DHTBucket
   memcpy(min_, min, DHT_ID_LENGTH);
 }
 
-DHTBucket::DHTBucket(const SharedHandle<DHTNode>& localNode)
+DHTBucket::DHTBucket(const std::shared_ptr<DHTNode>& localNode)
   : prefixLength_(0),
     localNode_(localNode),
     lastUpdated_(global::wallclock())
@@ -85,7 +85,7 @@ void DHTBucket::getRandomNodeID(unsigned char* nodeID) const
   }
 }
 
-bool DHTBucket::isInRange(const SharedHandle<DHTNode>& node) const
+bool DHTBucket::isInRange(const std::shared_ptr<DHTNode>& node) const
 {
   return isInRange(node->getID(), max_, min_);
 }
@@ -107,10 +107,10 @@ bool DHTBucket::isInRange(const unsigned char* nodeID,
                                   &nodeID[0], &nodeID[DHT_ID_LENGTH]);
 }
 
-bool DHTBucket::addNode(const SharedHandle<DHTNode>& node)
+bool DHTBucket::addNode(const std::shared_ptr<DHTNode>& node)
 {
   notifyUpdate();
-  std::deque<SharedHandle<DHTNode> >::iterator itr =
+  std::deque<std::shared_ptr<DHTNode> >::iterator itr =
     std::find_if(nodes_.begin(), nodes_.end(), derefEqual(node));
   if(itr == nodes_.end()) {
     if(nodes_.size() < K) {
@@ -132,19 +132,19 @@ bool DHTBucket::addNode(const SharedHandle<DHTNode>& node)
   }
 }
 
-void DHTBucket::cacheNode(const SharedHandle<DHTNode>& node)
+void DHTBucket::cacheNode(const std::shared_ptr<DHTNode>& node)
 {
   // cachedNodes_ are sorted by last time seen
   cachedNodes_.push_front(node);
   if(cachedNodes_.size() > CACHE_SIZE) {
-    cachedNodes_.resize(CACHE_SIZE, SharedHandle<DHTNode>());
+    cachedNodes_.resize(CACHE_SIZE, std::shared_ptr<DHTNode>());
   }
 }
 
-void DHTBucket::dropNode(const SharedHandle<DHTNode>& node)
+void DHTBucket::dropNode(const std::shared_ptr<DHTNode>& node)
 {
   if(!cachedNodes_.empty()) {
-    std::deque<SharedHandle<DHTNode> >::iterator itr =
+    std::deque<std::shared_ptr<DHTNode> >::iterator itr =
       std::find_if(nodes_.begin(), nodes_.end(), derefEqual(node));
     if(itr != nodes_.end()) {
       nodes_.erase(itr);
@@ -154,9 +154,9 @@ void DHTBucket::dropNode(const SharedHandle<DHTNode>& node)
   }
 }
 
-void DHTBucket::moveToHead(const SharedHandle<DHTNode>& node)
+void DHTBucket::moveToHead(const std::shared_ptr<DHTNode>& node)
 {
-  std::deque<SharedHandle<DHTNode> >::iterator itr =
+  std::deque<std::shared_ptr<DHTNode> >::iterator itr =
     std::find_if(nodes_.begin(), nodes_.end(), derefEqual(node));
   if(itr != nodes_.end()) {
     nodes_.erase(itr);
@@ -164,9 +164,9 @@ void DHTBucket::moveToHead(const SharedHandle<DHTNode>& node)
   }
 }
 
-void DHTBucket::moveToTail(const SharedHandle<DHTNode>& node)
+void DHTBucket::moveToTail(const std::shared_ptr<DHTNode>& node)
 {
-  std::deque<SharedHandle<DHTNode> >::iterator itr =
+  std::deque<std::shared_ptr<DHTNode> >::iterator itr =
     std::find_if(nodes_.begin(), nodes_.end(), derefEqual(node));
   if(itr != nodes_.end()) {
     nodes_.erase(itr);
@@ -179,7 +179,7 @@ bool DHTBucket::splitAllowed() const
   return prefixLength_ < DHT_ID_LENGTH*8-1 && isInRange(localNode_);
 }
 
-SharedHandle<DHTBucket> DHTBucket::split()
+std::shared_ptr<DHTBucket> DHTBucket::split()
 {
   assert(splitAllowed());
 
@@ -192,11 +192,11 @@ SharedHandle<DHTBucket> DHTBucket::split()
   bitfield::flipBit(min_, DHT_ID_LENGTH, prefixLength_);
 
   ++prefixLength_;
-  SharedHandle<DHTBucket> rBucket(new DHTBucket(prefixLength_,
+  std::shared_ptr<DHTBucket> rBucket(new DHTBucket(prefixLength_,
                                                 rMax, rMin, localNode_));
 
-  std::deque<SharedHandle<DHTNode> > lNodes;
-  for(std::deque<SharedHandle<DHTNode> >::iterator i = nodes_.begin(),
+  std::deque<std::shared_ptr<DHTNode> > lNodes;
+  for(std::deque<std::shared_ptr<DHTNode> >::iterator i = nodes_.begin(),
         eoi = nodes_.end(); i != eoi; ++i) {
     if(rBucket->isInRange(*i)) {
       assert(rBucket->addNode(*i));
@@ -218,23 +218,23 @@ SharedHandle<DHTBucket> DHTBucket::split()
 }
 
 void DHTBucket::getGoodNodes
-(std::vector<SharedHandle<DHTNode> >& goodNodes) const
+(std::vector<std::shared_ptr<DHTNode> >& goodNodes) const
 {
   goodNodes.insert(goodNodes.end(), nodes_.begin(), nodes_.end());
   goodNodes.erase(std::remove_if(goodNodes.begin(), goodNodes.end(),
                                  mem_fun_sh(&DHTNode::isBad)), goodNodes.end());
 }
 
-SharedHandle<DHTNode> DHTBucket::getNode(const unsigned char* nodeID, const std::string& ipaddr, uint16_t port) const
+std::shared_ptr<DHTNode> DHTBucket::getNode(const unsigned char* nodeID, const std::string& ipaddr, uint16_t port) const
 {
-  SharedHandle<DHTNode> node(new DHTNode(nodeID));
+  std::shared_ptr<DHTNode> node(new DHTNode(nodeID));
   node->setIPAddress(ipaddr);
   node->setPort(port);
-  std::deque<SharedHandle<DHTNode> >::const_iterator itr =
+  std::deque<std::shared_ptr<DHTNode> >::const_iterator itr =
     std::find_if(nodes_.begin(), nodes_.end(), derefEqual(node));
   if(itr == nodes_.end() ||
      (*itr)->getIPAddress() != ipaddr || (*itr)->getPort() != port) {
-    return SharedHandle<DHTNode>();
+    return std::shared_ptr<DHTNode>();
   } else {
     return *itr;
   }
@@ -260,7 +260,7 @@ void DHTBucket::notifyUpdate()
 namespace {
 class FindQuestionableNode {
 public:
-  bool operator()(const SharedHandle<DHTNode>& node) const
+  bool operator()(const std::shared_ptr<DHTNode>& node) const
   {
     return node->isQuestionable();
   }
@@ -272,12 +272,12 @@ bool DHTBucket::containsQuestionableNode() const
   return std::find_if(nodes_.begin(), nodes_.end(), FindQuestionableNode()) != nodes_.end();
 }
 
-SharedHandle<DHTNode> DHTBucket::getLRUQuestionableNode() const
+std::shared_ptr<DHTNode> DHTBucket::getLRUQuestionableNode() const
 {
-  std::deque<SharedHandle<DHTNode> >::const_iterator i =
+  std::deque<std::shared_ptr<DHTNode> >::const_iterator i =
     std::find_if(nodes_.begin(), nodes_.end(), FindQuestionableNode());
   if(i == nodes_.end()) {
-    return SharedHandle<DHTNode>();
+    return std::shared_ptr<DHTNode>();
   } else {
     return *i;
   }