github
/
aria2
mirror of https://github.com/aria2/aria2
1
0
Fork 0
Code Issues Releases Wiki Activity

Code cleanup

pull/28/head
Tatsuhiro Tsujikawa 2012-09-28 22:00:46 +09:00
parent 1fdc6e0a33
commit 1c57a3ff9f
11 changed files with 119 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/DefaultAuthResolver.h
View File

@ -45,8 +45,6 @@ public:
(const std::string& hostname);
};
typedef SharedHandle<DefaultAuthResolver> DefaultAuthResolverHandle;
} // namespace aria2
#endif // D_DEFAULT_AUTH_RESOLVER_H

2
src/DefaultBtInteractive.h
View File

@ -264,8 +264,6 @@ public:
}
};
typedef SharedHandle<DefaultBtInteractive> DefaultBtInteractiveHandle;
} // namespace aria2
#endif // D_DEFAULT_BT_INTERACTIVE_H

6
src/DefaultBtMessageDispatcher.h
View File

@ -69,7 +69,7 @@ public:
DefaultBtMessageDispatcher();
virtual ~DefaultBtMessageDispatcher();
virtual void addMessageToQueue(const SharedHandle<BtMessage>& btMessage);
virtual void addMessageToQueue
@ -100,7 +100,7 @@ public:
{
return requestSlots_.size();
}
virtual bool isOutstandingRequest(size_t index, size_t blockIndex);
virtual RequestSlot getOutstandingRequest
@ -145,8 +145,6 @@ public:
}
};
typedef SharedHandle<DefaultBtMessageDispatcher> DefaultBtMessageDispatcherHandle;
} // namespace aria2
#endif // D_DEFAULT_BT_MESSAGE_DISPATCHER_H

2
src/DefaultBtMessageReceiver.h
View File

@ -74,8 +74,6 @@ public:
void setBtMessageFactory(BtMessageFactory* factory);
};
typedef SharedHandle<DefaultBtMessageReceiver> DefaultBtMessageReceiverHandle;
} // namespace aria2
#endif // D_DEFAULT_BT_MESSAGE_RECEIVER_H

2
src/DefaultBtRequestFactory.h
View File

@ -105,8 +105,6 @@ public:
}
};
typedef SharedHandle<DefaultBtRequestFactory> DefaultBtRequestFactoryHandle;
} // namespace aria2
#endif // D_DEFAULT_BT_REQUEST_FACTORY_H

2
src/DefaultDiskWriter.h
View File

@ -48,8 +48,6 @@ public:
virtual void initAndOpenFile(int64_t totalLength = 0);
};
typedef SharedHandle<DefaultDiskWriter> DefaultDiskWriterHandle;
} // namespace aria2
#endif // D_DEFAULT_DISK_WRITER_H

2
src/DefaultDiskWriterFactory.h
View File

@ -47,8 +47,6 @@ public:
virtual SharedHandle<DiskWriter> newDiskWriter(const std::string& filename);
};
typedef SharedHandle<DefaultDiskWriterFactory> DefaultDiskWriterFactoryHandle;
} // namespace aria2
#endif // D_DEFAULT_DISK_WRITER_FACTORY_H

4
src/DefaultExtensionMessageFactory.h
View File

@ -98,15 +98,13 @@ public:
{
dispatcher_ = disp;
}
void setUTMetadataRequestTracker(UTMetadataRequestTracker* tracker)
{
tracker_ = tracker;
}
};
typedef SharedHandle<DefaultExtensionMessageFactory> DefaultExtensionMessageFactoryHandle;
} // namespace aria2
#endif // D_DEFAULT_EXTENSION_MESSAGE_FACTORY_H

2
src/DefaultPieceStorage.h
View File

@ -306,8 +306,6 @@ public:
}
};
typedef SharedHandle<DefaultPieceStorage> DefaultPieceStorageHandle;
} // namespace aria2
#endif // D_DEFAULT_PIECE_STORAGE_H

159
src/PeerInteractionCommand.cc
View File

@ -132,36 +132,42 @@ PeerInteractionCommand::PeerInteractionCommand
utMetadataRequestTracker.reset(new UTMetadataRequestTracker());
}
SharedHandle<DefaultExtensionMessageFactory> extensionMessageFactory
DefaultExtensionMessageFactory* extensionMessageFactoryPtr
(new DefaultExtensionMessageFactory(getPeer(), exMsgRegistry));
extensionMessageFactory->setPeerStorage(peerStorage);
extensionMessageFactory->setDownloadContext
extensionMessageFactoryPtr->setPeerStorage(peerStorage);
extensionMessageFactoryPtr->setDownloadContext
(requestGroup_->getDownloadContext());
extensionMessageFactory->setUTMetadataRequestTracker
extensionMessageFactoryPtr->setUTMetadataRequestTracker
(utMetadataRequestTracker.get());
// PieceStorage will be set later.
SharedHandle<ExtensionMessageFactory> extensionMessageFactory
(extensionMessageFactoryPtr);
SharedHandle<DefaultBtMessageFactory> factory(new DefaultBtMessageFactory());
factory->setCuid(cuid);
factory->setDownloadContext(requestGroup_->getDownloadContext());
factory->setPieceStorage(pieceStorage);
factory->setPeerStorage(peerStorage);
factory->setExtensionMessageFactory(extensionMessageFactory);
factory->setPeer(getPeer());
DefaultBtMessageFactory* factoryPtr(new DefaultBtMessageFactory());
factoryPtr->setCuid(cuid);
factoryPtr->setDownloadContext(requestGroup_->getDownloadContext());
factoryPtr->setPieceStorage(pieceStorage);
factoryPtr->setPeerStorage(peerStorage);
factoryPtr->setExtensionMessageFactory(extensionMessageFactory);
factoryPtr->setPeer(getPeer());
if(family == AF_INET) {
factory->setLocalNode(DHTRegistry::getData().localNode.get());
factory->setRoutingTable(DHTRegistry::getData().routingTable.get());
factory->setTaskQueue(DHTRegistry::getData().taskQueue.get());
factory->setTaskFactory(DHTRegistry::getData().taskFactory.get());
factoryPtr->setLocalNode(DHTRegistry::getData().localNode.get());
factoryPtr->setRoutingTable(DHTRegistry::getData().routingTable.get());
factoryPtr->setTaskQueue(DHTRegistry::getData().taskQueue.get());
factoryPtr->setTaskFactory(DHTRegistry::getData().taskFactory.get());
} else {
factory->setLocalNode(DHTRegistry::getData6().localNode.get());
factory->setRoutingTable(DHTRegistry::getData6().routingTable.get());
factory->setTaskQueue(DHTRegistry::getData6().taskQueue.get());
factory->setTaskFactory(DHTRegistry::getData6().taskFactory.get());
factoryPtr->setLocalNode(DHTRegistry::getData6().localNode.get());
factoryPtr->setRoutingTable(DHTRegistry::getData6().routingTable.get());
factoryPtr->setTaskQueue(DHTRegistry::getData6().taskQueue.get());
factoryPtr->setTaskFactory(DHTRegistry::getData6().taskFactory.get());
}
if(metadataGetMode) {
factory->enableMetadataGetMode();
factoryPtr->enableMetadataGetMode();
}
SharedHandle<BtMessageFactory> factory(factoryPtr);
PeerConnectionHandle peerConnection;
if(!passedPeerConnection) {
@ -183,91 +189,94 @@ PeerInteractionCommand::PeerInteractionCommand
1+(requestGroup_->getDownloadContext()->getNumPieces()+7)/8;
peerConnection->reserveBuffer(bitfieldPayloadSize);
SharedHandle<DefaultBtMessageDispatcher> dispatcher
(new DefaultBtMessageDispatcher());
dispatcher->setCuid(cuid);
dispatcher->setPeer(getPeer());
dispatcher->setDownloadContext(requestGroup_->getDownloadContext());
dispatcher->setPieceStorage(pieceStorage);
dispatcher->setPeerStorage(peerStorage);
dispatcher->setRequestTimeout(getOption()->getAsInt(PREF_BT_REQUEST_TIMEOUT));
dispatcher->setBtMessageFactory(factory.get());
dispatcher->setRequestGroupMan
DefaultBtMessageDispatcher* dispatcherPtr(new DefaultBtMessageDispatcher());
dispatcherPtr->setCuid(cuid);
dispatcherPtr->setPeer(getPeer());
dispatcherPtr->setDownloadContext(requestGroup_->getDownloadContext());
dispatcherPtr->setPieceStorage(pieceStorage);
dispatcherPtr->setPeerStorage(peerStorage);
dispatcherPtr->setRequestTimeout(getOption()->
getAsInt(PREF_BT_REQUEST_TIMEOUT));
dispatcherPtr->setBtMessageFactory(factoryPtr);
dispatcherPtr->setRequestGroupMan
(getDownloadEngine()->getRequestGroupMan().get());
SharedHandle<BtMessageDispatcher> dispatcher(dispatcherPtr);
DefaultBtMessageReceiverHandle receiver(new DefaultBtMessageReceiver());
receiver->setDownloadContext(requestGroup_->getDownloadContext());
receiver->setPeerConnection(peerConnection.get());
receiver->setDispatcher(dispatcher.get());
receiver->setBtMessageFactory(factory.get());
DefaultBtMessageReceiver* receiverPtr(new DefaultBtMessageReceiver());
receiverPtr->setDownloadContext(requestGroup_->getDownloadContext());
receiverPtr->setPeerConnection(peerConnection.get());
receiverPtr->setDispatcher(dispatcherPtr);
receiverPtr->setBtMessageFactory(factoryPtr);
SharedHandle<BtMessageReceiver> receiver(receiverPtr);
SharedHandle<DefaultBtRequestFactory> reqFactory
(new DefaultBtRequestFactory());
reqFactory->setPeer(getPeer());
reqFactory->setPieceStorage(pieceStorage);
reqFactory->setBtMessageDispatcher(dispatcher.get());
reqFactory->setBtMessageFactory(factory.get());
reqFactory->setCuid(cuid);
DefaultBtRequestFactory* reqFactoryPtr(new DefaultBtRequestFactory());
reqFactoryPtr->setPeer(getPeer());
reqFactoryPtr->setPieceStorage(pieceStorage);
reqFactoryPtr->setBtMessageDispatcher(dispatcherPtr);
reqFactoryPtr->setBtMessageFactory(factoryPtr);
reqFactoryPtr->setCuid(cuid);
SharedHandle<BtRequestFactory> reqFactory(reqFactoryPtr);
DefaultBtInteractiveHandle btInteractive
DefaultBtInteractive* btInteractivePtr
(new DefaultBtInteractive(requestGroup_->getDownloadContext(), getPeer()));
btInteractive->setBtRuntime(btRuntime_);
btInteractive->setPieceStorage(pieceStorage_);
btInteractive->setPeerStorage(peerStorage); // Note: Not a member variable.
btInteractive->setCuid(cuid);
btInteractive->setBtMessageReceiver(receiver);
btInteractive->setDispatcher(dispatcher);
btInteractive->setBtRequestFactory(reqFactory);
btInteractive->setPeerConnection(peerConnection);
btInteractive->setExtensionMessageFactory(extensionMessageFactory);
btInteractive->setExtensionMessageRegistry(exMsgRegistry);
btInteractive->setKeepAliveInterval
btInteractivePtr->setBtRuntime(btRuntime_);
btInteractivePtr->setPieceStorage(pieceStorage_);
btInteractivePtr->setPeerStorage(peerStorage); // Note: Not a member variable.
btInteractivePtr->setCuid(cuid);
btInteractivePtr->setBtMessageReceiver(receiver);
btInteractivePtr->setDispatcher(dispatcher);
btInteractivePtr->setBtRequestFactory(reqFactory);
btInteractivePtr->setPeerConnection(peerConnection);
btInteractivePtr->setExtensionMessageFactory(extensionMessageFactory);
btInteractivePtr->setExtensionMessageRegistry(exMsgRegistry);
btInteractivePtr->setKeepAliveInterval
(getOption()->getAsInt(PREF_BT_KEEP_ALIVE_INTERVAL));
btInteractive->setRequestGroupMan
btInteractivePtr->setRequestGroupMan
(getDownloadEngine()->getRequestGroupMan().get());
btInteractive->setBtMessageFactory(factory);
btInteractivePtr->setBtMessageFactory(factory);
if((metadataGetMode || !torrentAttrs->privateTorrent) &&
!getPeer()->isLocalPeer()) {
if(getOption()->getAsBool(PREF_ENABLE_PEER_EXCHANGE)) {
btInteractive->setUTPexEnabled(true);
btInteractivePtr->setUTPexEnabled(true);
}
if(family == AF_INET) {
if(DHTRegistry::isInitialized()) {
btInteractive->setDHTEnabled(true);
factory->setDHTEnabled(true);
btInteractive->setLocalNode(DHTRegistry::getData().localNode.get());
btInteractivePtr->setDHTEnabled(true);
factoryPtr->setDHTEnabled(true);
btInteractivePtr->setLocalNode(DHTRegistry::getData().localNode.get());
}
} else {
if(DHTRegistry::isInitialized6()) {
btInteractive->setDHTEnabled(true);
factory->setDHTEnabled(true);
btInteractive->setLocalNode(DHTRegistry::getData6().localNode.get());
btInteractivePtr->setDHTEnabled(true);
factoryPtr->setDHTEnabled(true);
btInteractivePtr->setLocalNode(DHTRegistry::getData6().localNode.get());
}
}
}
btInteractive->setUTMetadataRequestFactory(utMetadataRequestFactory);
btInteractive->setUTMetadataRequestTracker(utMetadataRequestTracker);
btInteractive->setTcpPort(e->getBtRegistry()->getTcpPort());
btInteractivePtr->setUTMetadataRequestFactory(utMetadataRequestFactory);
btInteractivePtr->setUTMetadataRequestTracker(utMetadataRequestTracker);
btInteractivePtr->setTcpPort(e->getBtRegistry()->getTcpPort());
if(metadataGetMode) {
btInteractive->enableMetadataGetMode();
btInteractivePtr->enableMetadataGetMode();
}
SharedHandle<BtInteractive> btInteractive(btInteractivePtr);
btInteractive_ = btInteractive;
// reverse depends
factory->setBtMessageDispatcher(dispatcher.get());
factory->setBtRequestFactory(reqFactory.get());
factory->setPeerConnection(peerConnection.get());
factoryPtr->setBtMessageDispatcher(dispatcherPtr);
factoryPtr->setBtRequestFactory(reqFactoryPtr);
factoryPtr->setPeerConnection(peerConnection.get());
extensionMessageFactory->setBtMessageDispatcher(dispatcher.get());
extensionMessageFactory->setBtMessageFactory(factory.get());
extensionMessageFactoryPtr->setBtMessageDispatcher(dispatcherPtr);
extensionMessageFactoryPtr->setBtMessageFactory(factoryPtr);
if(metadataGetMode) {
utMetadataRequestFactory->setCuid(cuid);
utMetadataRequestFactory->setDownloadContext
(requestGroup_->getDownloadContext());
utMetadataRequestFactory->setBtMessageDispatcher(dispatcher.get());
utMetadataRequestFactory->setBtMessageFactory(factory.get());
utMetadataRequestFactory->setBtMessageDispatcher(dispatcherPtr);
utMetadataRequestFactory->setBtMessageFactory(factoryPtr);
utMetadataRequestFactory->setPeer(getPeer());
utMetadataRequestFactory->setUTMetadataRequestTracker
(utMetadataRequestTracker.get());
@ -276,7 +285,7 @@ PeerInteractionCommand::PeerInteractionCommand
getPeer()->allocateSessionResource
(requestGroup_->getDownloadContext()->getPieceLength(),
requestGroup_->getDownloadContext()->getTotalLength());
getPeer()->setBtMessageDispatcher(dispatcher.get());
getPeer()->setBtMessageDispatcher(dispatcherPtr);
btRuntime_->increaseConnections();
requestGroup_->increaseNumCommand();

59
src/RequestGroup.cc
View File

@ -218,7 +218,7 @@ void RequestGroup::closeFile()
// that this function open file.
SharedHandle<CheckIntegrityEntry> RequestGroup::createCheckIntegrityEntry()
{
BtProgressInfoFileHandle infoFile
SharedHandle<BtProgressInfoFile> infoFile
(new DefaultBtProgressInfoFile(downloadContext_, pieceStorage_,
option_.get()));
SharedHandle<CheckIntegrityEntry> checkEntry;
@ -309,38 +309,42 @@ void RequestGroup::createInitialCommand
pieceStorage_->setupFileFilter();
}
}
SharedHandle<DefaultBtProgressInfoFile> progressInfoFile;
DefaultBtProgressInfoFile* progressInfoFilePtr = 0;
SharedHandle<BtProgressInfoFile> progressInfoFile;
if(!metadataGetMode) {
progressInfoFile.reset(new DefaultBtProgressInfoFile(downloadContext_,
pieceStorage_,
option_.get()));
progressInfoFilePtr = new DefaultBtProgressInfoFile(downloadContext_,
pieceStorage_,
option_.get());
progressInfoFile.reset(progressInfoFilePtr);
}
BtRuntimeHandle btRuntime(new BtRuntime());
btRuntime->setMaxPeers(option_->getAsInt(PREF_BT_MAX_PEERS));
btRuntime_ = btRuntime.get();
if(progressInfoFile) {
progressInfoFile->setBtRuntime(btRuntime);
if(progressInfoFilePtr) {
progressInfoFilePtr->setBtRuntime(btRuntime);
}
SharedHandle<DefaultPeerStorage> peerStorage(new DefaultPeerStorage());
peerStorage->setBtRuntime(btRuntime);
peerStorage->setPieceStorage(pieceStorage_);
peerStorage_ = peerStorage.get();
if(progressInfoFile) {
progressInfoFile->setPeerStorage(peerStorage);
DefaultPeerStorage* peerStoragePtr(new DefaultPeerStorage());
peerStoragePtr->setBtRuntime(btRuntime);
peerStoragePtr->setPieceStorage(pieceStorage_);
peerStorage_ = peerStoragePtr;
SharedHandle<PeerStorage> peerStorage(peerStoragePtr);
if(progressInfoFilePtr) {
progressInfoFilePtr->setPeerStorage(peerStorage);
}
SharedHandle<DefaultBtAnnounce> btAnnounce
DefaultBtAnnounce* btAnnouncePtr
(new DefaultBtAnnounce(downloadContext_, option_.get()));
btAnnounce->setBtRuntime(btRuntime);
btAnnounce->setPieceStorage(pieceStorage_);
btAnnounce->setPeerStorage(peerStorage);
btAnnounce->setUserDefinedInterval
btAnnouncePtr->setBtRuntime(btRuntime);
btAnnouncePtr->setPieceStorage(pieceStorage_);
btAnnouncePtr->setPeerStorage(peerStorage);
btAnnouncePtr->setUserDefinedInterval
(option_->getAsInt(PREF_BT_TRACKER_INTERVAL));
btAnnounce->shuffleAnnounce();
btAnnouncePtr->shuffleAnnounce();
SharedHandle<BtAnnounce> btAnnounce(btAnnouncePtr);
assert(!btRegistry->get(gid_));
btRegistry->put
(gid_, SharedHandle<BtObject>
@ -351,8 +355,7 @@ void RequestGroup::createInitialCommand
btAnnounce,
btRuntime,
(progressInfoFile ?
SharedHandle<BtProgressInfoFile>(progressInfoFile) :
progressInfoFile_))));
progressInfoFile : progressInfoFile_))));
if(metadataGetMode) {
if(option_->getAsBool(PREF_ENABLE_DHT) ||
(!e->getOption()->getAsBool(PREF_DISABLE_IPV6) &&
@ -508,7 +511,7 @@ void RequestGroup::createInitialCommand
if(downloadContext_->getFileEntries().size() > 1) {
pieceStorage_->setupFileFilter();
}
SharedHandle<DefaultBtProgressInfoFile> progressInfoFile
SharedHandle<BtProgressInfoFile> progressInfoFile
(new DefaultBtProgressInfoFile(downloadContext_,
pieceStorage_,
option_.get()));
@ -712,7 +715,8 @@ void RequestGroup::removeDefunctControlFile
}
}
void RequestGroup::loadAndOpenFile(const BtProgressInfoFileHandle& progressInfoFile)
void RequestGroup::loadAndOpenFile
(const SharedHandle<BtProgressInfoFile>& progressInfoFile)
{
try {
if(!isPreLocalFileCheckEnabled()) {
@ -1135,7 +1139,8 @@ void RequestGroup::setPieceStorage(const PieceStorageHandle& pieceStorage)
pieceStorage_ = pieceStorage;
}
void RequestGroup::setProgressInfoFile(const BtProgressInfoFileHandle& progressInfoFile)
void RequestGroup::setProgressInfoFile
(const SharedHandle<BtProgressInfoFile>& progressInfoFile)
{
progressInfoFile_ = progressInfoFile;
}