2006-08-14 Tatsuhiro Tsujikawa <tujikawa at rednoah dot com>

	* src/FeatureConfig.cc
	(FEATURE_ASYNC_DNS): New definition.
	(FeatureConfig): Added aysnc DNS entry.

	To replace CommandUuid with Command* in SocketEntry and
	NameResolverEntry:
	
	* src/DownloadEngine.h
	(CommandUuids): Removed.
	(SocketEntry::commandUuid): Removed.
	(SocketEntry::command): New variable.
	(SocketEntry::SocketEntry): Updated.
	(SocketEntry::operator==): Updated.
	(NameResolverEntry::commandUuid): Removed.
	(NameResolverEntry::command): New variable.
	(NameResolverEntry::NameResolverEntry): Updated.
	(NameResolverEntry::operator==): Updated.
	(waitData): Changed the argument type.
	(addSocketForReadCheck): Changed the argument type.
	(deleteSocketForReadCheck): Changed the argument type.
	(addSocketForWriteCheck): Changed the argument type.
	(deleteSocketForWriteCheck): Changed the argument type.
	(addNameResolverCheck): Changed the argument type.
	(deleteNameResolverCheck): Changed the argument type.
	* src/DownloadEngine.cc
	(FindCommand): Removed.
	(run): Removed activeUuid. Added activeCommands instead.
	(AccumulateActiveUuid): Renamed as AccumulateActiveCommand.
	(AccumulateActiveCommand): New function object.
	(waitData): Use AccumulateActiveCommand.
	(addSocketForReadCheck): Use Command instead of CommandUuid.
	(deleteSocketForReadCheck): Use Command instead of CommandUuid.
	(addSocketForWriteCheck): Use Command instead of CommandUuid.
	(deleteSocketForWriteCheck): Use Command instead of CommandUuid.
	(addNameResolverCheck): Use Command instead of CommandUuid.
	(deleteNameResolverCheck): Use Command instead of CommandUuid.	
	* src/AbstractCommand.cc
	(disableReadCheckSocket): Updated according to the changes in
	DownloadEngine.
	(setReadCheckSocket): Updated according to the changes in
	DownloadEngine.
	(disableWriteCheckSocket): Updated according to the changes in
	DownloadEngine.
	(setWriteCheckSocket): Updated according to the changes in
	DownloadEngine.
	(setNameResolverCheck): Updated according to the changes in
	DownloadEngine.
	(disableNameResolverCheck): Updated according to the changes in
	DownloadEngine.
	* src/AbstractCommand.cc
	(disableReadCheckSocket): Updated according to the changes in
	DownloadEngine.
	(setReadCheckSocket): Updated according to the changes in
	DownloadEngine.
	(disableWriteCheckSocket): Updated according to the changes in
	DownloadEngine.
	(setWriteCheckSocket): Updated according to the changes in
	DownloadEngine.

	* release 0.7.1

5 files changed, 78 insertions, 87 deletions

diff --git a/src/AbstractCommand.cc b/src/AbstractCommand.cc
index bc9f005f..28df0413 100644
--- a/src/AbstractCommand.cc
+++ b/src/AbstractCommand.cc
@@ -120,7 +120,7 @@ void AbstractCommand::onAbort(Exception* ex) {
 
 void AbstractCommand::disableReadCheckSocket() {
   if(checkSocketIsReadable) {
-    e->deleteSocketForReadCheck(readCheckTarget, getUuid());
+    e->deleteSocketForReadCheck(readCheckTarget, this);
     checkSocketIsReadable = false;
     readCheckTarget = SocketHandle();
   }  
@@ -132,12 +132,12 @@ void AbstractCommand::setReadCheckSocket(const SocketHandle& socket) {
   } else {
     if(checkSocketIsReadable) {
       if(readCheckTarget != socket) {
-	e->deleteSocketForReadCheck(readCheckTarget, getUuid());
-	e->addSocketForReadCheck(socket, getUuid());
+	e->deleteSocketForReadCheck(readCheckTarget, this);
+	e->addSocketForReadCheck(socket, this);
 	readCheckTarget = socket;
       }
     } else {
-      e->addSocketForReadCheck(socket, getUuid());
+      e->addSocketForReadCheck(socket, this);
       checkSocketIsReadable = true;
       readCheckTarget = socket;
     }
@@ -146,7 +146,7 @@ void AbstractCommand::setReadCheckSocket(const SocketHandle& socket) {
 
 void AbstractCommand::disableWriteCheckSocket() {
   if(checkSocketIsWritable) {
-    e->deleteSocketForWriteCheck(writeCheckTarget, getUuid());
+    e->deleteSocketForWriteCheck(writeCheckTarget, this);
     checkSocketIsWritable = false;
     writeCheckTarget = SocketHandle();
   }
@@ -158,12 +158,12 @@ void AbstractCommand::setWriteCheckSocket(const SocketHandle& socket) {
   } else {
     if(checkSocketIsWritable) {
       if(writeCheckTarget != socket) {
-	e->deleteSocketForWriteCheck(writeCheckTarget, getUuid());
-	e->addSocketForWriteCheck(socket, getUuid());
+	e->deleteSocketForWriteCheck(writeCheckTarget, this);
+	e->addSocketForWriteCheck(socket, this);
 	writeCheckTarget = socket;
       }
     } else {
-      e->addSocketForWriteCheck(socket, getUuid());
+      e->addSocketForWriteCheck(socket, this);
       checkSocketIsWritable = true;
       writeCheckTarget = socket;
     }
@@ -172,11 +172,11 @@ void AbstractCommand::setWriteCheckSocket(const SocketHandle& socket) {
 
 #ifdef HAVE_LIBARES
 void AbstractCommand::setNameResolverCheck(const NameResolverHandle& resolver) {
-  e->addNameResolverCheck(resolver, getUuid());
+  e->addNameResolverCheck(resolver, this);
 }
 
 void AbstractCommand::disableNameResolverCheck(const NameResolverHandle& resolver) {
-  e->deleteNameResolverCheck(resolver, getUuid());
+  e->deleteNameResolverCheck(resolver, this);
 }
 
 bool AbstractCommand::resolveHostname(const string& hostname,
diff --git a/src/DownloadEngine.cc b/src/DownloadEngine.cc
index 9229acd2..abdc18a8 100644
--- a/src/DownloadEngine.cc
+++ b/src/DownloadEngine.cc
@@ -46,27 +46,11 @@ void DownloadEngine::cleanQueue() {
   commands.clear();
 }
 
-
-class FindCommand {
-private:
-  CommandUuid uuid;
-public:
-  FindCommand(const CommandUuid& uuid):uuid(uuid) {}
-
-  bool operator()(const Command* command) {
-    if(command->getUuid() == uuid) {
-      return true;
-    } else {
-      return false;
-    }
-  }
-};
-
 void DownloadEngine::run() {
   initStatistics();
   Time cp;
   cp.setTimeInSec(0);
-  CommandUuids activeUuids;
+  Commands activeCommands;
   while(!commands.empty()) {
     if(cp.elapsed(1)) {
       cp.reset();
@@ -79,22 +63,22 @@ void DownloadEngine::run() {
 	}
       }
     } else {
-      for(CommandUuids::iterator itr = activeUuids.begin();
-	  itr != activeUuids.end(); itr++) {
-	Commands::iterator comItr = find_if(commands.begin(), commands.end(),
-					    FindCommand(*itr));
+      for(Commands::iterator itr = activeCommands.begin();
+	  itr != activeCommands.end(); itr++) {
+	Commands::iterator comItr = find(commands.begin(), commands.end(),
+					 *itr);
 	assert(comItr != commands.end());
-	Command* com = *comItr;
+	Command* command = *itr;
 	commands.erase(comItr);
-	if(com->execute()) {
-	  delete com;
+	if(command->execute()) {
+	  delete command;
 	}
       }
     }
     afterEachIteration();
-    activeUuids.clear();
+    activeCommands.clear();
     if(!noWait && !commands.empty()) {
-      waitData(activeUuids);
+      waitData(activeCommands);
     }
     noWait = false;
     calculateStatistics();
@@ -146,34 +130,34 @@ public:
 #endif // HAVE_LIBARES
 };
 
-class AccumulateActiveUuid {
+class AccumulateActiveCommand {
 private:
-  CommandUuids* activeUuids_ptr;
+  Commands* activeCommands_ptr;
   fd_set* rfds_ptr;
   fd_set* wfds_ptr;
 public:
-  AccumulateActiveUuid(CommandUuids* activeUuids_ptr,
+  AccumulateActiveCommand(Commands* activeCommands_ptr,
 		       fd_set* rfds_ptr,
 		       fd_set* wfds_ptr):
-    activeUuids_ptr(activeUuids_ptr),
+    activeCommands_ptr(activeCommands_ptr),
     rfds_ptr(rfds_ptr),
     wfds_ptr(wfds_ptr) {}
 
   void operator()(const SocketEntry& entry) {
     if(FD_ISSET(entry.socket->getSockfd(), rfds_ptr) ||
        FD_ISSET(entry.socket->getSockfd(), wfds_ptr)) {
-      activeUuids_ptr->push_back(entry.commandUuid);
+      activeCommands_ptr->push_back(entry.command);
     }
     /*
     switch(entry.type) {
     case SocketEntry::TYPE_RD:
       if(FD_ISSET(entry.socket->getSockfd(), rfds_ptr)) {
-	activeUuids_ptr->push_back(entry.commandUuid);
+      activeCommands_ptr->push_back(entry.command);
       }
       break;
     case SocketEntry::TYPE_WR:
       if(FD_ISSET(entry.socket->getSockfd(), wfds_ptr)) {
-	activeUuids_ptr->push_back(entry.commandUuid);
+	activeCommands_ptr->push_back(entry.command);
       }
       break;
     }
@@ -185,7 +169,7 @@ public:
     switch(entry.nameResolver->getStatus()) {
     case NameResolver::STATUS_SUCCESS:
     case NameResolver::STATUS_ERROR:
-      activeUuids_ptr->push_back(entry.commandUuid);
+      activeCommands_ptr->push_back(entry.command);
       break;
     default:
       break;
@@ -194,7 +178,7 @@ public:
 #endif // HAVE_LIBARES
 };
 
-void DownloadEngine::waitData(CommandUuids& activeUuids) {
+void DownloadEngine::waitData(Commands& activeCommands) {
   fd_set rfds;
   fd_set wfds;
   int retval = 0;
@@ -208,15 +192,15 @@ void DownloadEngine::waitData(CommandUuids& activeUuids) {
   retval = select(fdmax+1, &rfds, &wfds, NULL, &tv);
   if(retval > 0) {
     for_each(socketEntries.begin(), socketEntries.end(),
-	     AccumulateActiveUuid(&activeUuids, &rfds, &wfds));
+	     AccumulateActiveCommand(&activeCommands, &rfds, &wfds));
 #ifdef HAVE_LIBARES
     for_each(nameResolverEntries.begin(), nameResolverEntries.end(),
-	     AccumulateActiveUuid(&activeUuids, &rfds, &wfds));
+	     AccumulateActiveCommand(&activeCommands, &rfds, &wfds));
 #endif // HAVE_LIBARES
-    sort(activeUuids.begin(), activeUuids.end());
-    activeUuids.erase(unique(activeUuids.begin(),
-			     activeUuids.end()),
-		      activeUuids.end());
+    sort(activeCommands.begin(), activeCommands.end());
+    activeCommands.erase(unique(activeCommands.begin(),
+				activeCommands.end()),
+			 activeCommands.end());
   }
 }
 
@@ -257,33 +241,33 @@ bool DownloadEngine::deleteSocket(const SocketEntry& entry) {
 }
 
 bool DownloadEngine::addSocketForReadCheck(const SocketHandle& socket,
-					   const CommandUuid& commandUuid) {
-  SocketEntry entry(socket, commandUuid, SocketEntry::TYPE_RD);
+					   Command* command) {
+  SocketEntry entry(socket, command, SocketEntry::TYPE_RD);
   return addSocket(entry);
 }
 
 bool DownloadEngine::deleteSocketForReadCheck(const SocketHandle& socket,
-					      const CommandUuid& commandUuid) {
-  SocketEntry entry(socket, commandUuid, SocketEntry::TYPE_RD);
+					      Command* command) {
+  SocketEntry entry(socket, command, SocketEntry::TYPE_RD);
   return deleteSocket(entry);
 }
 
 bool DownloadEngine::addSocketForWriteCheck(const SocketHandle& socket,
-					    const CommandUuid& commandUuid) {
-  SocketEntry entry(socket, commandUuid, SocketEntry::TYPE_WR);
+					    Command* command) {
+  SocketEntry entry(socket, command, SocketEntry::TYPE_WR);
   return addSocket(entry);
 }
 
 bool DownloadEngine::deleteSocketForWriteCheck(const SocketHandle& socket,
-					       const CommandUuid& commandUuid) {
-  SocketEntry entry(socket, commandUuid, SocketEntry::TYPE_WR);
+					       Command* command) {
+  SocketEntry entry(socket, command, SocketEntry::TYPE_WR);
   return deleteSocket(entry);
 }
 
 #ifdef HAVE_LIBARES
 bool DownloadEngine::addNameResolverCheck(const NameResolverHandle& resolver,
-					  const CommandUuid& uuid) {
-  NameResolverEntry entry(resolver, uuid);
+					  Command* command) {
+  NameResolverEntry entry(resolver, command);
   NameResolverEntries::iterator itr = find(nameResolverEntries.begin(),
 					   nameResolverEntries.end(),
 					   entry);
@@ -297,8 +281,8 @@ bool DownloadEngine::addNameResolverCheck(const NameResolverHandle& resolver,
 }
 
 bool DownloadEngine::deleteNameResolverCheck(const NameResolverHandle& resolver,
-					     const CommandUuid& uuid) {
-  NameResolverEntry entry(resolver, uuid);
+					     Command* command) {
+  NameResolverEntry entry(resolver, command);
   NameResolverEntries::iterator itr = find(nameResolverEntries.begin(),
 					   nameResolverEntries.end(),
 					   entry);
diff --git a/src/DownloadEngine.h b/src/DownloadEngine.h
index b412ce3b..26b7c753 100644
--- a/src/DownloadEngine.h
+++ b/src/DownloadEngine.h
@@ -34,7 +34,6 @@
 
 typedef deque<SocketHandle> Sockets;
 typedef deque<Command*> Commands;
-typedef deque<CommandUuid> CommandUuids;
 
 class SocketEntry {
 public:
@@ -44,18 +43,18 @@ public:
   };
 
   SocketHandle socket;
-  CommandUuid commandUuid;
+  Command* command;
   TYPE type;
 public:
   SocketEntry(const SocketHandle& socket,
-	      const CommandUuid& commandUuid,
+	      Command* command,
 	      TYPE type):
-    socket(socket), commandUuid(commandUuid), type(type) {}
+    socket(socket), command(command), type(type) {}
   ~SocketEntry() {}
 
   bool operator==(const SocketEntry& entry) {
     return socket == entry.socket &&
-      commandUuid == entry.commandUuid &&
+      command == entry.command &&
       type == entry.type;
   }
 };
@@ -66,16 +65,16 @@ typedef deque<SocketEntry> SocketEntries;
 class NameResolverEntry {
 public:
   NameResolverHandle nameResolver;
-  CommandUuid commandUuid;
+  Command* command;
 public:
   NameResolverEntry(const NameResolverHandle& nameResolver,
-		    const CommandUuid& commandUuid):
-    nameResolver(nameResolver), commandUuid(commandUuid) {}
+		    Command* command):
+    nameResolver(nameResolver), command(command) {}
   ~NameResolverEntry() {}
 
   bool operator==(const NameResolverEntry& entry) {
     return nameResolver == entry.nameResolver &&
-      commandUuid == entry.commandUuid;
+      command == entry.command;
   }
 };
 
@@ -85,7 +84,7 @@ typedef deque<NameResolverEntry> NameResolverEntries;
 
 class DownloadEngine {
 private:
-  void waitData(CommandUuids& activeUuids);
+  void waitData(Commands& activeCommands);
   SocketEntries socketEntries;
 #ifdef HAVE_LIBARES
   NameResolverEntries nameResolverEntries;
@@ -119,18 +118,18 @@ public:
   void updateFdSet();
 
   bool addSocketForReadCheck(const SocketHandle& socket,
-			     const CommandUuid& commandUuid);
+			     Command* command);
   bool deleteSocketForReadCheck(const SocketHandle& socket,
-				const CommandUuid& commandUuid);
+				Command* command);
   bool addSocketForWriteCheck(const SocketHandle& socket,
-			      const CommandUuid& commandUuid);
+			      Command* command);
   bool deleteSocketForWriteCheck(const SocketHandle& socket,
-				 const CommandUuid& command);
+				 Command* command);
 #ifdef HAVE_LIBARES
   bool addNameResolverCheck(const NameResolverHandle& resolver,
-			    const CommandUuid& uuid);
+			    Command* command);
   bool deleteNameResolverCheck(const NameResolverHandle& resolver,
-			       const CommandUuid& uuid);
+			       Command* command);
 #endif // HAVE_LIBARES
 };
 
diff --git a/src/FeatureConfig.cc b/src/FeatureConfig.cc
index 9e4ab013..79922710 100644
--- a/src/FeatureConfig.cc
+++ b/src/FeatureConfig.cc
@@ -29,6 +29,7 @@ FeatureConfig* FeatureConfig::featureConfig = 0;
 #define FEATURE_BITTORRENT "bittorrent"
 #define FEATURE_METALINK "metalink"
 #define FEATURE_MESSAGE_DIGEST "message digest"
+#define FEATURE_ASYNC_DNS "async dns"
 
 FeatureConfig::FeatureConfig() {
   static PortMap::value_type portArray[] = {
@@ -71,6 +72,13 @@ FeatureConfig::FeatureConfig() {
 			   false
 #endif // ENABLE_MESSAGE_DIGEST
 			   ),
+    FeatureMap::value_type(FEATURE_ASYNC_DNS,
+#ifdef HAVE_LIBARES
+			   true
+#else
+			   false
+#endif // HAVE_LIBARES
+			   ),
   };
 
   int featureArraySize = sizeof(featureArray)/sizeof(FeatureMap::value_type);
diff --git a/src/PeerAbstractCommand.cc b/src/PeerAbstractCommand.cc
index eab501ad..fe663b7e 100644
--- a/src/PeerAbstractCommand.cc
+++ b/src/PeerAbstractCommand.cc
@@ -88,7 +88,7 @@ void PeerAbstractCommand::onAbort(Exception* ex) {
 
 void PeerAbstractCommand::disableReadCheckSocket() {
   if(checkSocketIsReadable) {
-    e->deleteSocketForReadCheck(readCheckTarget, getUuid());
+    e->deleteSocketForReadCheck(readCheckTarget, this);
     checkSocketIsReadable = false;
     readCheckTarget = SocketHandle();
   }  
@@ -100,12 +100,12 @@ void PeerAbstractCommand::setReadCheckSocket(const SocketHandle& socket) {
   } else {
     if(checkSocketIsReadable) {
       if(readCheckTarget != socket) {
-	e->deleteSocketForReadCheck(readCheckTarget, getUuid());
-	e->addSocketForReadCheck(socket, getUuid());
+	e->deleteSocketForReadCheck(readCheckTarget, this);
+	e->addSocketForReadCheck(socket, this);
 	readCheckTarget = socket;
       }
     } else {
-      e->addSocketForReadCheck(socket, getUuid());
+      e->addSocketForReadCheck(socket, this);
       checkSocketIsReadable = true;
       readCheckTarget = socket;
     }
@@ -114,7 +114,7 @@ void PeerAbstractCommand::setReadCheckSocket(const SocketHandle& socket) {
 
 void PeerAbstractCommand::disableWriteCheckSocket() {
   if(checkSocketIsWritable) {
-    e->deleteSocketForWriteCheck(writeCheckTarget, getUuid());
+    e->deleteSocketForWriteCheck(writeCheckTarget, this);
     checkSocketIsWritable = false;
     writeCheckTarget = SocketHandle();
   }
@@ -126,12 +126,12 @@ void PeerAbstractCommand::setWriteCheckSocket(const SocketHandle& socket) {
   } else {
     if(checkSocketIsWritable) {
       if(writeCheckTarget != socket) {
-	e->deleteSocketForWriteCheck(writeCheckTarget, getUuid());
-	e->addSocketForWriteCheck(socket, getUuid());
+	e->deleteSocketForWriteCheck(writeCheckTarget, this);
+	e->addSocketForWriteCheck(socket, this);
 	writeCheckTarget = socket;
       }
     } else {
-      e->addSocketForWriteCheck(socket, getUuid());
+      e->addSocketForWriteCheck(socket, this);
       checkSocketIsWritable = true;
       writeCheckTarget = socket;
     }