2008-12-14 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>

Use BDE instead of Dictionary/List/Data.
	* src/DHTAbstractMessage.cc
	* src/DHTAbstractMessage.h
	* src/DHTAnnouncePeerMessage.cc
	* src/DHTAnnouncePeerMessage.h
	* src/DHTAnnouncePeerReplyMessage.cc
	* src/DHTAnnouncePeerReplyMessage.h
	* src/DHTFindNodeMessage.cc
	* src/DHTFindNodeMessage.h
	* src/DHTFindNodeReplyMessage.cc
	* src/DHTFindNodeReplyMessage.h
	* src/DHTGetPeersMessage.cc
	* src/DHTGetPeersMessage.h
	* src/DHTGetPeersReplyMessage.cc
	* src/DHTGetPeersReplyMessage.h
	* src/DHTMessageFactory.h
	* src/DHTMessageFactoryImpl.cc
	* src/DHTMessageFactoryImpl.h
	* src/DHTMessageReceiver.cc
	* src/DHTMessageTracker.cc
	* src/DHTMessageTracker.h
	* src/DHTPingMessage.cc
	* src/DHTPingMessage.h
	* src/DHTPingReplyMessage.cc
	* src/DHTPingReplyMessage.h
	* src/DHTQueryMessage.cc
	* src/DHTQueryMessage.h
	* src/DHTResponseMessage.cc
	* src/DHTResponseMessage.h
	* test/DHTAnnouncePeerMessageTest.cc
	* test/DHTAnnouncePeerReplyMessageTest.cc
	* test/DHTFindNodeMessageTest.cc
	* test/DHTFindNodeReplyMessageTest.cc
	* test/DHTGetPeersMessageTest.cc
	* test/DHTGetPeersReplyMessageTest.cc
	* test/DHTMessageFactoryImplTest.cc
	* test/DHTMessageTrackerTest.cc
	* test/DHTPingMessageTest.cc
	* test/DHTPingReplyMessageTest.cc
	* test/MockDHTMessageFactory.h

ChangeLog

@@ -1,3 +1,46 @@
+2008-12-14  Tatsuhiro Tsujikawa  <t-tujikawa@users.sourceforge.net>
+
+	Use BDE instead of Dictionary/List/Data.
+	* src/DHTAbstractMessage.cc
+	* src/DHTAbstractMessage.h
+	* src/DHTAnnouncePeerMessage.cc
+	* src/DHTAnnouncePeerMessage.h
+	* src/DHTAnnouncePeerReplyMessage.cc
+	* src/DHTAnnouncePeerReplyMessage.h
+	* src/DHTFindNodeMessage.cc
+	* src/DHTFindNodeMessage.h
+	* src/DHTFindNodeReplyMessage.cc
+	* src/DHTFindNodeReplyMessage.h
+	* src/DHTGetPeersMessage.cc
+	* src/DHTGetPeersMessage.h
+	* src/DHTGetPeersReplyMessage.cc
+	* src/DHTGetPeersReplyMessage.h
+	* src/DHTMessageFactory.h
+	* src/DHTMessageFactoryImpl.cc
+	* src/DHTMessageFactoryImpl.h
+	* src/DHTMessageReceiver.cc
+	* src/DHTMessageTracker.cc
+	* src/DHTMessageTracker.h
+	* src/DHTPingMessage.cc
+	* src/DHTPingMessage.h
+	* src/DHTPingReplyMessage.cc
+	* src/DHTPingReplyMessage.h
+	* src/DHTQueryMessage.cc
+	* src/DHTQueryMessage.h
+	* src/DHTResponseMessage.cc
+	* src/DHTResponseMessage.h
+	* test/DHTAnnouncePeerMessageTest.cc
+	* test/DHTAnnouncePeerReplyMessageTest.cc
+	* test/DHTFindNodeMessageTest.cc
+	* test/DHTFindNodeReplyMessageTest.cc
+	* test/DHTGetPeersMessageTest.cc
+	* test/DHTGetPeersReplyMessageTest.cc
+	* test/DHTMessageFactoryImplTest.cc
+	* test/DHTMessageTrackerTest.cc
+	* test/DHTPingMessageTest.cc
+	* test/DHTPingReplyMessageTest.cc
+	* test/MockDHTMessageFactory.h
+
 2008-12-14  Tatsuhiro Tsujikawa  <t-tujikawa@users.sourceforge.net>
 
 	Added tests the case where length < 0 is specified.

src/DHTAbstractMessage.cc

@@ -37,14 +37,12 @@
 #include <cassert>
 
 #include "DHTNode.h"
-#include "BencodeVisitor.h"
 #include "DHTConnection.h"
-#include "Dictionary.h"
-#include "Data.h"
 #include "DHTMessageDispatcher.h"
 #include "DHTMessageFactory.h"
 #include "DHTRoutingTable.h"
 #include "DHTMessageCallback.h"
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -57,14 +55,11 @@ DHTAbstractMessage::~DHTAbstractMessage() {}
 
 std::string DHTAbstractMessage::getBencodedMessage()
 {
-  SharedHandle<Dictionary> msg(new Dictionary());
+  bencode::BDE msgDict = bencode::BDE::dict();
-  msg->put(DHTMessage::T, new Data(_transactionID));
+  msgDict[T] = _transactionID;
-  msg->put(DHTMessage::Y, new Data(getType()));
+  msgDict[Y] = getType();
-  fillMessage(msg.get());
+  fillMessage(msgDict);
-  
+  return bencode::encode(msgDict);
-  BencodeVisitor v;
-  msg->accept(&v);
-  return v.getBencodedData();
 }
 
 bool DHTAbstractMessage::send()

src/DHTAbstractMessage.h

@@ -40,7 +40,9 @@
 
 namespace aria2 {
 
-class Dictionary;
+namespace bencode {
+class BDE;
+} // namespace bencode
 class DHTConnection;
 class DHTMessageDispatcher;
 class DHTMessageFactory;
@@ -66,7 +68,7 @@ public:
 
   virtual std::string getType() const = 0;
 
-  virtual void fillMessage(Dictionary* message) = 0;
+  virtual void fillMessage(bencode::BDE& msgDict) = 0;
 
   std::string getBencodedMessage();
 

src/DHTAnnouncePeerMessage.cc

@@ -33,9 +33,10 @@
  */
 /* copyright --> */
 #include "DHTAnnouncePeerMessage.h"
+
+#include <cstring>
+
 #include "DHTNode.h"
-#include "Data.h"
-#include "Dictionary.h"
 #include "DHTRoutingTable.h"
 #include "DHTMessageFactory.h"
 #include "DHTMessageDispatcher.h"
@@ -46,7 +47,7 @@
 #include "DlAbortEx.h"
 #include "BtConstants.h"
 #include "StringFormat.h"
-#include <cstring>
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -83,17 +84,14 @@ void DHTAnnouncePeerMessage::doReceivedAction()
   _dispatcher->addMessageToQueue(reply);
 }
 
-Dictionary* DHTAnnouncePeerMessage::getArgument()
+bencode::BDE DHTAnnouncePeerMessage::getArgument()
 {
-  Dictionary* a = new Dictionary();
+  bencode::BDE aDict = bencode::BDE::dict();
-  a->put(DHTMessage::ID, new Data(reinterpret_cast<const char*>(_localNode->getID()),
+  aDict[DHTMessage::ID] = bencode::BDE(_localNode->getID(), DHT_ID_LENGTH);
-			DHT_ID_LENGTH));
+  aDict[INFO_HASH] = bencode::BDE(_infoHash, DHT_ID_LENGTH);
-  a->put(INFO_HASH, new Data(reinterpret_cast<const char*>(_infoHash),
+  aDict[PORT] = _tcpPort;
-			       DHT_ID_LENGTH));
+  aDict[TOKEN] = _token;
-  a->put(PORT, new Data(Util::uitos(_tcpPort), true));
+  return aDict;
-  a->put(TOKEN, new Data(_token));
-  
-  return a;
 }
 
 std::string DHTAnnouncePeerMessage::getMessageType() const

src/DHTAnnouncePeerMessage.h

@@ -69,7 +69,7 @@ public:
 
   virtual void doReceivedAction();
 
-  virtual Dictionary* getArgument();
+  virtual bencode::BDE getArgument();
   
   virtual std::string getMessageType() const;
 

src/DHTAnnouncePeerReplyMessage.cc

@@ -34,8 +34,7 @@
 /* copyright --> */
 #include "DHTAnnouncePeerReplyMessage.h"
 #include "DHTNode.h"
-#include "Dictionary.h"
+#include "bencode.h"
-#include "Data.h"
 
 namespace aria2 {
 
@@ -50,11 +49,11 @@ DHTAnnouncePeerReplyMessage::~DHTAnnouncePeerReplyMessage() {}
 
 void DHTAnnouncePeerReplyMessage::doReceivedAction() {}
 
-Dictionary* DHTAnnouncePeerReplyMessage::getResponse()
+bencode::BDE DHTAnnouncePeerReplyMessage::getResponse()
 {
-  Dictionary* r = new Dictionary();
+  bencode::BDE rDict = bencode::BDE::dict();
-  r->put(DHTMessage::ID, new Data(_localNode->getID(), DHT_ID_LENGTH));
+  rDict[DHTMessage::ID] = bencode::BDE(_localNode->getID(), DHT_ID_LENGTH);
-  return r;
+  return rDict;
 }
 
 std::string DHTAnnouncePeerReplyMessage::getMessageType() const

src/DHTAnnouncePeerReplyMessage.h

@@ -49,7 +49,7 @@ public:
 
   virtual void doReceivedAction();
 
-  virtual Dictionary* getResponse();
+  virtual bencode::BDE getResponse();
 
   virtual std::string getMessageType() const;
 

src/DHTFindNodeMessage.cc

@@ -33,15 +33,16 @@
  */
 /* copyright --> */
 #include "DHTFindNodeMessage.h"
+
+#include <cstring>
+
 #include "DHTNode.h"
-#include "Data.h"
-#include "Dictionary.h"
 #include "DHTRoutingTable.h"
 #include "DHTMessageFactory.h"
 #include "DHTMessageDispatcher.h"
 #include "DHTMessageCallback.h"
 #include "Util.h"
-#include <cstring>
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -69,14 +70,12 @@ void DHTFindNodeMessage::doReceivedAction()
   _dispatcher->addMessageToQueue(reply);
 }
 
-Dictionary* DHTFindNodeMessage::getArgument()
+bencode::BDE DHTFindNodeMessage::getArgument()
 {
-  Dictionary* a = new Dictionary();
+  bencode::BDE aDict = bencode::BDE::dict();
-  a->put(DHTMessage::ID, new Data(reinterpret_cast<const char*>(_localNode->getID()),
+  aDict[DHTMessage::ID] = bencode::BDE(_localNode->getID(), DHT_ID_LENGTH);
-			DHT_ID_LENGTH));
+  aDict[TARGET_NODE] = bencode::BDE(_targetNodeID, DHT_ID_LENGTH);
-  a->put(TARGET_NODE, new Data(reinterpret_cast<const char*>(_targetNodeID),
+  return aDict;
-			    DHT_ID_LENGTH));
-  return a;
 }
 
 std::string DHTFindNodeMessage::getMessageType() const

src/DHTFindNodeMessage.h

@@ -55,7 +55,7 @@ public:
 
   virtual void doReceivedAction();
 
-  virtual Dictionary* getArgument();
+  virtual bencode::BDE getArgument();
   
   virtual std::string getMessageType() const;
 

src/DHTFindNodeReplyMessage.cc

@@ -33,17 +33,18 @@
  */
 /* copyright --> */
 #include "DHTFindNodeReplyMessage.h"
+
+#include <cstring>
+
 #include "DHTNode.h"
 #include "DHTBucket.h"
-#include "Data.h"
-#include "Dictionary.h"
 #include "DHTRoutingTable.h"
 #include "DHTMessageFactory.h"
 #include "DHTMessageDispatcher.h"
 #include "DHTMessageCallback.h"
 #include "PeerMessageUtil.h"
 #include "Util.h"
-#include <cstring>
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -67,22 +68,25 @@ void DHTFindNodeReplyMessage::doReceivedAction()
   }
 }
 
-Dictionary* DHTFindNodeReplyMessage::getResponse()
+bencode::BDE DHTFindNodeReplyMessage::getResponse()
 {
-  Dictionary* a = new Dictionary();
+  bencode::BDE aDict = bencode::BDE::dict();
-  a->put(DHTMessage::ID, new Data(_localNode->getID(), DHT_ID_LENGTH));
+  aDict[DHTMessage::ID] = bencode::BDE(_localNode->getID(), DHT_ID_LENGTH);
   size_t offset = 0;
   unsigned char buffer[DHTBucket::K*26];
   // TODO if _closestKNodes.size() > DHTBucket::K ??
-  for(std::deque<SharedHandle<DHTNode> >::const_iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) {
+  for(std::deque<SharedHandle<DHTNode> >::const_iterator i =
+	_closestKNodes.begin();
+      i != _closestKNodes.end() && offset < DHTBucket::K*26; ++i) {
     SharedHandle<DHTNode> node = *i;
     memcpy(buffer+offset, node->getID(), DHT_ID_LENGTH);
-    if(PeerMessageUtil::createcompact(buffer+20+offset, node->getIPAddress(), node->getPort())) {
+    if(PeerMessageUtil::createcompact(buffer+20+offset, node->getIPAddress(),
+				      node->getPort())) {
       offset += 26;
     }
   }
-  a->put(NODES, new Data(buffer, offset));
+  aDict[NODES] = bencode::BDE(buffer, offset);
-  return a;
+  return aDict;
 }
 
 std::string DHTFindNodeReplyMessage::getMessageType() const

src/DHTFindNodeReplyMessage.h

@@ -54,7 +54,7 @@ public:
 
   virtual void doReceivedAction();
 
-  virtual Dictionary* getResponse();
+  virtual bencode::BDE getResponse();
   
   virtual std::string getMessageType() const;
 

src/DHTGetPeersMessage.cc

@@ -33,9 +33,10 @@
  */
 /* copyright --> */
 #include "DHTGetPeersMessage.h"
+
+#include <cstring>
+
 #include "DHTNode.h"
-#include "Data.h"
-#include "Dictionary.h"
 #include "DHTRoutingTable.h"
 #include "DHTMessageFactory.h"
 #include "DHTMessageDispatcher.h"
@@ -45,7 +46,7 @@
 #include "Peer.h"
 #include "DHTTokenTracker.h"
 #include "Util.h"
-#include <cstring>
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -87,12 +88,12 @@ void DHTGetPeersMessage::doReceivedAction()
   _dispatcher->addMessageToQueue(reply);
 }
 
-Dictionary* DHTGetPeersMessage::getArgument()
+bencode::BDE DHTGetPeersMessage::getArgument()
 {
-  Dictionary* a = new Dictionary();
+  bencode::BDE aDict = bencode::BDE::dict();
-  a->put(DHTMessage::ID, new Data(_localNode->getID(), DHT_ID_LENGTH));
+  aDict[DHTMessage::ID] = bencode::BDE(_localNode->getID(), DHT_ID_LENGTH);
-  a->put(INFO_HASH, new Data(_infoHash, DHT_ID_LENGTH));
+  aDict[INFO_HASH] = bencode::BDE(_infoHash, DHT_ID_LENGTH);
-  return a;
+  return aDict;
 }
 
 std::string DHTGetPeersMessage::getMessageType() const

src/DHTGetPeersMessage.h

@@ -63,7 +63,7 @@ public:
 
   virtual void doReceivedAction();
 
-  virtual Dictionary* getArgument();
+  virtual bencode::BDE getArgument();
   
   virtual std::string getMessageType() const;
 

src/DHTGetPeersReplyMessage.cc

@@ -33,11 +33,11 @@
  */
 /* copyright --> */
 #include "DHTGetPeersReplyMessage.h"
+
+#include <cstring>
+
 #include "DHTNode.h"
 #include "DHTBucket.h"
-#include "Data.h"
-#include "Dictionary.h"
-#include "List.h"
 #include "DHTRoutingTable.h"
 #include "DHTMessageFactory.h"
 #include "DHTMessageDispatcher.h"
@@ -46,7 +46,7 @@
 #include "Peer.h"
 #include "DHTUtil.h"
 #include "Util.h"
-#include <cstring>
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -72,34 +72,37 @@ void DHTGetPeersReplyMessage::doReceivedAction()
   // Returned peers and nodes are handled in DHTPeerLookupTask.
 }
 
-Dictionary* DHTGetPeersReplyMessage::getResponse()
+bencode::BDE DHTGetPeersReplyMessage::getResponse()
 {
-  Dictionary* r = new Dictionary();
+  bencode::BDE rDict = bencode::BDE::dict();
-  r->put(DHTMessage::ID, new Data(_localNode->getID(), DHT_ID_LENGTH));
+  rDict[DHTMessage::ID] = bencode::BDE(_localNode->getID(), DHT_ID_LENGTH);
-  r->put(TOKEN, new Data(_token));
+  rDict[TOKEN] = _token;
-  if(_values.size()) {
+  if(_values.empty()) {
-    List* valuesList = new List();
-    r->put(VALUES, valuesList);
-    for(std::deque<SharedHandle<Peer> >::const_iterator i = _values.begin(); i != _values.end(); ++i) {
-      const SharedHandle<Peer>& peer = *i;
-      unsigned char buffer[6];
-      if(PeerMessageUtil::createcompact(buffer, peer->ipaddr, peer->port)) {
-	valuesList->add(new Data(buffer, sizeof(buffer)));
-      }
-    }
-  } else {
     size_t offset = 0;
     unsigned char buffer[DHTBucket::K*26];
-    for(std::deque<SharedHandle<DHTNode> >::const_iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) {
+    for(std::deque<SharedHandle<DHTNode> >::const_iterator i =
+	  _closestKNodes.begin();
+	i != _closestKNodes.end() && offset < DHTBucket::K*26; ++i) {
       SharedHandle<DHTNode> node = *i;
       memcpy(buffer+offset, node->getID(), DHT_ID_LENGTH);
       if(PeerMessageUtil::createcompact(buffer+20+offset, node->getIPAddress(), node->getPort())) {
 	offset += 26;
       }
     }
-    r->put(NODES, new Data(buffer, offset));
+    rDict[NODES] = bencode::BDE(buffer, offset);
+  } else {
+    bencode::BDE valuesList = bencode::BDE::list();
+    for(std::deque<SharedHandle<Peer> >::const_iterator i = _values.begin();
+	i != _values.end(); ++i) {
+      const SharedHandle<Peer>& peer = *i;
+      unsigned char buffer[6];
+      if(PeerMessageUtil::createcompact(buffer, peer->ipaddr, peer->port)) {
+	valuesList << bencode::BDE(buffer, sizeof(buffer));
       }
-  return r;
+    }
+    rDict[VALUES] = valuesList;
+  }
+  return rDict;  
 }
 
 std::string DHTGetPeersReplyMessage::getMessageType() const

src/DHTGetPeersReplyMessage.h

@@ -36,9 +36,11 @@
 #define _D_DHT_GET_PEERS_REPLY_MESSAGE_H_
 
 #include "DHTResponseMessage.h"
-#include "DHTConstants.h"
+
 #include <deque>
 
+#include "DHTConstants.h"
+
 namespace aria2 {
 
 class Peer;
@@ -62,7 +64,7 @@ public:
 
   virtual void doReceivedAction();
 
-  virtual Dictionary* getResponse();
+  virtual bencode::BDE getResponse();
 
   virtual std::string getMessageType() const;
 

src/DHTMessageFactory.h

@@ -48,19 +48,21 @@ namespace aria2 {
 class DHTMessage;
 class DHTNode;
 class Peer;
-class Dictionary;
+namespace bencode {
+class BDE;
+} // namespace bencode
 
 class DHTMessageFactory {
 public:
   virtual ~DHTMessageFactory() {}
 
   virtual SharedHandle<DHTMessage>
-  createQueryMessage(const Dictionary* d,
+  createQueryMessage(const bencode::BDE& dict,
 		     const std::string& ipaddr, uint16_t port) = 0;
 
   virtual SharedHandle<DHTMessage>
   createResponseMessage(const std::string& messageType,
-			const Dictionary* d,
+			const bencode::BDE& dict,
 			const std::string& ipaddr, uint16_t port) = 0;
 
   virtual SharedHandle<DHTMessage>

src/DHTMessageFactoryImpl.cc

@@ -39,9 +39,6 @@
 
 #include "LogFactory.h"
 #include "DlAbortEx.h"
-#include "Data.h"
-#include "Dictionary.h"
-#include "List.h"
 #include "DHTNode.h"
 #include "DHTRoutingTable.h"
 #include "DHTPingMessage.h"
@@ -64,6 +61,7 @@
 #include "Peer.h"
 #include "Logger.h"
 #include "StringFormat.h"
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -84,10 +82,23 @@ DHTMessageFactoryImpl::getRemoteNode(const unsigned char* id, const std::string&
   return node;
 }
 
-static const Dictionary* getDictionary(const Dictionary* d, const std::string& key)
+static const bencode::BDE& getDictionary(const bencode::BDE& dict,
+					 const std::string& key)
 {
-  const Dictionary* c = dynamic_cast<const Dictionary*>(d->get(key));
+  const bencode::BDE& d = dict[key];
-  if(c) {
+  if(d.isDict()) {
+    return d;
+  } else {
+    throw DlAbortEx
+      (StringFormat("Malformed DHT message. Missing %s", key.c_str()).str());
+  }
+}
+
+static const bencode::BDE& getString(const bencode::BDE& dict,
+				     const std::string& key)
+{
+  const bencode::BDE& c = dict[key];
+  if(c.isString()) {
     return c;
   } else {
     throw DlAbortEx
@@ -95,10 +106,11 @@ static const Dictionary* getDictionary(const Dictionary* d, const std::string& k
   }
 }
 
-static const Data* getData(const Dictionary* d, const std::string& key)
+static const bencode::BDE& getInteger(const bencode::BDE& dict,
+				      const std::string& key)
 {
-  const Data* c = dynamic_cast<const Data*>(d->get(key));
+  const bencode::BDE& c = dict[key];
-  if(c) {
+  if(c.isInteger()) {
     return c;
   } else {
     throw DlAbortEx
@@ -106,22 +118,35 @@ static const Data* getData(const Dictionary* d, const std::string& key)
   }
 }
 
-static const Data* getData(const List* l, size_t index)
+static const bencode::BDE& getString(const bencode::BDE& list, size_t index)
 {
-  const Data* c = dynamic_cast<const Data*>(l->getList()[index]);
+  const bencode::BDE& c = list[index];
-  if(c) {
+  if(c.isString()) {
     return c;
   } else {
     throw DlAbortEx
-      (StringFormat("Malformed DHT message. element[%u] is not Data.",
+      (StringFormat("Malformed DHT message. element[%u] is not String.",
 		    index).str());
   }
 }
 
-static const List* getList(const Dictionary* d, const std::string& key)
+static const bencode::BDE& getInteger(const bencode::BDE& list, size_t index)
 {
-  const List* l = dynamic_cast<const List*>(d->get(key));
+  const bencode::BDE& c = list[index];
-  if(l) {
+  if(c.isInteger()) {
+    return c;
+  } else {
+    throw DlAbortEx
+      (StringFormat("Malformed DHT message. element[%u] is not Integer.",
+		    index).str());
+  }
+}
+
+static const bencode::BDE& getList(const bencode::BDE& dict,
+				   const std::string& key)
+{
+  const bencode::BDE& l = dict[key];
+  if(l.isList()) {
     return l;
   } else {
     throw DlAbortEx
@@ -129,121 +154,121 @@ static const List* getList(const Dictionary* d, const std::string& key)
   }
 }
 
-void DHTMessageFactoryImpl::validateID(const Data* id) const
+void DHTMessageFactoryImpl::validateID(const bencode::BDE& id) const
 {
-  if(id->getLen() != DHT_ID_LENGTH) {
+  if(id.s().size() != DHT_ID_LENGTH) {
     throw DlAbortEx
-      (StringFormat("Malformed DHT message. Invalid ID length. Expected:%d, Actual:%d", DHT_ID_LENGTH, id->getLen()).str());
+      (StringFormat("Malformed DHT message. Invalid ID length."
+		    " Expected:%d, Actual:%d",
+		    DHT_ID_LENGTH, id.s().size()).str());
   }
 }
 
-void DHTMessageFactoryImpl::validatePort(const Data* i) const
+void DHTMessageFactoryImpl::validatePort(const bencode::BDE& i) const
 {
-  if(!i->isNumber()) {
+  bencode::BDE::Integer port = i.i();
+  if(!(0 < port && port < UINT16_MAX)) {
     throw DlAbortEx
       (StringFormat("Malformed DHT message. Invalid port=%s",
-		    Util::toHex(i->toString()).c_str()).str());
+		    Util::itos(port).c_str()).str());
-  }
-  uint32_t port = i->toInt();
-  if(UINT16_MAX < port) {
-    throw DlAbortEx
-      (StringFormat("Malformed DHT message. Invalid port=%u", port).str());
   }
 }
 
-SharedHandle<DHTMessage> DHTMessageFactoryImpl::createQueryMessage(const Dictionary* d,
+SharedHandle<DHTMessage> DHTMessageFactoryImpl::createQueryMessage
+(const bencode::BDE& dict,
  const std::string& ipaddr,
  uint16_t port)
 {
-  const Data* q = getData(d, DHTQueryMessage::Q);
+  const bencode::BDE& messageType = getString(dict, DHTQueryMessage::Q);
-  const Data* t = getData(d, DHTMessage::T);
+  const bencode::BDE& transactionID = getString(dict, DHTMessage::T);
-  const Data* y = getData(d, DHTMessage::Y);
+  const bencode::BDE& y = getString(dict, DHTMessage::Y);
-  const Dictionary* a = getDictionary(d, DHTQueryMessage::A);
+  const bencode::BDE& aDict = getDictionary(dict, DHTQueryMessage::A);
-  if(y->toString() != DHTQueryMessage::Q) {
+  if(y.s() != DHTQueryMessage::Q) {
     throw DlAbortEx("Malformed DHT message. y != q");
   }
-  const Data* id = getData(getDictionary(d, DHTQueryMessage::A), DHTMessage::ID);
+  const bencode::BDE& id = getString(aDict, DHTMessage::ID);
   validateID(id);
-  SharedHandle<DHTNode> remoteNode = getRemoteNode(id->getData(), ipaddr, port);
+  SharedHandle<DHTNode> remoteNode = getRemoteNode(id.uc(), ipaddr, port);
-  std::string messageType = q->toString();
+  if(messageType.s() == DHTPingMessage::PING) {
-  std::string transactionID = t->toString();
+    return createPingMessage(remoteNode, transactionID.s());
-  if(messageType == DHTPingMessage::PING) {
+  } else if(messageType.s() == DHTFindNodeMessage::FIND_NODE) {
-    return createPingMessage(remoteNode, transactionID);
+    const bencode::BDE& targetNodeID =
-  } else if(messageType == DHTFindNodeMessage::FIND_NODE) {
+      getString(aDict, DHTFindNodeMessage::TARGET_NODE);
-    const Data* targetNodeID = getData(a, DHTFindNodeMessage::TARGET_NODE);
     validateID(targetNodeID);
-    return createFindNodeMessage(remoteNode, targetNodeID->getData(),
+    return createFindNodeMessage(remoteNode, targetNodeID.uc(),
-				 transactionID);
+				 transactionID.s());
-  } else if(messageType == DHTGetPeersMessage::GET_PEERS) {
+  } else if(messageType.s() == DHTGetPeersMessage::GET_PEERS) {
-    const Data* infoHash = getData(a, DHTGetPeersMessage::INFO_HASH);
+    const bencode::BDE& infoHash = 
+      getString(aDict, DHTGetPeersMessage::INFO_HASH);
     validateID(infoHash);
     return createGetPeersMessage(remoteNode,
-				 infoHash->getData(), transactionID);
+				 infoHash.uc(), transactionID.s());
-  } else if(messageType == DHTAnnouncePeerMessage::ANNOUNCE_PEER) {
+  } else if(messageType.s() == DHTAnnouncePeerMessage::ANNOUNCE_PEER) {
-    const Data* infoHash = getData(a, DHTAnnouncePeerMessage::INFO_HASH);
+    const bencode::BDE& infoHash =
+      getString(aDict, DHTAnnouncePeerMessage::INFO_HASH);
     validateID(infoHash);
-    const Data* port = getData(a, DHTAnnouncePeerMessage::PORT);
+    const bencode::BDE& port = getInteger(aDict, DHTAnnouncePeerMessage::PORT);
     validatePort(port);
-    const Data* token = getData(a, DHTAnnouncePeerMessage::TOKEN);
+    const bencode::BDE& token = getString(aDict, DHTAnnouncePeerMessage::TOKEN);
-    return createAnnouncePeerMessage(remoteNode, infoHash->getData(),
+    return createAnnouncePeerMessage(remoteNode, infoHash.uc(),
-				     static_cast<uint16_t>(port->toInt()),
+				     static_cast<uint16_t>(port.i()),
-				     token->toString(), transactionID);
+				     token.s(), transactionID.s());
   } else {
     throw DlAbortEx
-      (StringFormat("Unsupported message type: %s", messageType.c_str()).str());
+      (StringFormat("Unsupported message type: %s",
+		    messageType.s().c_str()).str());
   }
 }
 
 SharedHandle<DHTMessage>
 DHTMessageFactoryImpl::createResponseMessage(const std::string& messageType,
-					     const Dictionary* d,
+					     const bencode::BDE& dict,
 					     const std::string& ipaddr,
 					     uint16_t port)
 {
-  const Data* t = getData(d, DHTMessage::T);
+  const bencode::BDE& transactionID = getString(dict, DHTMessage::T);
-  const Data* y = getData(d, DHTMessage::Y);
+  const bencode::BDE& y = getString(dict, DHTMessage::Y);
-  if(y->toString() == DHTUnknownMessage::E) {
+  if(y.s() == DHTUnknownMessage::E) {
     // for now, just report error message arrived and throw exception.
-    const List* e = getList(d, DHTUnknownMessage::E);
+    const bencode::BDE& e = getList(dict, DHTUnknownMessage::E);
-    if(e->getList().size() == 2) {
+    if(e.size() == 2) {
       _logger->info("Received Error DHT message. code=%s, msg=%s",
-		    Util::urlencode(getData(e, 0)->toString()).c_str(),
+		    Util::itos(getInteger(e, 0).i()).c_str(),
-		    Util::urlencode(getData(e, 1)->toString()).c_str());
+		    Util::urlencode(getString(e, 1).s()).c_str());
     } else {
       _logger->debug("e doesn't have 2 elements.");
     }
     throw DlAbortEx("Received Error DHT message.");
-  } else if(y->toString() != DHTResponseMessage::R) {
+  } else if(y.s() != DHTResponseMessage::R) {
     throw DlAbortEx
       (StringFormat("Malformed DHT message. y != r: y=%s",
-		    Util::urlencode(y->toString()).c_str()).str());
+		    Util::urlencode(y.s()).c_str()).str());
   }
-  const Dictionary* r = getDictionary(d, DHTResponseMessage::R);
+  const bencode::BDE& rDict = getDictionary(dict, DHTResponseMessage::R);
-  const Data* id = getData(r, DHTMessage::ID);
+  const bencode::BDE& id = getString(rDict, DHTMessage::ID);
   validateID(id);
-  SharedHandle<DHTNode> remoteNode = getRemoteNode(id->getData(), ipaddr, port);
+  SharedHandle<DHTNode> remoteNode = getRemoteNode(id.uc(), ipaddr, port);
 
-  std::string transactionID = t->toString();
   if(messageType == DHTPingReplyMessage::PING) {
-    return createPingReplyMessage(remoteNode,
+    return createPingReplyMessage(remoteNode, id.uc(), transactionID.s());
-				  id->getData(), transactionID);
   } else if(messageType == DHTFindNodeReplyMessage::FIND_NODE) {
-    return createFindNodeReplyMessage(remoteNode, d, transactionID);
+    return createFindNodeReplyMessage(remoteNode, dict, transactionID.s());
   } else if(messageType == DHTGetPeersReplyMessage::GET_PEERS) {
-    const List* values =
+    const bencode::BDE& valuesList = rDict[DHTGetPeersReplyMessage::VALUES];
-      dynamic_cast<const List*>(r->get(DHTGetPeersReplyMessage::VALUES));
+    if(valuesList.isList()) {
-    if(values) {
+      return createGetPeersReplyMessageWithValues(remoteNode, dict,
-      return createGetPeersReplyMessageWithValues(remoteNode, d, transactionID);
+						  transactionID.s());
     } else {
-      const Data* nodes = dynamic_cast<const Data*>(r->get(DHTGetPeersReplyMessage::NODES));
+      const bencode::BDE& nodes = rDict[DHTGetPeersReplyMessage::NODES];
-      if(nodes) {
+      if(nodes.isString()) {
-	return createGetPeersReplyMessageWithNodes(remoteNode, d, transactionID);
+	return createGetPeersReplyMessageWithNodes(remoteNode, dict,
+						   transactionID.s());
       } else {
 	throw DlAbortEx("Malformed DHT message: missing nodes/values");
       }
     }
   } else if(messageType == DHTAnnouncePeerReplyMessage::ANNOUNCE_PEER) {
-    return createAnnouncePeerReplyMessage(remoteNode, transactionID);
+    return createAnnouncePeerReplyMessage(remoteNode, transactionID.s());
   } else {
     throw DlAbortEx
       (StringFormat("Unsupported message type: %s", messageType.c_str()).str());
@@ -319,12 +344,16 @@ DHTMessageFactoryImpl::extractNodes(const unsigned char* src, size_t length)
 }
 
 SharedHandle<DHTMessage>
-DHTMessageFactoryImpl::createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+DHTMessageFactoryImpl::createFindNodeReplyMessage
-						  const Dictionary* d,
+(const SharedHandle<DHTNode>& remoteNode,
+ const bencode::BDE& dict,
  const std::string& transactionID)
 {
-  const Data* nodesData = getData(getDictionary(d, DHTResponseMessage::R), DHTFindNodeReplyMessage::NODES);
+  const bencode::BDE& nodesData =
-  std::deque<SharedHandle<DHTNode> > nodes = extractNodes(nodesData->getData(), nodesData->getLen());
+    getString(getDictionary(dict, DHTResponseMessage::R),
+	      DHTFindNodeReplyMessage::NODES);
+  std::deque<SharedHandle<DHTNode> > nodes = extractNodes(nodesData.uc(),
+							  nodesData.s().size());
   return createFindNodeReplyMessage(remoteNode, nodes, transactionID);
 }
 
@@ -344,15 +373,18 @@ DHTMessageFactoryImpl::createGetPeersMessage(const SharedHandle<DHTNode>& remote
 }
 
 SharedHandle<DHTMessage>
-DHTMessageFactoryImpl::createGetPeersReplyMessageWithNodes(const SharedHandle<DHTNode>& remoteNode,
+DHTMessageFactoryImpl::createGetPeersReplyMessageWithNodes
-							   const Dictionary* d,
+(const SharedHandle<DHTNode>& remoteNode,
+ const bencode::BDE& dict,
  const std::string& transactionID)
 {
-  const Dictionary* r = getDictionary(d, DHTResponseMessage::R);
+  const bencode::BDE& rDict = getDictionary(dict, DHTResponseMessage::R);
-  const Data* nodesData = getData(r, DHTGetPeersReplyMessage::NODES);
+  const bencode::BDE& nodesData = getString(rDict,
-  std::deque<SharedHandle<DHTNode> > nodes = extractNodes(nodesData->getData(), nodesData->getLen());
+					    DHTGetPeersReplyMessage::NODES);
-  const Data* token = getData(r, DHTGetPeersReplyMessage::TOKEN);
+  std::deque<SharedHandle<DHTNode> > nodes = extractNodes(nodesData.uc(),
-  return createGetPeersReplyMessage(remoteNode, nodes, token->toString(),
+							  nodesData.s().size());
+  const bencode::BDE& token = getString(rDict, DHTGetPeersReplyMessage::TOKEN);
+  return createGetPeersReplyMessage(remoteNode, nodes, token.s(),
 				    transactionID);
 }
 
@@ -370,23 +402,27 @@ DHTMessageFactoryImpl::createGetPeersReplyMessage(const SharedHandle<DHTNode>& r
 }
 
 SharedHandle<DHTMessage>
-DHTMessageFactoryImpl::createGetPeersReplyMessageWithValues(const SharedHandle<DHTNode>& remoteNode,
+DHTMessageFactoryImpl::createGetPeersReplyMessageWithValues
-							    const Dictionary* d,
+(const SharedHandle<DHTNode>& remoteNode,
+ const bencode::BDE& dict,
  const std::string& transactionID)
 {
-  const Dictionary* r = getDictionary(d, DHTResponseMessage::R);
+  const bencode::BDE& rDict = getDictionary(dict, DHTResponseMessage::R);
-  const List* valuesList = getList(r, DHTGetPeersReplyMessage::VALUES);
+  const bencode::BDE& valuesList = getList(rDict,
+					   DHTGetPeersReplyMessage::VALUES);
   std::deque<SharedHandle<Peer> > peers;
-  for(std::deque<MetaEntry*>::const_iterator i = valuesList->getList().begin(); i != valuesList->getList().end(); ++i) {
+  for(bencode::BDE::List::const_iterator i = valuesList.listBegin();
-    const Data* data = dynamic_cast<const Data*>(*i);
+      i != valuesList.listEnd(); ++i) {
-    if(data && data->getLen() == 6) {
+    const bencode::BDE& data = *i;
-      std::pair<std::string, uint16_t> addr = PeerMessageUtil::unpackcompact(data->getData());
+    if(data.isString() && data.s().size() == 6) {
+      std::pair<std::string, uint16_t> addr =
+	PeerMessageUtil::unpackcompact(data.uc());
       PeerHandle peer(new Peer(addr.first, addr.second));
       peers.push_back(peer);
     }
   }
-  const Data* token = getData(r, DHTGetPeersReplyMessage::TOKEN);
+  const bencode::BDE& token = getString(rDict, DHTGetPeersReplyMessage::TOKEN);
-  return createGetPeersReplyMessage(remoteNode, peers, token->toString(),
+  return createGetPeersReplyMessage(remoteNode, peers, token.s(),
 				    transactionID);
 }
 

src/DHTMessageFactoryImpl.h

@@ -46,7 +46,6 @@ class DHTRoutingTable;
 class DHTPeerAnnounceStorage;
 class DHTTokenTracker;
 class Logger;
-class Data;
 class DHTMessage;
 class DHTAbstractMessage;
 
@@ -69,9 +68,9 @@ private:
   // search node in routingTable. If it is not found, create new one.
   SharedHandle<DHTNode> getRemoteNode(const unsigned char* id, const std::string& ipaddr, uint16_t port) const;
 
-  void validateID(const Data* id) const;
+  void validateID(const bencode::BDE& id) const;
 
-  void validatePort(const Data* i) const;
+  void validatePort(const bencode::BDE& i) const;
 
   std::deque<SharedHandle<DHTNode> > extractNodes(const unsigned char* src, size_t length);
 
@@ -83,12 +82,12 @@ public:
   virtual ~DHTMessageFactoryImpl();
 
   virtual SharedHandle<DHTMessage>
-  createQueryMessage(const Dictionary* d,
+  createQueryMessage(const bencode::BDE& dict,
 		     const std::string& ipaddr, uint16_t port);
 
   virtual SharedHandle<DHTMessage>
   createResponseMessage(const std::string& messageType,
-			const Dictionary* d,
+			const bencode::BDE& dict,
 			const std::string& ipaddr, uint16_t port);
 
   virtual SharedHandle<DHTMessage>
@@ -107,7 +106,7 @@ public:
 
   SharedHandle<DHTMessage>
   createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-			     const Dictionary* d,
+			     const bencode::BDE& dict,
 			     const std::string& transactionID);
 
 
@@ -129,7 +128,7 @@ public:
 
   SharedHandle<DHTMessage>
   createGetPeersReplyMessageWithNodes(const SharedHandle<DHTNode>& remoteNode,
-				      const Dictionary* d,
+				      const bencode::BDE& dict,
 				      const std::string& transactionID);
 
   virtual SharedHandle<DHTMessage>
@@ -140,7 +139,7 @@ public:
 
   SharedHandle<DHTMessage>
   createGetPeersReplyMessageWithValues(const SharedHandle<DHTNode>& remoteNode,
-				       const Dictionary* d,
+				       const bencode::BDE& dict,
 				       const std::string& transactionID);
 
   virtual SharedHandle<DHTMessage>

src/DHTMessageReceiver.cc

@@ -46,13 +46,11 @@
 #include "DHTRoutingTable.h"
 #include "DHTNode.h"
 #include "DHTMessageCallback.h"
-#include "Dictionary.h"
-#include "Data.h"
-#include "MetaFileUtil.h"
 #include "DlAbortEx.h"
 #include "LogFactory.h"
 #include "Logger.h"
 #include "Util.h"
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -76,27 +74,28 @@ SharedHandle<DHTMessage> DHTMessageReceiver::receiveMessage()
   }
   try {
     bool isReply = false;
-    MetaEntryHandle msgroot(MetaFileUtil::bdecoding(data, length));
+    const bencode::BDE dict = bencode::decode(data, length);
-    const Dictionary* d = dynamic_cast<const Dictionary*>(msgroot.get());
+    if(dict.isDict()) {
-    if(d) {
+      const bencode::BDE& y = dict[DHTMessage::Y];
-      const Data* y = dynamic_cast<const Data*>(d->get(DHTMessage::Y));
+      if(y.isString()) {
-      if(y) {
+	if(y.s() == DHTResponseMessage::R || y.s() == DHTUnknownMessage::E) {
-	if(y->toString() == DHTResponseMessage::R ||
-	   y->toString() == DHTUnknownMessage::E) {
 	  isReply = true;
 	}
       } else {
-	_logger->info("Malformed DHT message. Missing 'y' key. From:%s:%u", remoteAddr.c_str(), remotePort);
+	_logger->info("Malformed DHT message. Missing 'y' key. From:%s:%u",
+		      remoteAddr.c_str(), remotePort);
 	return handleUnknownMessage(data, sizeof(data), remoteAddr, remotePort);
       }
     } else {
-      _logger->info("Malformed DHT message. This is not a bencoded directory. From:%s:%u", remoteAddr.c_str(), remotePort);
+      _logger->info("Malformed DHT message. This is not a bencoded directory."
+		    " From:%s:%u", remoteAddr.c_str(), remotePort);
       return handleUnknownMessage(data, sizeof(data), remoteAddr, remotePort);
     }
     SharedHandle<DHTMessage> message;
     SharedHandle<DHTMessageCallback> callback;
     if(isReply) {
-      std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> > p = _tracker->messageArrived(d, remoteAddr, remotePort);
+      std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> > p =
+	_tracker->messageArrived(dict, remoteAddr, remotePort);
       message = p.first;
       callback = p.second;
       if(message.isNull()) {
@@ -104,7 +103,7 @@ SharedHandle<DHTMessage> DHTMessageReceiver::receiveMessage()
 	return handleUnknownMessage(data, sizeof(data), remoteAddr, remotePort);
       }
     } else {
-      message = _factory->createQueryMessage(d, remoteAddr, remotePort);
+      message = _factory->createQueryMessage(dict, remoteAddr, remotePort);
       if(message->getLocalNode() == message->getRemoteNode()) {
 	// drop message from localnode
 	_logger->info("Recieved DHT message from localnode.");

src/DHTMessageTracker.cc

@@ -45,11 +45,10 @@
 #include "Util.h"
 #include "LogFactory.h"
 #include "Logger.h"
-#include "Dictionary.h"
-#include "Data.h"
 #include "DlAbortEx.h"
 #include "DHTConstants.h"
 #include "StringFormat.h"
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -70,26 +69,26 @@ void DHTMessageTracker::addMessage(const SharedHandle<DHTMessage>& message, cons
 }
 
 std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> >
-DHTMessageTracker::messageArrived(const Dictionary* d,
+DHTMessageTracker::messageArrived(const bencode::BDE& dict,
 				  const std::string& ipaddr, uint16_t port)
 {
-  const Data* tid = dynamic_cast<const Data*>(d->get(DHTMessage::T));
+  const bencode::BDE& tid = dict[DHTMessage::T];
-  if(!tid) {
+  if(!tid.isString()) {
     throw DlAbortEx(StringFormat("Malformed DHT message. From:%s:%u",
 				 ipaddr.c_str(), port).str());
   }
   _logger->debug("Searching tracker entry for TransactionID=%s, Remote=%s:%u",
-		 Util::toHex(tid->toString()).c_str(), ipaddr.c_str(), port);
+		 Util::toHex(tid.s()).c_str(), ipaddr.c_str(), port);
-  for(std::deque<SharedHandle<DHTMessageTrackerEntry> >::iterator i = _entries.begin();
+  for(std::deque<SharedHandle<DHTMessageTrackerEntry> >::iterator i =
-      i != _entries.end(); ++i) {
+	_entries.begin(); i != _entries.end(); ++i) {
-    if((*i)->match(tid->toString(), ipaddr, port)) {
+    if((*i)->match(tid.s(), ipaddr, port)) {
       SharedHandle<DHTMessageTrackerEntry> entry = *i;
       _entries.erase(i);
       _logger->debug("Tracker entry found.");
       SharedHandle<DHTNode> targetNode = entry->getTargetNode();
 
       SharedHandle<DHTMessage> message =
-	_factory->createResponseMessage(entry->getMessageType(), d,
+	_factory->createResponseMessage(entry->getMessageType(), dict,
 					targetNode->getIPAddress(),
 					targetNode->getPort());
 

src/DHTMessageTracker.h

@@ -36,11 +36,13 @@
 #define _D_DHT_MESSAGE_TRACKER_H_
 
 #include "common.h"
-#include "SharedHandle.h"
+
-#include "a2time.h"
 #include <utility>
 #include <deque>
 
+#include "SharedHandle.h"
+#include "a2time.h"
+
 namespace aria2 {
 
 class DHTMessage;
@@ -49,7 +51,9 @@ class DHTRoutingTable;
 class DHTMessageFactory;
 class DHTMessageTrackerEntry;
 class Logger;
-class Dictionary;
+namespace bencode {
+class BDE;
+} // namespace bencode
 
 class DHTMessageTracker {
 private:
@@ -75,7 +79,8 @@ public:
 		  SharedHandle<DHTMessageCallback>());
 
   std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> >
-  messageArrived(const Dictionary* d, const std::string& ipaddr, uint16_t port);
+  messageArrived(const bencode::BDE& dict,
+		 const std::string& ipaddr, uint16_t port);
 
   void handleTimeout();
 

src/DHTPingMessage.cc

@@ -34,12 +34,11 @@
 /* copyright --> */
 #include "DHTPingMessage.h"
 #include "DHTNode.h"
-#include "Dictionary.h"
-#include "Data.h"
 #include "DHTConstants.h"
 #include "DHTMessageDispatcher.h"
 #include "DHTMessageFactory.h"
 #include "DHTMessageCallback.h"
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -59,12 +58,11 @@ void DHTPingMessage::doReceivedAction()
   _dispatcher->addMessageToQueue(reply);
 }
 
-Dictionary* DHTPingMessage::getArgument()
+bencode::BDE DHTPingMessage::getArgument()
 {
-  Dictionary* a = new Dictionary();
+  bencode::BDE aDict = bencode::BDE::dict();
-  a->put(DHTMessage::ID, new Data(reinterpret_cast<const char*>(_localNode->getID()),
+  aDict[DHTMessage::ID] = bencode::BDE(_localNode->getID(), DHT_ID_LENGTH);
-			DHT_ID_LENGTH));
+  return aDict;
-  return a;
 }
 
 std::string DHTPingMessage::getMessageType() const

src/DHTPingMessage.h

@@ -50,7 +50,7 @@ public:
 
   virtual void doReceivedAction();
 
-  virtual Dictionary* getArgument();
+  virtual bencode::BDE getArgument();
 
   virtual std::string getMessageType() const;
 

src/DHTPingReplyMessage.cc

@@ -33,11 +33,12 @@
  */
 /* copyright --> */
 #include "DHTPingReplyMessage.h"
-#include "DHTNode.h"
+
-#include "Dictionary.h"
-#include "Data.h"
 #include <cstring>
 
+#include "DHTNode.h"
+#include "bencode.h"
+
 namespace aria2 {
 
 const std::string DHTPingReplyMessage::PING("ping");
@@ -55,11 +56,11 @@ DHTPingReplyMessage::~DHTPingReplyMessage() {}
 
 void DHTPingReplyMessage::doReceivedAction() {}
 
-Dictionary* DHTPingReplyMessage::getResponse()
+bencode::BDE DHTPingReplyMessage::getResponse()
 {
-  Dictionary* r = new Dictionary();
+  bencode::BDE rDict = bencode::BDE::dict();
-  r->put(DHTMessage::ID, new Data(_id, DHT_ID_LENGTH));
+  rDict[DHTMessage::ID] = bencode::BDE(_id, DHT_ID_LENGTH);
-  return r;
+  return rDict;
 }
 
 std::string DHTPingReplyMessage::getMessageType() const

src/DHTPingReplyMessage.h

@@ -53,7 +53,7 @@ public:
 
   virtual void doReceivedAction();
 
-  virtual Dictionary* getResponse();
+  virtual bencode::BDE getResponse();
 
   virtual std::string getMessageType() const;
 

src/DHTQueryMessage.cc

@@ -35,8 +35,7 @@
 #include "DHTQueryMessage.h"
 #include "DHTNode.h"
 #include "Util.h"
-#include "Dictionary.h"
+#include "bencode.h"
-#include "Data.h"
 
 namespace aria2 {
 
@@ -56,10 +55,10 @@ std::string DHTQueryMessage::getType() const
   return Q;
 }
 
-void DHTQueryMessage::fillMessage(Dictionary* message)
+void DHTQueryMessage::fillMessage(bencode::BDE& msgDict)
 {
-  message->put(Q, new Data(getMessageType()));
+  msgDict[Q] = getMessageType();
-  message->put(A, getArgument());
+  msgDict[A] = getArgument();
 }
 
 bool DHTQueryMessage::isReply() const

src/DHTQueryMessage.h

@@ -52,9 +52,9 @@ public:
 
   virtual std::string getType() const;
 
-  virtual void fillMessage(Dictionary* message);
+  virtual void fillMessage(bencode::BDE& msgDict);
 
-  virtual Dictionary* getArgument() = 0;
+  virtual bencode::BDE getArgument() = 0;
   
   virtual bool isReply() const;
 

src/DHTResponseMessage.cc

@@ -35,8 +35,7 @@
 #include "DHTResponseMessage.h"
 #include "DHTNode.h"
 #include "Util.h"
-#include "Dictionary.h"
+#include "bencode.h"
-#include "Data.h"
 
 namespace aria2 {
 
@@ -54,9 +53,9 @@ std::string DHTResponseMessage::getType() const
   return R;
 }
 
-void DHTResponseMessage::fillMessage(Dictionary* message)
+void DHTResponseMessage::fillMessage(bencode::BDE& msgDict)
 {
-  message->put(R, getResponse());
+  msgDict[R] = getResponse();
 }
 
 bool DHTResponseMessage::isReply() const

src/DHTResponseMessage.h

@@ -52,9 +52,9 @@ public:
 
   virtual std::string getType() const;
 
-  virtual void fillMessage(Dictionary* message);
+  virtual void fillMessage(bencode::BDE& msgDict);
 
-  virtual Dictionary* getResponse() = 0;
+  virtual bencode::BDE getResponse() = 0;
   
   virtual bool isReply() const;
 

test/DHTAnnouncePeerMessageTest.cc

@@ -1,16 +1,16 @@
 #include "DHTAnnouncePeerMessage.h"
+
+#include <cppunit/extensions/HelperMacros.h>
+
 #include "DHTNode.h"
 #include "DHTUtil.h"
-#include "BencodeVisitor.h"
-#include "Dictionary.h"
-#include "Data.h"
 #include "Exception.h"
 #include "Util.h"
 #include "MockDHTMessageFactory.h"
 #include "MockDHTMessageDispatcher.h"
 #include "MockDHTMessage.h"
 #include "DHTPeerAnnounceStorage.h"
-#include <cppunit/extensions/HelperMacros.h>
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -60,21 +60,18 @@ void DHTAnnouncePeerMessageTest::testGetBencodedMessage()
 
   std::string msgbody = msg.getBencodedMessage();
 
-  SharedHandle<Dictionary> cm(new Dictionary());
+  bencode::BDE dict = bencode::BDE::dict();
-  cm->put("t", new Data(transactionID));
+  dict["t"] = transactionID;
-  cm->put("y", new Data("q"));
+  dict["y"] = bencode::BDE("q");
-  cm->put("q", new Data("announce_peer"));
+  dict["q"] = bencode::BDE("announce_peer");
-  Dictionary* a = new Dictionary();
+  bencode::BDE aDict = bencode::BDE::dict();
-  cm->put("a", a);
+  aDict["id"] = bencode::BDE(localNode->getID(), DHT_ID_LENGTH);
-  a->put("id", new Data(localNode->getID(), DHT_ID_LENGTH));
+  aDict["info_hash"] = bencode::BDE(infoHash, DHT_ID_LENGTH);
-  a->put("info_hash", new Data(infoHash, DHT_ID_LENGTH));
+  aDict["port"] = port;
-  a->put("port", new Data(Util::uitos(port), true));
+  aDict["token"] = token;
-  a->put("token", new Data(token));
+  dict["a"] = aDict;
 
-  BencodeVisitor v;
+  CPPUNIT_ASSERT_EQUAL(Util::urlencode(bencode::encode(dict)),
-  cm->accept(&v);
-
-  CPPUNIT_ASSERT_EQUAL(Util::urlencode(v.getBencodedData()),
 		       Util::urlencode(msgbody));
 }
 

test/DHTAnnouncePeerReplyMessageTest.cc

@@ -1,12 +1,12 @@
 #include "DHTAnnouncePeerReplyMessage.h"
+
+#include <cppunit/extensions/HelperMacros.h>
+
 #include "DHTNode.h"
 #include "DHTUtil.h"
-#include "BencodeVisitor.h"
-#include "Dictionary.h"
-#include "Data.h"
 #include "Exception.h"
 #include "Util.h"
-#include <cppunit/extensions/HelperMacros.h>
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -39,17 +39,14 @@ void DHTAnnouncePeerReplyMessageTest::testGetBencodedMessage()
 
   std::string msgbody = msg.getBencodedMessage();
 
-  SharedHandle<Dictionary> cm(new Dictionary());
+  bencode::BDE dict = bencode::BDE::dict();
-  cm->put("t", new Data(transactionID));
+  dict["t"] = transactionID;
-  cm->put("y", new Data("r"));
+  dict["y"] = bencode::BDE("r");
-  Dictionary* r = new Dictionary();
+  bencode::BDE rDict = bencode::BDE::dict();
-  cm->put("r", r);
+  rDict["id"] = bencode::BDE(localNode->getID(), DHT_ID_LENGTH);
-  r->put("id", new Data(localNode->getID(), DHT_ID_LENGTH));
+  dict["r"] = rDict;
 
-  BencodeVisitor v;
+  CPPUNIT_ASSERT_EQUAL(bencode::encode(dict), msgbody);
-  cm->accept(&v);
-
-  CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody);
 }
 
 } // namespace aria2

test/DHTFindNodeMessageTest.cc

@@ -1,16 +1,16 @@
 #include "DHTFindNodeMessage.h"
+
+#include <cppunit/extensions/HelperMacros.h>
+
 #include "DHTNode.h"
 #include "DHTUtil.h"
-#include "BencodeVisitor.h"
-#include "Dictionary.h"
-#include "Data.h"
 #include "Exception.h"
 #include "Util.h"
 #include "MockDHTMessageFactory.h"
 #include "MockDHTMessage.h"
 #include "MockDHTMessageDispatcher.h"
 #include "DHTRoutingTable.h"
-#include <cppunit/extensions/HelperMacros.h>
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -61,19 +61,16 @@ void DHTFindNodeMessageTest::testGetBencodedMessage()
 
   std::string msgbody = msg.getBencodedMessage();
 
-  SharedHandle<Dictionary> cm(new Dictionary());
+  bencode::BDE dict = bencode::BDE::dict();
-  cm->put("t", new Data(transactionID));
+  dict["t"] = transactionID;
-  cm->put("y", new Data("q"));
+  dict["y"] = bencode::BDE("q");
-  cm->put("q", new Data("find_node"));
+  dict["q"] = bencode::BDE("find_node");
-  Dictionary* a = new Dictionary();
+  bencode::BDE aDict = bencode::BDE::dict();
-  cm->put("a", a);
+  aDict["id"] = bencode::BDE(localNode->getID(), DHT_ID_LENGTH);
-  a->put("id", new Data(localNode->getID(), DHT_ID_LENGTH));
+  aDict["target"] = bencode::BDE(targetNode->getID(), DHT_ID_LENGTH);
-  a->put("target", new Data(targetNode->getID(), DHT_ID_LENGTH));
+  dict["a"] = aDict;
 
-  BencodeVisitor v;
+  CPPUNIT_ASSERT_EQUAL(bencode::encode(dict), msgbody);
-  cm->accept(&v);
-
-  CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody);
 }
 
 void DHTFindNodeMessageTest::testDoReceivedAction()

test/DHTFindNodeReplyMessageTest.cc

@@ -1,14 +1,14 @@
 #include "DHTFindNodeReplyMessage.h"
+
+#include <cppunit/extensions/HelperMacros.h>
+
 #include "DHTNode.h"
 #include "DHTUtil.h"
-#include "BencodeVisitor.h"
-#include "Dictionary.h"
-#include "Data.h"
 #include "Exception.h"
 #include "Util.h"
 #include "DHTBucket.h"
 #include "PeerMessageUtil.h"
-#include <cppunit/extensions/HelperMacros.h>
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -56,18 +56,15 @@ void DHTFindNodeReplyMessageTest::testGetBencodedMessage()
 
   std::string msgbody = msg.getBencodedMessage();
 
-  SharedHandle<Dictionary> cm(new Dictionary());
+  bencode::BDE dict = bencode::BDE::dict();
-  cm->put("t", new Data(transactionID));
+  dict["t"] = transactionID;
-  cm->put("y", new Data("r"));
+  dict["y"] = bencode::BDE("r");
-  Dictionary* r = new Dictionary();
+  bencode::BDE rDict = bencode::BDE::dict();
-  cm->put("r", r);
+  rDict["id"] = bencode::BDE(localNode->getID(), DHT_ID_LENGTH);
-  r->put("id", new Data(localNode->getID(), DHT_ID_LENGTH));
+  rDict["nodes"] = compactNodeInfo;
-  r->put("nodes", new Data(compactNodeInfo));
+  dict["r"] = rDict;
 
-  BencodeVisitor v;
+  CPPUNIT_ASSERT_EQUAL(bencode::encode(dict), msgbody);
-  cm->accept(&v);
-
-  CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody);
 }
 
 } // namespace aria2

test/DHTGetPeersMessageTest.cc

@@ -1,9 +1,9 @@
 #include "DHTGetPeersMessage.h"
+
+#include <cppunit/extensions/HelperMacros.h>
+
 #include "DHTNode.h"
 #include "DHTUtil.h"
-#include "BencodeVisitor.h"
-#include "Dictionary.h"
-#include "Data.h"
 #include "Exception.h"
 #include "Util.h"
 #include "MockDHTMessageFactory.h"
@@ -12,7 +12,7 @@
 #include "DHTTokenTracker.h"
 #include "DHTPeerAnnounceStorage.h"
 #include "DHTRoutingTable.h"
-#include <cppunit/extensions/HelperMacros.h>
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -80,19 +80,16 @@ void DHTGetPeersMessageTest::testGetBencodedMessage()
 
   std::string msgbody = msg.getBencodedMessage();
 
-  SharedHandle<Dictionary> cm(new Dictionary());
+  bencode::BDE dict = bencode::BDE::dict();
-  cm->put("t", new Data(transactionID));
+  dict["t"] = transactionID;
-  cm->put("y", new Data("q"));
+  dict["y"] = bencode::BDE("q");
-  cm->put("q", new Data("get_peers"));
+  dict["q"] = bencode::BDE("get_peers");
-  Dictionary* a = new Dictionary();
+  bencode::BDE aDict = bencode::BDE::dict();
-  cm->put("a", a);
+  aDict["id"] = bencode::BDE(localNode->getID(), DHT_ID_LENGTH);
-  a->put("id", new Data(localNode->getID(), DHT_ID_LENGTH));
+  aDict["info_hash"] = bencode::BDE(infoHash, DHT_ID_LENGTH);
-  a->put("info_hash", new Data(infoHash, DHT_ID_LENGTH));
+  dict["a"] = aDict;
 
-  BencodeVisitor v;
+  CPPUNIT_ASSERT_EQUAL(Util::urlencode(bencode::encode(dict)),
-  cm->accept(&v);
-
-  CPPUNIT_ASSERT_EQUAL(Util::urlencode(v.getBencodedData()),
 		       Util::urlencode(msgbody));
 }
 

test/DHTGetPeersReplyMessageTest.cc

@@ -1,16 +1,15 @@
 #include "DHTGetPeersReplyMessage.h"
+
+#include <cppunit/extensions/HelperMacros.h>
+
 #include "DHTNode.h"
 #include "DHTUtil.h"
-#include "BencodeVisitor.h"
-#include "Dictionary.h"
-#include "Data.h"
 #include "Exception.h"
 #include "Util.h"
 #include "DHTBucket.h"
 #include "PeerMessageUtil.h"
-#include "List.h"
 #include "Peer.h"
-#include <cppunit/extensions/HelperMacros.h>
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -43,14 +42,13 @@ void DHTGetPeersReplyMessageTest::testGetBencodedMessage()
 
   DHTGetPeersReplyMessage msg(localNode, remoteNode, token, transactionID);
 
-  SharedHandle<Dictionary> cm(new Dictionary());
+  bencode::BDE dict = bencode::BDE::dict();
-  cm->put("t", new Data(transactionID));
+  dict["t"] = transactionID;
-  cm->put("y", new Data("r"));
+  dict["y"] = bencode::BDE("r");
-  Dictionary* r = new Dictionary();
+  bencode::BDE rDict = bencode::BDE::dict();
-  cm->put("r", r);
+  rDict["id"] = bencode::BDE(localNode->getID(), DHT_ID_LENGTH);
-  r->put("id", new Data(localNode->getID(), DHT_ID_LENGTH));
+  rDict["token"] = token;
-  r->put("token", new Data(token));
+  dict["r"] = rDict;
-
   {
     std::string compactNodeInfo;
     SharedHandle<DHTNode> nodes[8];
@@ -60,40 +58,39 @@ void DHTGetPeersReplyMessageTest::testGetBencodedMessage()
       nodes[i]->setPort(6881+i);
       
       unsigned char buf[6];
-      CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buf, nodes[i]->getIPAddress(), nodes[i]->getPort()));
+      CPPUNIT_ASSERT(PeerMessageUtil::createcompact
+		     (buf, nodes[i]->getIPAddress(), nodes[i]->getPort()));
       compactNodeInfo +=
 	std::string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+
 	std::string(&buf[0], &buf[sizeof(buf)]);
     }
-    msg.setClosestKNodes(std::deque<SharedHandle<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
+    msg.setClosestKNodes
+      (std::deque<SharedHandle<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
 
     std::string msgbody = msg.getBencodedMessage();
 
-    r->put("nodes", new Data(compactNodeInfo));
+    rDict["nodes"] = compactNodeInfo;
 
-    BencodeVisitor v;
+    CPPUNIT_ASSERT_EQUAL(Util::urlencode(bencode::encode(dict)),
-    cm->accept(&v);
-
-    CPPUNIT_ASSERT_EQUAL(Util::urlencode(v.getBencodedData()),
 			 Util::urlencode(msgbody));
   }
-  r->remove("nodes");
+  rDict.removeKey("nodes");
   {
     std::deque<SharedHandle<Peer> > peers;
-    List* values = new List();
+    bencode::BDE valuesList = bencode::BDE::list();
-    r->put("values", values);
     for(size_t i = 0; i < 4; ++i) {
       SharedHandle<Peer> peer(new Peer("192.168.0."+Util::uitos(i+1), 6881+i));
       unsigned char buffer[6];
       CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buffer, peer->ipaddr, peer->port));
-      values->add(new Data(buffer, sizeof(buffer)));
+      valuesList << bencode::BDE(buffer, sizeof(buffer));
       peers.push_back(peer);
     }
+    rDict["values"] = valuesList;
+
     msg.setValues(peers);
     std::string msgbody  = msg.getBencodedMessage();
-    BencodeVisitor v;
+
-    cm->accept(&v);
+    CPPUNIT_ASSERT_EQUAL(Util::urlencode(bencode::encode(dict)),
-    CPPUNIT_ASSERT_EQUAL(Util::urlencode(v.getBencodedData()),
 			 Util::urlencode(msgbody));
   }
 }

test/DHTMessageFactoryImplTest.cc

@@ -9,9 +9,6 @@
 #include "Util.h"
 #include "DHTNode.h"
 #include "DHTRoutingTable.h"
-#include "Dictionary.h"
-#include "Data.h"
-#include "List.h"
 #include "Peer.h"
 #include "PeerMessageUtil.h"
 #include "DHTBucket.h"
@@ -23,6 +20,7 @@
 #include "DHTGetPeersReplyMessage.h"
 #include "DHTAnnouncePeerMessage.h"
 #include "DHTAnnouncePeerReplyMessage.h"
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -81,16 +79,17 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTMessageFactoryImplTest);
 
 void DHTMessageFactoryImplTest::testCreatePingMessage()
 {
-  SharedHandle<Dictionary> d(new Dictionary());
+  bencode::BDE dict = bencode::BDE::dict();
-  d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH));
+  dict["t"] = bencode::BDE(transactionID, DHT_TRANSACTION_ID_LENGTH);
-  d->put("y", new Data("q"));
+  dict["y"] = bencode::BDE("q");
-  d->put("q", new Data("ping"));
+  dict["q"] = bencode::BDE("ping");
-  Dictionary* a = new Dictionary();
+  bencode::BDE aDict = bencode::BDE::dict();
-  a->put("id", new Data(remoteNodeID, DHT_ID_LENGTH));
+  aDict["id"] = bencode::BDE(remoteNodeID, DHT_ID_LENGTH);
-  d->put("a", a);
+  dict["a"] = aDict;
   
   SharedHandle<DHTPingMessage> m
-    (dynamic_pointer_cast<DHTPingMessage>(factory->createQueryMessage(d.get(), "192.168.0.1", 6881)));
+    (dynamic_pointer_cast<DHTPingMessage>
+     (factory->createQueryMessage(dict, "192.168.0.1", 6881)));
   SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
@@ -103,12 +102,12 @@ void DHTMessageFactoryImplTest::testCreatePingMessage()
 
 void DHTMessageFactoryImplTest::testCreatePingReplyMessage()
 {
-  SharedHandle<Dictionary> d(new Dictionary());
+  bencode::BDE dict = bencode::BDE::dict();
-  d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH));
+  dict["t"] = bencode::BDE(transactionID, DHT_TRANSACTION_ID_LENGTH);
-  d->put("y", new Data("r"));
+  dict["y"] = bencode::BDE("r");
-  Dictionary* r = new Dictionary();
+  bencode::BDE rDict = bencode::BDE::dict();
-  r->put("id", new Data(remoteNodeID, DHT_ID_LENGTH));
+  rDict["id"] = bencode::BDE(remoteNodeID, DHT_ID_LENGTH);
-  d->put("r", r);
+  dict["r"] = rDict;
 
   SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
   remoteNode->setIPAddress("192.168.0.1");
@@ -116,7 +115,7 @@ void DHTMessageFactoryImplTest::testCreatePingReplyMessage()
   
   SharedHandle<DHTPingReplyMessage> m
     (dynamic_pointer_cast<DHTPingReplyMessage>
-     (factory->createResponseMessage("ping", d.get(),
+     (factory->createResponseMessage("ping", dict,
 				     remoteNode->getIPAddress(),
 				     remoteNode->getPort())));
 
@@ -128,19 +127,20 @@ void DHTMessageFactoryImplTest::testCreatePingReplyMessage()
 
 void DHTMessageFactoryImplTest::testCreateFindNodeMessage()
 {
-  SharedHandle<Dictionary> d(new Dictionary());
+  bencode::BDE dict = bencode::BDE::dict();
-  d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH));
+  dict["t"] = bencode::BDE(transactionID, DHT_TRANSACTION_ID_LENGTH);
-  d->put("y", new Data("q"));
+  dict["y"] = bencode::BDE("q");
-  d->put("q", new Data("find_node"));
+  dict["q"] = bencode::BDE("find_node");
-  Dictionary* a = new Dictionary();
+  bencode::BDE aDict = bencode::BDE::dict();
-  a->put("id", new Data(remoteNodeID, DHT_ID_LENGTH));
+  aDict["id"] = bencode::BDE(remoteNodeID, DHT_ID_LENGTH);
   unsigned char targetNodeID[DHT_ID_LENGTH];
   memset(targetNodeID, 0x11, DHT_ID_LENGTH);
-  a->put("target", new Data(targetNodeID, DHT_ID_LENGTH));
+  aDict["target"] = bencode::BDE(targetNodeID, DHT_ID_LENGTH);
-  d->put("a", a);
+  dict["a"] = aDict;
   
   SharedHandle<DHTFindNodeMessage> m
-    (dynamic_pointer_cast<DHTFindNodeMessage>(factory->createQueryMessage(d.get(), "192.168.0.1", 6881)));
+    (dynamic_pointer_cast<DHTFindNodeMessage>
+     (factory->createQueryMessage(dict, "192.168.0.1", 6881)));
   SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
@@ -156,11 +156,11 @@ void DHTMessageFactoryImplTest::testCreateFindNodeMessage()
 void DHTMessageFactoryImplTest::testCreateFindNodeReplyMessage()
 {
   try {
-    SharedHandle<Dictionary> d(new Dictionary());
+    bencode::BDE dict = bencode::BDE::dict();
-    d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH));
+    dict["t"] = bencode::BDE(transactionID, DHT_TRANSACTION_ID_LENGTH);
-    d->put("y", new Data("r"));
+    dict["y"] = bencode::BDE("r");
-    Dictionary* r = new Dictionary();
+    bencode::BDE rDict = bencode::BDE::dict();
-    r->put("id", new Data(remoteNodeID, DHT_ID_LENGTH));
+    rDict["id"] = bencode::BDE(remoteNodeID, DHT_ID_LENGTH);
     std::string compactNodeInfo;
     SharedHandle<DHTNode> nodes[8];
     for(size_t i = 0; i < DHTBucket::K; ++i) {
@@ -169,13 +169,14 @@ void DHTMessageFactoryImplTest::testCreateFindNodeReplyMessage()
       nodes[i]->setPort(6881+i);
 
       unsigned char buf[6];
-      CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buf, nodes[i]->getIPAddress(), nodes[i]->getPort()));
+      CPPUNIT_ASSERT(PeerMessageUtil::createcompact
+		     (buf, nodes[i]->getIPAddress(), nodes[i]->getPort()));
       compactNodeInfo +=
 	std::string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+
 	std::string(&buf[0], &buf[sizeof(buf)]);
     }
-    r->put("nodes", new Data(compactNodeInfo));
+    rDict["nodes"] = compactNodeInfo;
-    d->put("r", r);
+    dict["r"] = rDict;
 
     SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
     remoteNode->setIPAddress("192.168.0.1");
@@ -183,7 +184,7 @@ void DHTMessageFactoryImplTest::testCreateFindNodeReplyMessage()
   
     SharedHandle<DHTFindNodeReplyMessage> m
       (dynamic_pointer_cast<DHTFindNodeReplyMessage>
-       (factory->createResponseMessage("find_node", d.get(),
+       (factory->createResponseMessage("find_node", dict,
 				       remoteNode->getIPAddress(),
 				       remoteNode->getPort())));
 
@@ -201,19 +202,20 @@ void DHTMessageFactoryImplTest::testCreateFindNodeReplyMessage()
 
 void DHTMessageFactoryImplTest::testCreateGetPeersMessage()
 {
-  SharedHandle<Dictionary> d(new Dictionary());
+  bencode::BDE dict = bencode::BDE::dict();
-  d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH));
+  dict["t"] = bencode::BDE(transactionID, DHT_TRANSACTION_ID_LENGTH);
-  d->put("y", new Data("q"));
+  dict["y"] = bencode::BDE("q");
-  d->put("q", new Data("get_peers"));
+  dict["q"] = bencode::BDE("get_peers");
-  Dictionary* a = new Dictionary();
+  bencode::BDE aDict = bencode::BDE::dict();
-  a->put("id", new Data(remoteNodeID, DHT_ID_LENGTH));
+  aDict["id"] = bencode::BDE(remoteNodeID, DHT_ID_LENGTH);
   unsigned char infoHash[DHT_ID_LENGTH];
   memset(infoHash, 0x11, DHT_ID_LENGTH);
-  a->put("info_hash", new Data(infoHash, DHT_ID_LENGTH));
+  aDict["info_hash"] = bencode::BDE(infoHash, DHT_ID_LENGTH);
-  d->put("a", a);
+  dict["a"] = aDict;
   
   SharedHandle<DHTGetPeersMessage> m
-    (dynamic_pointer_cast<DHTGetPeersMessage>(factory->createQueryMessage(d.get(), "192.168.0.1", 6881)));
+    (dynamic_pointer_cast<DHTGetPeersMessage>
+     (factory->createQueryMessage(dict, "192.168.0.1", 6881)));
   SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
@@ -229,11 +231,11 @@ void DHTMessageFactoryImplTest::testCreateGetPeersMessage()
 void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage_nodes()
 {
   try {
-    SharedHandle<Dictionary> d(new Dictionary());
+    bencode::BDE dict = bencode::BDE::dict();
-    d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH));
+    dict["t"] = bencode::BDE(transactionID, DHT_TRANSACTION_ID_LENGTH);
-    d->put("y", new Data("r"));
+    dict["y"] = bencode::BDE("r");
-    Dictionary* r = new Dictionary();
+    bencode::BDE rDict = bencode::BDE::dict();
-    r->put("id", new Data(remoteNodeID, DHT_ID_LENGTH));
+    rDict["id"] = bencode::BDE(remoteNodeID, DHT_ID_LENGTH);
     std::string compactNodeInfo;
     SharedHandle<DHTNode> nodes[8];
     for(size_t i = 0; i < DHTBucket::K; ++i) {
@@ -242,14 +244,15 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage_nodes()
       nodes[i]->setPort(6881+i);
 
       unsigned char buf[6];
-      CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buf, nodes[i]->getIPAddress(), nodes[i]->getPort()));
+      CPPUNIT_ASSERT(PeerMessageUtil::createcompact
+		     (buf, nodes[i]->getIPAddress(), nodes[i]->getPort()));
       compactNodeInfo +=
 	std::string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+
 	std::string(&buf[0], &buf[sizeof(buf)]);
     }
-    r->put("nodes", new Data(compactNodeInfo));
+    rDict["nodes"] = compactNodeInfo;
-    r->put("token", new Data("token"));
+    rDict["token"] = bencode::BDE("token");
-    d->put("r", r);
+    dict["r"] = rDict;
 
     SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
     remoteNode->setIPAddress("192.168.0.1");
@@ -257,7 +260,7 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage_nodes()
   
     SharedHandle<DHTGetPeersReplyMessage> m
       (dynamic_pointer_cast<DHTGetPeersReplyMessage>
-       (factory->createResponseMessage("get_peers", d.get(),
+       (factory->createResponseMessage("get_peers", dict,
 				       remoteNode->getIPAddress(),
 				       remoteNode->getPort())));
 
@@ -277,25 +280,25 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage_nodes()
 void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage_values()
 {
   try {
-    SharedHandle<Dictionary> d(new Dictionary());
+    bencode::BDE dict = bencode::BDE::dict();
-    d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH));
+    dict["t"] = bencode::BDE(transactionID, DHT_TRANSACTION_ID_LENGTH);
-    d->put("y", new Data("r"));
+    dict["y"] = bencode::BDE("r");
-    Dictionary* r = new Dictionary();
+    bencode::BDE rDict = bencode::BDE::dict();
-    r->put("id", new Data(remoteNodeID, DHT_ID_LENGTH));
+    rDict["id"] = bencode::BDE(remoteNodeID, DHT_ID_LENGTH);
 
     std::deque<SharedHandle<Peer> > peers;
-    List* values = new List();
+    bencode::BDE valuesList = bencode::BDE::list();
-    r->put("values", values);
     for(size_t i = 0; i < 4; ++i) {
       SharedHandle<Peer> peer(new Peer("192.168.0."+Util::uitos(i+1), 6881+i));
       unsigned char buffer[6];
-      CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buffer, peer->ipaddr, peer->port));
+      CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buffer, peer->ipaddr,
-      values->add(new Data(buffer, sizeof(buffer)));
+						    peer->port));
+      valuesList << bencode::BDE(buffer, sizeof(buffer));
       peers.push_back(peer);
     }
-    r->put("values", values);
+    rDict["values"] = valuesList;
-    r->put("token", new Data("token"));
+    rDict["token"] = bencode::BDE("token");
-    d->put("r", r);
+    dict["r"] = rDict;
 
     SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
     remoteNode->setIPAddress("192.168.0.1");
@@ -303,7 +306,7 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage_values()
   
     SharedHandle<DHTGetPeersReplyMessage> m
       (dynamic_pointer_cast<DHTGetPeersReplyMessage>
-       (factory->createResponseMessage("get_peers", d.get(),
+       (factory->createResponseMessage("get_peers", dict,
 				       remoteNode->getIPAddress(),
 				       remoteNode->getPort())));
 
@@ -323,23 +326,24 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage_values()
 void DHTMessageFactoryImplTest::testCreateAnnouncePeerMessage()
 {
   try {
-    SharedHandle<Dictionary> d(new Dictionary());
+    bencode::BDE dict = bencode::BDE::dict();
-    d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH));
+    dict["t"] = bencode::BDE(transactionID, DHT_TRANSACTION_ID_LENGTH);
-    d->put("y", new Data("q"));
+    dict["y"] = bencode::BDE("q");
-    d->put("q", new Data("announce_peer"));
+    dict["q"] = bencode::BDE("announce_peer");
-    Dictionary* a = new Dictionary();
+    bencode::BDE aDict = bencode::BDE::dict();
-    a->put("id", new Data(remoteNodeID, DHT_ID_LENGTH));
+    aDict["id"] = bencode::BDE(remoteNodeID, DHT_ID_LENGTH);
     unsigned char infoHash[DHT_ID_LENGTH];
     memset(infoHash, 0x11, DHT_ID_LENGTH);
-    a->put("info_hash", new Data(infoHash, DHT_ID_LENGTH));
+    aDict["info_hash"] = bencode::BDE(infoHash, DHT_ID_LENGTH);
     std::string token = "ffff";
     uint16_t port = 6881;
-    a->put("port", new Data(Util::uitos(port), true));
+    aDict["port"] = port;
-    a->put("token", new Data(token));
+    aDict["token"] = token;
-    d->put("a", a);
+    dict["a"] = aDict;
   
     SharedHandle<DHTAnnouncePeerMessage> m
-      (dynamic_pointer_cast<DHTAnnouncePeerMessage>(factory->createQueryMessage(d.get(), "192.168.0.1", 6882)));
+      (dynamic_pointer_cast<DHTAnnouncePeerMessage>
+       (factory->createQueryMessage(dict, "192.168.0.1", 6882)));
     SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
     remoteNode->setIPAddress("192.168.0.1");
     remoteNode->setPort(6882);
@@ -359,12 +363,12 @@ void DHTMessageFactoryImplTest::testCreateAnnouncePeerMessage()
 
 void DHTMessageFactoryImplTest::testCreateAnnouncePeerReplyMessage()
 {
-  SharedHandle<Dictionary> d(new Dictionary());
+  bencode::BDE dict = bencode::BDE::dict();
-  d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH));
+  dict["t"] = bencode::BDE(transactionID, DHT_TRANSACTION_ID_LENGTH);
-  d->put("y", new Data("r"));
+  dict["y"] = bencode::BDE("r");
-  Dictionary* r = new Dictionary();
+  bencode::BDE rDict = bencode::BDE::dict();
-  r->put("id", new Data(remoteNodeID, DHT_ID_LENGTH));
+  rDict["id"] = bencode::BDE(remoteNodeID, DHT_ID_LENGTH);
-  d->put("r", r);
+  dict["r"] = rDict;
 
   SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
   remoteNode->setIPAddress("192.168.0.1");
@@ -372,7 +376,7 @@ void DHTMessageFactoryImplTest::testCreateAnnouncePeerReplyMessage()
   
   SharedHandle<DHTAnnouncePeerReplyMessage> m
     (dynamic_pointer_cast<DHTAnnouncePeerReplyMessage>
-     (factory->createResponseMessage("announce_peer", d.get(),
+     (factory->createResponseMessage("announce_peer", dict,
 				     remoteNode->getIPAddress(),
 				     remoteNode->getPort())));
 
@@ -384,20 +388,20 @@ void DHTMessageFactoryImplTest::testCreateAnnouncePeerReplyMessage()
 
 void DHTMessageFactoryImplTest::testReceivedErrorMessage()
 {
-  SharedHandle<Dictionary> d(new Dictionary());
+  bencode::BDE dict = bencode::BDE::dict();
-  d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH));
+  dict["t"] = bencode::BDE(transactionID, DHT_TRANSACTION_ID_LENGTH);
-  d->put("y", new Data("e"));
+  dict["y"] = bencode::BDE("e");
-  List* l = new List();
+  bencode::BDE list = bencode::BDE::list();
-  l->add(new Data("404"));
+  list << 404;
-  l->add(new Data("Not found"));
+  list << bencode::BDE("Not found");
-  d->put("e", l);
+  dict["e"] = list;
 
   SharedHandle<DHTNode> remoteNode(new DHTNode(remoteNodeID));
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
 
   try {
-    factory->createResponseMessage("announce_peer", d.get(),
+    factory->createResponseMessage("announce_peer", dict,
 				   remoteNode->getIPAddress(),
 				   remoteNode->getPort());
     CPPUNIT_FAIL("exception must be thrown.");

test/DHTMessageTrackerTest.cc

@@ -1,16 +1,16 @@
 #include "DHTMessageTracker.h"
+
+#include <cppunit/extensions/HelperMacros.h>
+
 #include "Exception.h"
 #include "Util.h"
 #include "MockDHTMessage.h"
 #include "MockDHTMessageCallback.h"
 #include "DHTNode.h"
-#include "MetaEntry.h"
 #include "DHTMessageTrackerEntry.h"
 #include "DHTRoutingTable.h"
 #include "MockDHTMessageFactory.h"
-#include "Dictionary.h"
+#include "bencode.h"
-#include "Data.h"
-#include <cppunit/extensions/HelperMacros.h>
 
 namespace aria2 {
 
@@ -76,11 +76,12 @@ void DHTMessageTrackerTest::testMessageArrived()
   tracker.addMessage(m3);
 
   {
-    SharedHandle<Dictionary> res(new Dictionary());
+    bencode::BDE resDict = bencode::BDE::dict();
-    res->put("t", new Data(m2->getTransactionID()));
+    resDict["t"] = m2->getTransactionID();
     
     std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> > p =
-      tracker.messageArrived(res.get(), m2->getRemoteNode()->getIPAddress(), m2->getRemoteNode()->getPort());
+      tracker.messageArrived(resDict, m2->getRemoteNode()->getIPAddress(),
+			     m2->getRemoteNode()->getPort());
     SharedHandle<DHTMessage> reply = p.first;
 
     CPPUNIT_ASSERT(!reply.isNull());
@@ -89,10 +90,12 @@ void DHTMessageTrackerTest::testMessageArrived()
     CPPUNIT_ASSERT_EQUAL((size_t)2, tracker.countEntry());
   }
   {
-    SharedHandle<Dictionary> res(new Dictionary());
+    bencode::BDE resDict = bencode::BDE::dict();
-    res->put("t", new Data(m3->getTransactionID()));
+    resDict["t"] = m3->getTransactionID();
 
-    std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> > p = tracker.messageArrived(res.get(), m3->getRemoteNode()->getIPAddress(), m3->getRemoteNode()->getPort());
+    std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> > p =
+      tracker.messageArrived(resDict, m3->getRemoteNode()->getIPAddress(),
+			     m3->getRemoteNode()->getPort());
     SharedHandle<DHTMessage> reply = p.first;
 
     CPPUNIT_ASSERT(!reply.isNull());
@@ -100,10 +103,11 @@ void DHTMessageTrackerTest::testMessageArrived()
     CPPUNIT_ASSERT_EQUAL((size_t)1, tracker.countEntry());
   }
   {
-    SharedHandle<Dictionary> res(new Dictionary());
+    bencode::BDE resDict = bencode::BDE::dict();
-    res->put("t", new Data(m1->getTransactionID()));
+    resDict["t"] = m1->getTransactionID();
 
-    std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> > p = tracker.messageArrived(res.get(), "192.168.1.100", 6889);
+    std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> > p =
+      tracker.messageArrived(resDict, "192.168.1.100", 6889);
     SharedHandle<DHTMessage> reply = p.first;
 
     CPPUNIT_ASSERT(reply.isNull());

test/DHTPingMessageTest.cc

@@ -1,15 +1,15 @@
 #include "DHTPingMessage.h"
+
+#include <cppunit/extensions/HelperMacros.h>
+
 #include "DHTNode.h"
 #include "DHTUtil.h"
-#include "BencodeVisitor.h"
-#include "Dictionary.h"
-#include "Data.h"
 #include "Exception.h"
 #include "Util.h"
 #include "MockDHTMessageFactory.h"
 #include "MockDHTMessageDispatcher.h"
 #include "MockDHTMessage.h"
-#include <cppunit/extensions/HelperMacros.h>
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -57,18 +57,15 @@ void DHTPingMessageTest::testGetBencodedMessage()
 
   std::string msgbody = msg.getBencodedMessage();
 
-  SharedHandle<Dictionary> cm(new Dictionary());
+  bencode::BDE dict = bencode::BDE::dict();
-  cm->put("t", new Data(transactionID));
+  dict["t"] = transactionID;
-  cm->put("y", new Data("q"));
+  dict["y"] = bencode::BDE("q");
-  cm->put("q", new Data("ping"));
+  dict["q"] = bencode::BDE("ping");
-  Dictionary* a = new Dictionary();
+  bencode::BDE aDict = bencode::BDE::dict();
-  cm->put("a", a);
+  aDict["id"] = bencode::BDE(localNode->getID(), DHT_ID_LENGTH);
-  a->put("id", new Data(localNode->getID(), DHT_ID_LENGTH));
+  dict["a"] = aDict;
 
-  BencodeVisitor v;
+  CPPUNIT_ASSERT_EQUAL(bencode::encode(dict), msgbody);
-  cm->accept(&v);
-
-  CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody);
 }
 
 void DHTPingMessageTest::testDoReceivedAction()

test/DHTPingReplyMessageTest.cc

@@ -1,12 +1,12 @@
 #include "DHTPingReplyMessage.h"
+
+#include <cppunit/extensions/HelperMacros.h>
+
 #include "DHTNode.h"
 #include "DHTUtil.h"
-#include "BencodeVisitor.h"
-#include "Dictionary.h"
-#include "Data.h"
 #include "Exception.h"
 #include "Util.h"
-#include <cppunit/extensions/HelperMacros.h>
+#include "bencode.h"
 
 namespace aria2 {
 
@@ -42,17 +42,14 @@ void DHTPingReplyMessageTest::testGetBencodedMessage()
 
   std::string msgbody = msg.getBencodedMessage();
 
-  SharedHandle<Dictionary> cm(new Dictionary());
+  bencode::BDE dict = bencode::BDE::dict();
-  cm->put("t", new Data(transactionID));
+  dict["t"] = transactionID;
-  cm->put("y", new Data("r"));
+  dict["y"] = bencode::BDE("r");
-  Dictionary* r = new Dictionary();
+  bencode::BDE rDict = bencode::BDE::dict();
-  cm->put("r", r);
+  rDict["id"] = bencode::BDE(id, DHT_ID_LENGTH);
-  r->put("id", new Data(id, DHT_ID_LENGTH));
+  dict["r"] = rDict;
 
-  BencodeVisitor v;
+  CPPUNIT_ASSERT_EQUAL(bencode::encode(dict), msgbody);
-  cm->accept(&v);
-
-  CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody);
 }
 
 } // namespace aria2

test/MockDHTMessageFactory.h

@@ -4,8 +4,7 @@
 #include "DHTMessageFactory.h"
 #include "DHTNode.h"
 #include "MockDHTMessage.h"
-#include "Dictionary.h"
+#include "bencode.h"
-#include "Data.h"
 
 namespace aria2 {
 
@@ -18,7 +17,7 @@ public:
   virtual ~MockDHTMessageFactory() {}
 
   virtual SharedHandle<DHTMessage>
-  createQueryMessage(const Dictionary* d,
+  createQueryMessage(const bencode::BDE& dict,
 		     const std::string& ipaddr, uint16_t port)
   {
     return SharedHandle<DHTMessage>();
@@ -26,7 +25,7 @@ public:
 
   virtual SharedHandle<DHTMessage>
   createResponseMessage(const std::string& messageType,
-			const Dictionary* d,
+			const bencode::BDE& dict,
 			const std::string& ipaddr, uint16_t port)
   {
     SharedHandle<DHTNode> remoteNode(new DHTNode());
@@ -34,8 +33,7 @@ public:
     remoteNode->setIPAddress(ipaddr);
     remoteNode->setPort(port);
     SharedHandle<MockDHTMessage> m
-      (new MockDHTMessage(_localNode, remoteNode,
+      (new MockDHTMessage(_localNode, remoteNode, dict["t"].s()));
-			  reinterpret_cast<const Data*>(d->get("t"))->toString()));
     m->setReply(true);
     return m;
   }