2010-06-09 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>

	Made protected member variable private. Added accessor funcs.
	* src/ActivePeerConnectionCommand.cc
	* src/ActivePeerConnectionCommand.h
	* src/CheckIntegrityDispatcherCommand.cc
	* src/DHTEntryPointNameResolveCommand.h
	* src/DHTInteractionCommand.h
	* src/FileAllocationDispatcherCommand.cc
	* src/LpdReceiveMessageCommand.h
	* src/PeerChokeCommand.cc
	* src/PeerChokeCommand.h
	* src/PeerListenCommand.cc
	* src/PeerListenCommand.h
	* src/SeedCheckCommand.cc
	* src/SeedCheckCommand.h
	* src/SequentialDispatcherCommand.h
	* src/SleepCommand.cc
	* src/SleepCommand.h
	* src/TrackerWatcherCommand.cc
	* src/TrackerWatcherCommand.h

ChangeLog

@@ -1,3 +1,25 @@
+2010-06-09  Tatsuhiro Tsujikawa  <t-tujikawa@users.sourceforge.net>
+
+	Made protected member variable private. Added accessor funcs.
+	* src/ActivePeerConnectionCommand.cc
+	* src/ActivePeerConnectionCommand.h
+	* src/CheckIntegrityDispatcherCommand.cc
+	* src/DHTEntryPointNameResolveCommand.h
+	* src/DHTInteractionCommand.h
+	* src/FileAllocationDispatcherCommand.cc
+	* src/LpdReceiveMessageCommand.h
+	* src/PeerChokeCommand.cc
+	* src/PeerChokeCommand.h
+	* src/PeerListenCommand.cc
+	* src/PeerListenCommand.h
+	* src/SeedCheckCommand.cc
+	* src/SeedCheckCommand.h
+	* src/SequentialDispatcherCommand.h
+	* src/SleepCommand.cc
+	* src/SleepCommand.h
+	* src/TrackerWatcherCommand.cc
+	* src/TrackerWatcherCommand.h
+
 2010-06-09  Tatsuhiro Tsujikawa  <t-tujikawa@users.sourceforge.net>
 
 	Made protected member variable private. Added accessor funcs.

src/ActivePeerConnectionCommand.cc

@@ -66,8 +66,8 @@ ActivePeerConnectionCommand::ActivePeerConnectionCommand
   :
   Command(cuid),
   _requestGroup(requestGroup),
-  interval(interval),
-  e(e),
+  _interval(interval),
+  _e(e),
   _numNewConnection(5)
 {
   _requestGroup->increaseNumCommand();
@@ -82,8 +82,8 @@ bool ActivePeerConnectionCommand::execute() {
   if(_btRuntime->isHalt()) {
     return true;
   }
-  if(checkPoint.difference(global::wallclock) >= interval) {
-    checkPoint = global::wallclock;
+  if(_checkPoint.difference(global::wallclock) >= _interval) {
+    _checkPoint = global::wallclock;
     TransferStat tstat = _requestGroup->calculateStat();
     const unsigned int maxDownloadLimit =
       _requestGroup->getMaxDownloadSpeedLimit();
@@ -129,7 +129,7 @@ bool ActivePeerConnectionCommand::execute() {
       }
     }
   }
-  e->addCommand(this);
+  _e->addCommand(this);
   return false;
 }
 
@@ -138,13 +138,13 @@ void ActivePeerConnectionCommand::connectToPeer(const SharedHandle<Peer>& peer)
   if(peer.isNull()) {
     return;
   }
-  peer->usedBy(e->newCUID());
+  peer->usedBy(_e->newCUID());
   PeerInitiateConnectionCommand* command =
-    new PeerInitiateConnectionCommand(peer->usedBy(), _requestGroup, peer, e,
+    new PeerInitiateConnectionCommand(peer->usedBy(), _requestGroup, peer, _e,
                                       _btRuntime);
   command->setPeerStorage(_peerStorage);
   command->setPieceStorage(_pieceStorage);
-  e->addCommand(command);
+  _e->addCommand(command);
   if(getLogger()->info()) {
     getLogger()->info(MSG_CONNECTING_TO_PEER,
                       util::itos(getCuid()).c_str(), peer->ipaddr.c_str());

src/ActivePeerConnectionCommand.h

@@ -57,9 +57,9 @@ private:
   SharedHandle<PeerStorage> _peerStorage;
   SharedHandle<BtAnnounce> _btAnnounce;
 
-  time_t interval; // UNIT: sec
-  DownloadEngine* e;
-  Timer checkPoint;
+  time_t _interval; // UNIT: sec
+  DownloadEngine* _e;
+  Timer _checkPoint;
   unsigned int _numNewConnection; // the number of the connection to establish.
 public:
   ActivePeerConnectionCommand(cuid_t cuid,

src/CheckIntegrityDispatcherCommand.cc

@@ -56,14 +56,14 @@ CheckIntegrityDispatcherCommand::CheckIntegrityDispatcherCommand
 Command* CheckIntegrityDispatcherCommand::createCommand
 (const SharedHandle<CheckIntegrityEntry>& entry)
 {
-  cuid_t newCUID = _e->newCUID();
+  cuid_t newCUID = getDownloadEngine()->newCUID();
   if(getLogger()->info()) {
     getLogger()->info("CUID#%s - Dispatching CheckIntegrityCommand CUID#%s.",
                       util::itos(getCuid()).c_str(),
                       util::itos(newCUID).c_str());
   }
   return new CheckIntegrityCommand
-    (newCUID, entry->getRequestGroup(), _e, entry);
+    (newCUID, entry->getRequestGroup(), getDownloadEngine(), entry);
 }
 
 } // namespace aria2

src/DHTEntryPointNameResolveCommand.h

@@ -55,9 +55,9 @@ class AsyncNameResolver;
 #endif // ENABLE_ASYNC_DNS
 
 class DHTEntryPointNameResolveCommand:public Command {
-protected:
-  DownloadEngine* _e;
 private:
+  DownloadEngine* _e;
+
 #ifdef ENABLE_ASYNC_DNS
   SharedHandle<AsyncNameResolver> _resolver;
 #endif // ENABLE_ASYNC_DNS

src/DHTInteractionCommand.h

@@ -47,14 +47,12 @@ class DownloadEngine;
 class SocketCore;
 
 class DHTInteractionCommand:public Command {
-protected:
-  DownloadEngine* _e;
 private:
+  DownloadEngine* _e;
   SharedHandle<DHTMessageDispatcher> _dispatcher;
   SharedHandle<DHTMessageReceiver> _receiver;
   SharedHandle<DHTTaskQueue> _taskQueue;
   SharedHandle<SocketCore> _readCheckSocket;
-
 public:
   DHTInteractionCommand(cuid_t cuid, DownloadEngine* e);
 

src/FileAllocationDispatcherCommand.cc

@@ -53,13 +53,14 @@ FileAllocationDispatcherCommand::FileAllocationDispatcherCommand
 Command* FileAllocationDispatcherCommand::createCommand
 (const SharedHandle<FileAllocationEntry>& entry)
 {
-  cuid_t newCUID = _e->newCUID();
+  cuid_t newCUID = getDownloadEngine()->newCUID();
   if(getLogger()->info()) {
     getLogger()->info(MSG_FILE_ALLOCATION_DISPATCH,
                       util::itos(newCUID).c_str());
   }
   FileAllocationCommand* command =
-    new FileAllocationCommand(newCUID, entry->getRequestGroup(), _e, entry);
+    new FileAllocationCommand(newCUID, entry->getRequestGroup(),
+                              getDownloadEngine(), entry);
   return command;
 }
 

src/LpdReceiveMessageCommand.h

@@ -55,9 +55,8 @@ private:
   LpdReceiveMessageCommand
   (cuid_t cuid, const SharedHandle<LpdMessageReceiver>& receiver,
    DownloadEngine* e);
-protected:
-  DownloadEngine* _e;
 
+  DownloadEngine* _e;
 public:
   virtual ~LpdReceiveMessageCommand();
 

src/PeerChokeCommand.cc

@@ -47,7 +47,7 @@ namespace aria2 {
 PeerChokeCommand::PeerChokeCommand(cuid_t cuid,
                                    DownloadEngine* e):
   Command(cuid),
-  e(e) {}
+  _e(e) {}
 
 PeerChokeCommand::~PeerChokeCommand() {}
 
@@ -58,7 +58,7 @@ bool PeerChokeCommand::execute() {
   if(_peerStorage->chokeRoundIntervalElapsed()) {
     _peerStorage->executeChoke();
   }
-  e->addCommand(this);
+  _e->addCommand(this);
   return false;
 }
 

src/PeerChokeCommand.h

@@ -46,7 +46,7 @@ class PeerStorage;
 
 class PeerChokeCommand : public Command {
 private:
-  DownloadEngine* e;
+  DownloadEngine* _e;
 
   SharedHandle<PeerStorage> _peerStorage;
 

src/PeerListenCommand.cc

@@ -60,7 +60,7 @@ PeerListenCommand* PeerListenCommand::__instance = 0;
 
 PeerListenCommand::PeerListenCommand(cuid_t cuid, DownloadEngine* e):
   Command(cuid),
-  e(e),
+  _e(e),
   _lowestSpeedLimit(20*1024)
 {
   ++__numInstance;
@@ -73,7 +73,7 @@ PeerListenCommand::~PeerListenCommand()
 
 bool PeerListenCommand::bindPort(uint16_t& port, IntSequence& seq)
 {
-  socket.reset(new SocketCore());
+  _socket.reset(new SocketCore());
 
   std::vector<int32_t> randPorts = seq.flush();
   std::random_shuffle(randPorts.begin(), randPorts.end(),
@@ -86,15 +86,15 @@ bool PeerListenCommand::bindPort(uint16_t& port, IntSequence& seq)
     }
     port = (*portItr);
     try {
-      socket->bind(port);
-      socket->beginListen();
-      socket->setNonBlockingMode();
+      _socket->bind(port);
+      _socket->beginListen();
+      _socket->setNonBlockingMode();
       getLogger()->notice("BitTorrent: listening to port %d", port);
       return true;
     } catch(RecoverableException& ex) {
       getLogger()->error(MSG_BIND_FAILURE, ex,
                          util::itos(getCuid()).c_str(), port);
-      socket->closeConnection();
+      _socket->closeConnection();
     }
   }
   return false;
@@ -102,33 +102,33 @@ bool PeerListenCommand::bindPort(uint16_t& port, IntSequence& seq)
 
 uint16_t PeerListenCommand::getPort() const
 {
-  if(socket.isNull()) {
+  if(_socket.isNull()) {
     return 0;
   } else {
     std::pair<std::string, uint16_t> addr;
-    socket->getAddrInfo(addr);
+    _socket->getAddrInfo(addr);
     return addr.second;
   }
 }
 
 bool PeerListenCommand::execute() {
-  if(e->isHaltRequested() || e->getRequestGroupMan()->downloadFinished()) {
+  if(_e->isHaltRequested() || _e->getRequestGroupMan()->downloadFinished()) {
     return true;
   }
-  for(int i = 0; i < 3 && socket->isReadable(0); ++i) {
+  for(int i = 0; i < 3 && _socket->isReadable(0); ++i) {
     SocketHandle peerSocket;
     try {
-      peerSocket.reset(socket->acceptConnection());
+      peerSocket.reset(_socket->acceptConnection());
       std::pair<std::string, uint16_t> peerInfo;
       peerSocket->getPeerInfo(peerInfo);
 
       peerSocket->setNonBlockingMode();
 
       SharedHandle<Peer> peer(new Peer(peerInfo.first, peerInfo.second, true));
-      cuid_t cuid = e->newCUID();
+      cuid_t cuid = _e->newCUID();
       Command* command =
-        new ReceiverMSEHandshakeCommand(cuid, peer, e, peerSocket);
-      e->addCommand(command);
+        new ReceiverMSEHandshakeCommand(cuid, peer, _e, peerSocket);
+      _e->addCommand(command);
       if(getLogger()->debug()) {
         getLogger()->debug("Accepted the connection from %s:%u.",
                            peer->ipaddr.c_str(),
@@ -140,7 +140,7 @@ bool PeerListenCommand::execute() {
       getLogger()->debug(MSG_ACCEPT_FAILURE, ex, util::itos(getCuid()).c_str());
     }               
   }
-  e->addCommand(this);
+  _e->addCommand(this);
   return false;
 }
 

src/PeerListenCommand.h

@@ -46,8 +46,8 @@ class SocketCore;
 
 class PeerListenCommand : public Command {
 private:
-  DownloadEngine* e;
-  SharedHandle<SocketCore> socket;
+  DownloadEngine* _e;
+  SharedHandle<SocketCore> _socket;
   unsigned int _lowestSpeedLimit;
 
   static unsigned int __numInstance;

src/SeedCheckCommand.cc

@@ -55,9 +55,9 @@ SeedCheckCommand::SeedCheckCommand
  const SharedHandle<SeedCriteria>& seedCriteria)
   :Command(cuid),
    _requestGroup(requestGroup),
-   e(e),
-   seedCriteria(seedCriteria),
-   checkStarted(false)
+   _e(e),
+   _seedCriteria(seedCriteria),
+   _checkStarted(false)
 {
   setStatusRealtime();
   _requestGroup->increaseNumCommand();
@@ -72,29 +72,29 @@ bool SeedCheckCommand::execute() {
   if(_btRuntime->isHalt()) {
     return true;
   }
-  if(!seedCriteria.get()) {
+  if(!_seedCriteria.get()) {
     return false;
   }
-  if(!checkStarted) {
+  if(!_checkStarted) {
     if(_pieceStorage->downloadFinished()) {
-      checkStarted = true;
-      seedCriteria->reset();
+      _checkStarted = true;
+      _seedCriteria->reset();
     }
   }
-  if(checkStarted) {
-    if(seedCriteria->evaluate()) {
+  if(_checkStarted) {
+    if(_seedCriteria->evaluate()) {
       getLogger()->notice(MSG_SEEDING_END);
       _btRuntime->setHalt(true);
     }
   }
-  e->addCommand(this);
+  _e->addCommand(this);
   return false;
 }
 
 void SeedCheckCommand::setSeedCriteria
 (const SharedHandle<SeedCriteria>& seedCriteria)
 {
-  this->seedCriteria = seedCriteria;
+  _seedCriteria = seedCriteria;
 }
 
 void SeedCheckCommand::setBtRuntime(const SharedHandle<BtRuntime>& btRuntime)

src/SeedCheckCommand.h

@@ -50,11 +50,11 @@ class SeedCheckCommand : public Command
 {
 private:
   RequestGroup* _requestGroup;
-  DownloadEngine* e;
+  DownloadEngine* _e;
   SharedHandle<PieceStorage> _pieceStorage;
   SharedHandle<BtRuntime> _btRuntime;
-  SharedHandle<SeedCriteria> seedCriteria;
-  bool checkStarted;
+  SharedHandle<SeedCriteria> _seedCriteria;
+  bool _checkStarted;
 public:
   SeedCheckCommand(cuid_t cuid,
                    RequestGroup* requestGroup,

src/SequentialDispatcherCommand.h

@@ -47,10 +47,15 @@ class DownloadEngine;
 
 template<typename T>
 class SequentialDispatcherCommand : public Command {
-protected:
+private:
   SharedHandle<SequentialPicker<T> > _picker;
 
   DownloadEngine* _e;
+protected:
+  DownloadEngine* getDownloadEngine() const
+  {
+    return _e;
+  }
 public:
   SequentialDispatcherCommand(cuid_t cuid,
                               const SharedHandle<SequentialPicker<T> >& picker,

src/SleepCommand.cc

@@ -47,22 +47,22 @@ namespace aria2 {
 SleepCommand::SleepCommand(cuid_t cuid, DownloadEngine* e,
                            RequestGroup* requestGroup,
                            Command* nextCommand, time_t wait):
-  Command(cuid), engine(e), _requestGroup(requestGroup),
-  nextCommand(nextCommand), wait(wait), checkPoint(global::wallclock) {}
+  Command(cuid), _engine(e), _requestGroup(requestGroup),
+  _nextCommand(nextCommand), _wait(wait), _checkPoint(global::wallclock) {}
 
 SleepCommand::~SleepCommand() {
-  delete nextCommand;
+  delete _nextCommand;
 }
 
 bool SleepCommand::execute() {
   if(_requestGroup->downloadFinished() || _requestGroup->isHaltRequested()) {
     return true;
-  } else if(checkPoint.difference(global::wallclock) >= wait) {
-    engine->addCommand(nextCommand);
-    nextCommand = 0;
+  } else if(_checkPoint.difference(global::wallclock) >= _wait) {
+    _engine->addCommand(_nextCommand);
+    _nextCommand = 0;
     return true;
   } else {
-    engine->addCommand(this);
+    _engine->addCommand(this);
     return false;
   }
 }

src/SleepCommand.h

@@ -45,11 +45,11 @@ class RequestGroup;
 
 class SleepCommand:public Command {
 private:
-  DownloadEngine* engine;
+  DownloadEngine* _engine;
   RequestGroup* _requestGroup;
-  Command* nextCommand;
-  time_t wait;
-  Timer checkPoint;
+  Command* _nextCommand;
+  time_t _wait;
+  Timer _checkPoint;
 public:
   SleepCommand(cuid_t cuid, DownloadEngine* e, RequestGroup* requestGroup,
                Command* nextCommand, time_t wait);

src/TrackerWatcherCommand.cc

@@ -72,7 +72,7 @@ TrackerWatcherCommand::TrackerWatcherCommand
 (cuid_t cuid, RequestGroup* requestGroup, DownloadEngine* e):
   Command(cuid),
   _requestGroup(requestGroup),
-  e(e)
+  _e(e)
 {
   _requestGroup->increaseNumCommand();
 }
@@ -91,7 +91,7 @@ bool TrackerWatcherCommand::execute() {
       return true;
     } else {
       _trackerRequestGroup->setForceHaltRequested(true);
-      e->addCommand(this);
+      _e->addCommand(this);
       return false;
     }
   }
@@ -106,13 +106,13 @@ bool TrackerWatcherCommand::execute() {
     if(!_trackerRequestGroup.isNull()) {
       std::vector<Command*> commands;
       try {
-        _trackerRequestGroup->createInitialCommand(commands, e);
+        _trackerRequestGroup->createInitialCommand(commands, _e);
       } catch(RecoverableException& ex) {
         getLogger()->error(EX_EXCEPTION_CAUGHT, ex);
         std::for_each(commands.begin(), commands.end(), Deleter());
         commands.clear();
       }
-      e->addCommand(commands);
+      _e->addCommand(commands);
       if(getLogger()->debug()) {
         getLogger()->debug("added tracker request command");
       }
@@ -140,7 +140,7 @@ bool TrackerWatcherCommand::execute() {
       _btAnnounce->resetAnnounce();
     }
   }
-  e->addCommand(this);
+  _e->addCommand(this);
   return false;
 }
 
@@ -173,13 +173,13 @@ void TrackerWatcherCommand::processTrackerResponse
     if(peer.isNull()) {
       break;
     }
-    peer->usedBy(e->newCUID());
+    peer->usedBy(_e->newCUID());
     PeerInitiateConnectionCommand* command =
       new PeerInitiateConnectionCommand
-      (peer->usedBy(), _requestGroup, peer, e, _btRuntime);
+      (peer->usedBy(), _requestGroup, peer, _e, _btRuntime);
     command->setPeerStorage(_peerStorage);
     command->setPieceStorage(_pieceStorage);
-    e->addCommand(command);
+    _e->addCommand(command);
     if(getLogger()->debug()) {
       getLogger()->debug("CUID#%s - Adding new command CUID#%s",
                          util::itos(getCuid()).c_str(),

src/TrackerWatcherCommand.h

@@ -53,7 +53,7 @@ class TrackerWatcherCommand : public Command
 private:
   RequestGroup* _requestGroup;
 
-  DownloadEngine* e;
+  DownloadEngine* _e;
 
   SharedHandle<PeerStorage> _peerStorage;