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

2010-02-28 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net> 

Use vector instead of deque for containers which is used for
	mostly read-only purpose.
pull/1/head
Tatsuhiro Tsujikawa 2010-02-28 12:30:11 +00:00
parent 135f0a2a8c
commit c342bde962
277 changed files with 1280 additions and 1232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ChangeLog
View File

@ -1,3 +1,8 @@
2010-02-28 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Use vector instead of deque for containers which is used for
mostly read-only purpose.
2010-02-28 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Fixed typo

6
src/AbstractBtMessage.cc
View File

@ -59,12 +59,10 @@ void AbstractBtMessage::setPeer(const SharedHandle<Peer>& peer)
this->peer = peer;
}
bool AbstractBtMessage::validate(std::deque<std::string>& errors)
void AbstractBtMessage::validate()
{
if(validator.get()) {
return validator->validate(errors);
} else {
return true;
validator->validate();
}
}

4
src/AbstractBtMessage.h
View File

@ -37,8 +37,6 @@
#include "BtMessage.h"
#include <deque>
namespace aria2 {
class PieceStorage;
@ -122,7 +120,7 @@ public:
virtual void doReceivedAction() {}
virtual bool validate(std::deque<std::string>& errors);
virtual void validate();
virtual void onQueued() {}

8
src/AbstractCommand.cc
View File

@ -255,7 +255,7 @@ void AbstractCommand::tryReserved() {
if(logger->debug()) {
logger->debug("CUID#%d - Trying reserved/pooled request.", cuid);
}
Commands commands;
std::vector<Command*> commands;
_requestGroup->createNextCommand(commands, e, 1);
e->setNoWait(true);
e->addCommand(commands);
@ -503,7 +503,7 @@ bool AbstractCommand::asyncResolveHostname()
}
}
const std::deque<std::string>& AbstractCommand::getResolvedAddresses()
const std::vector<std::string>& AbstractCommand::getResolvedAddresses()
{
return _asyncNameResolver->getResolvedAddresses();
}
@ -533,10 +533,10 @@ bool AbstractCommand::nameResolveFinished() const {
void AbstractCommand::prepareForNextAction(Command* nextCommand)
{
CheckIntegrityEntryHandle entry
SharedHandle<CheckIntegrityEntry> entry
(new StreamCheckIntegrityEntry(_requestGroup, nextCommand));
std::deque<Command*> commands;
std::vector<Command*> commands;
try {
_requestGroup->processCheckIntegrityEntry(commands, entry, e);
} catch(RecoverableException& e) {

4
src/AbstractCommand.h
View File

@ -63,7 +63,7 @@ protected:
SharedHandle<FileEntry> _fileEntry;
DownloadEngine* e;
SharedHandle<SocketCore> socket;
std::deque<SharedHandle<Segment> > _segments;
std::vector<SharedHandle<Segment> > _segments;
#ifdef ENABLE_ASYNC_DNS
SharedHandle<AsyncNameResolver> _asyncNameResolver;
@ -74,7 +74,7 @@ protected:
bool asyncResolveHostname();
const std::deque<std::string>& getResolvedAddresses();
const std::vector<std::string>& getResolvedAddresses();
#endif // ENABLE_ASYNC_DNS
void tryReserved();

4
src/AbstractProxyRequestCommand.cc
View File

@ -51,7 +51,7 @@ namespace aria2 {
AbstractProxyRequestCommand::AbstractProxyRequestCommand
(int cuid,
const RequestHandle& req,
const SharedHandle<Request>& req,
const SharedHandle<FileEntry>& fileEntry,
RequestGroup* requestGroup,
DownloadEngine* e,
@ -76,7 +76,7 @@ bool AbstractProxyRequestCommand::executeInternal() {
(socket, _connectedHostname, _connectedAddr, _connectedPort)) {
return true;
}
HttpRequestHandle httpRequest(new HttpRequest());
SharedHandle<HttpRequest> httpRequest(new HttpRequest());
httpRequest->setUserAgent(getOption()->get(PREF_USER_AGENT));
httpRequest->setRequest(req);
httpRequest->setProxyRequest(_proxyRequest);

4
src/AbstractProxyResponseCommand.cc
View File

@ -51,7 +51,7 @@ namespace aria2 {
AbstractProxyResponseCommand::AbstractProxyResponseCommand
(int cuid,
const RequestHandle& req,
const SharedHandle<Request>& req,
const SharedHandle<FileEntry>& fileEntry,
RequestGroup* requestGroup,
const HttpConnectionHandle& httpConnection,
@ -63,7 +63,7 @@ AbstractProxyResponseCommand::AbstractProxyResponseCommand
AbstractProxyResponseCommand::~AbstractProxyResponseCommand() {}
bool AbstractProxyResponseCommand::executeInternal() {
HttpResponseHandle httpResponse = httpConnection->receiveResponse();
SharedHandle<HttpResponse> httpResponse = httpConnection->receiveResponse();
if(httpResponse.isNull()) {
// the server has not responded our request yet.
e->commands.push_back(this);

4
src/ActivePeerConnectionCommand.cc
View File

@ -114,7 +114,7 @@ bool ActivePeerConnectionCommand::execute() {
for(unsigned int numAdd = numConnection;
numAdd > 0 && _peerStorage->isPeerAvailable(); --numAdd) {
PeerHandle peer = _peerStorage->getUnusedPeer();
SharedHandle<Peer> peer = _peerStorage->getUnusedPeer();
connectToPeer(peer);
}
if(_btRuntime->getConnections() == 0 &&
@ -127,7 +127,7 @@ bool ActivePeerConnectionCommand::execute() {
return false;
}
void ActivePeerConnectionCommand::connectToPeer(const PeerHandle& peer)
void ActivePeerConnectionCommand::connectToPeer(const SharedHandle<Peer>& peer)
{
if(peer.isNull()) {
return;

30
src/AnnounceList.cc
View File

@ -54,7 +54,8 @@ AnnounceList::AnnounceList(const BDE& announceList):
reconfigure(announceList);
}
AnnounceList::AnnounceList(const AnnounceTiers& announceTiers):
AnnounceList::AnnounceList
(const std::deque<SharedHandle<AnnounceTier> >& announceTiers):
tiers(announceTiers), currentTrackerInitialized(false) {
resetIterator();
}
@ -77,7 +78,7 @@ void AnnounceList::reconfigure(const BDE& announceList)
}
}
if(!urls.empty()) {
AnnounceTierHandle tier(new AnnounceTier(urls));
SharedHandle<AnnounceTier> tier(new AnnounceTier(urls));
tiers.push_back(tier);
}
}
@ -88,7 +89,7 @@ void AnnounceList::reconfigure(const BDE& announceList)
void AnnounceList::reconfigure(const std::string& url) {
std::deque<std::string> urls;
urls.push_back(url);
tiers.push_back(AnnounceTierHandle(new AnnounceTier(urls)));
tiers.push_back(SharedHandle<AnnounceTier>(new AnnounceTier(urls)));
resetIterator();
}
@ -171,7 +172,7 @@ std::string AnnounceList::getEventString() const {
class FindStoppedAllowedTier {
public:
bool operator()(const AnnounceTierHandle& tier) const {
bool operator()(const SharedHandle<AnnounceTier>& tier) const {
switch(tier->event) {
case AnnounceTier::DOWNLOADING:
case AnnounceTier::STOPPED:
@ -186,7 +187,7 @@ public:
class FindCompletedAllowedTier {
public:
bool operator()(const AnnounceTierHandle& tier) const {
bool operator()(const SharedHandle<AnnounceTier>& tier) const {
switch(tier->event) {
case AnnounceTier::DOWNLOADING:
case AnnounceTier::COMPLETED:
@ -205,7 +206,8 @@ size_t AnnounceList::countCompletedAllowedTier() const {
return count_if(tiers.begin(), tiers.end(), FindCompletedAllowedTier());
}
void AnnounceList::setCurrentTier(const AnnounceTiers::iterator& itr) {
void AnnounceList::setCurrentTier
(const std::deque<SharedHandle<AnnounceTier> >::iterator& itr) {
if(itr != tiers.end()) {
currentTier = itr;
currentTracker = (*currentTier)->urls.begin();
@ -224,21 +226,23 @@ find_wrap_if(InputIterator first, InputIterator last,
}
void AnnounceList::moveToStoppedAllowedTier() {
AnnounceTiers::iterator itr = find_wrap_if(tiers.begin(), tiers.end(),
currentTier,
FindStoppedAllowedTier());
std::deque<SharedHandle<AnnounceTier> >::iterator itr =
find_wrap_if(tiers.begin(), tiers.end(),
currentTier,
FindStoppedAllowedTier());
setCurrentTier(itr);
}
void AnnounceList::moveToCompletedAllowedTier() {
AnnounceTiers::iterator itr = find_wrap_if(tiers.begin(), tiers.end(),
currentTier,
FindCompletedAllowedTier());
std::deque<SharedHandle<AnnounceTier> >::iterator itr =
find_wrap_if(tiers.begin(), tiers.end(),
currentTier,
FindCompletedAllowedTier());
setCurrentTier(itr);
}
void AnnounceList::shuffle() {
for(AnnounceTiers::iterator itr = tiers.begin();
for(std::deque<SharedHandle<AnnounceTier> >::iterator itr = tiers.begin();
itr != tiers.end(); ++itr) {
std::deque<std::string>& urls = (*itr)->urls;
std::random_shuffle(urls.begin(), urls.end(),

3
src/AnnounceTier.h
View File

@ -93,9 +93,6 @@ public:
}
};
typedef SharedHandle<AnnounceTier> AnnounceTierHandle;
typedef std::deque<AnnounceTierHandle> AnnounceTiers;
} // namespace aria2
#endif // _D_ANNOUNCE_TIER_H_

6
src/AsyncNameResolver.h
View File

@ -38,7 +38,7 @@
#include "common.h"
#include <string>
#include <deque>
#include <vector>
#include <ares.h>
@ -65,7 +65,7 @@ private:
STATUS status;
ares_channel channel;
std::deque<std::string> _resolvedAddresses;
std::vector<std::string> _resolvedAddresses;
std::string error;
std::string _hostname;
public:
@ -75,7 +75,7 @@ public:
void resolve(const std::string& name);
const std::deque<std::string>& getResolvedAddresses() const
const std::vector<std::string>& getResolvedAddresses() const
{
return _resolvedAddresses;
}

2
src/AuthConfigFactory.cc
View File

@ -162,7 +162,7 @@ AuthResolverHandle AuthConfigFactory::createFtpAuthResolver
return resolver;
}
void AuthConfigFactory::setNetrc(const NetrcHandle& netrc)
void AuthConfigFactory::setNetrc(const SharedHandle<Netrc>& netrc)
{
_netrc = netrc;
}

4
src/BDE.h
View File

@ -39,7 +39,7 @@
#include <map>
#include <string>
#include <deque>
#include <vector>
#include "SharedHandle.h"
#include "DlAbortEx.h"
@ -51,7 +51,7 @@ class BDE;
class BDE {
public:
typedef std::map<std::string, BDE> Dict;
typedef std::deque<BDE> List;
typedef std::vector<BDE> List;
typedef int64_t Integer;
private:
enum TYPE{

16
src/BNode.cc
View File

@ -33,11 +33,13 @@
*/
/* copyright --> */
#include "BNode.h"
#include "DHTBucket.h"
#include "DHTNode.h"
#include <functional>
#include <algorithm>
#include "DHTBucket.h"
#include "DHTNode.h"
namespace aria2 {
BNode::BNode(const SharedHandle<DHTBucket>& bucket):
@ -114,7 +116,7 @@ SharedHandle<DHTBucket> BNode::findBucketFor(BNode* b, const unsigned char* key)
}
void BNode::findClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
void BNode::findClosestKNodes(std::vector<SharedHandle<DHTNode> >& nodes,
BNode* b, const unsigned char* key)
{
BNode* bnode = findBNodeFor(b, key);
@ -128,7 +130,7 @@ void BNode::findClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
if(nodes.size() >= DHTBucket::K) {
return;
}
std::deque<const BNode*> visited;
std::vector<const BNode*> visited;
visited.push_back(bnode);
BNode* up = bnode->getUp();
@ -163,7 +165,7 @@ void BNode::findClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
{
SharedHandle<DHTBucket> bucket = bnode->getBucket();
if(!bucket.isNull()) {
std::deque<SharedHandle<DHTNode> > goodNodes;
std::vector<SharedHandle<DHTNode> > goodNodes;
bucket->getGoodNodes(goodNodes);
size_t r = DHTBucket::K-nodes.size();
if(goodNodes.size() <= r) {
@ -176,10 +178,10 @@ void BNode::findClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
}
}
void BNode::enumerateBucket(std::deque<SharedHandle<DHTBucket> >& buckets,
void BNode::enumerateBucket(std::vector<SharedHandle<DHTBucket> >& buckets,
const BNode* b)
{
std::deque<const BNode*> visited;
std::vector<const BNode*> visited;
visited.push_back(b);
while(1) {
if(!b) {

8
src/BNode.h
View File

@ -36,8 +36,10 @@
#define _D_BNODE_H_
#include "common.h"
#include <vector>
#include "SharedHandle.h"
#include <deque>
namespace aria2 {
@ -93,10 +95,10 @@ public:
static SharedHandle<DHTBucket> findBucketFor(BNode* b, const unsigned char* key);
static void findClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
static void findClosestKNodes(std::vector<SharedHandle<DHTNode> >& nodes,
BNode* b, const unsigned char* key);
static void enumerateBucket(std::deque<SharedHandle<DHTBucket> >& buckets,
static void enumerateBucket(std::vector<SharedHandle<DHTBucket> >& buckets,
const BNode* b);
};

5
src/BitfieldMan.h
View File

@ -36,10 +36,11 @@
#define _D_BITFIELD_MAN_H_
#include "common.h"
#include "SharedHandle.h"
#include <deque>
#include <vector>
#include "SharedHandle.h"
namespace aria2 {
class BitfieldMan {

5
src/BtBitfieldMessageValidator.h
View File

@ -51,12 +51,11 @@ public:
message(message),
numPiece(numPiece) {}
virtual bool validate(Errors& error) {
// TODO
virtual void validate()
{
bittorrent::checkBitfield(message->getBitfield(),
message->getBitfieldLength(),
numPiece);
return true;
}
};

8
src/BtCheckIntegrityEntry.cc
View File

@ -49,8 +49,8 @@ BtCheckIntegrityEntry::BtCheckIntegrityEntry(RequestGroup* requestGroup):
BtCheckIntegrityEntry::~BtCheckIntegrityEntry() {}
void BtCheckIntegrityEntry::onDownloadIncomplete(std::deque<Command*>& commands,
DownloadEngine* e)
void BtCheckIntegrityEntry::onDownloadIncomplete
(std::vector<Command*>& commands, DownloadEngine* e)
{
const SharedHandle<DiskAdaptor>& diskAdaptor =
_requestGroup->getPieceStorage()->getDiskAdaptor();
@ -65,8 +65,8 @@ void BtCheckIntegrityEntry::onDownloadIncomplete(std::deque<Command*>& commands,
proceedFileAllocation(commands, entry, e);
}
void BtCheckIntegrityEntry::onDownloadFinished(std::deque<Command*>& commands,
DownloadEngine* e)
void BtCheckIntegrityEntry::onDownloadFinished
(std::vector<Command*>& commands, DownloadEngine* e)
{
// TODO Currently,when all the checksums
// are valid, then aira2 goes to seeding mode. Sometimes it is better

4
src/BtCheckIntegrityEntry.h
View File

@ -45,10 +45,10 @@ public:
virtual ~BtCheckIntegrityEntry();
virtual void onDownloadFinished(std::deque<Command*>& commands,
virtual void onDownloadFinished(std::vector<Command*>& commands,
DownloadEngine* e);
virtual void onDownloadIncomplete(std::deque<Command*>& commands,
virtual void onDownloadIncomplete(std::vector<Command*>& commands,
DownloadEngine* e);
};

8
src/BtDependency.cc
View File

@ -51,8 +51,8 @@
namespace aria2 {
BtDependency::BtDependency(const RequestGroupWeakHandle& dependant,
const RequestGroupHandle& dependee):
BtDependency::BtDependency(const WeakHandle<RequestGroup>& dependant,
const SharedHandle<RequestGroup>& dependee):
_dependant(dependant),
_dependee(dependee),
_logger(LogFactory::getInstance()) {}
@ -74,13 +74,13 @@ static void copyValues(const SharedHandle<FileEntry>& d,
bool BtDependency::resolve()
{
if(_dependee->getNumCommand() == 0 && _dependee->downloadFinished()) {
RequestGroupHandle dependee = _dependee;
SharedHandle<RequestGroup> dependee = _dependee;
// cut reference here
_dependee.reset();
SharedHandle<DownloadContext> context(new DownloadContext());
context->setDir(_dependant->getDownloadContext()->getDir());
try {
DiskAdaptorHandle diskAdaptor =
SharedHandle<DiskAdaptor> diskAdaptor =
dependee->getPieceStorage()->getDiskAdaptor();
diskAdaptor->openExistingFile();
std::string content = util::toString(diskAdaptor);

2
src/BtExtendedMessage.cc
View File

@ -99,7 +99,7 @@ std::string BtExtendedMessage::toString() const {
BtExtendedMessageHandle
BtExtendedMessage::create(const SharedHandle<ExtensionMessageFactory>& factory,
const PeerHandle& peer,
const SharedHandle<Peer>& peer,
const unsigned char* data, size_t dataLength)
{
bittorrent::assertPayloadLengthGreater(1, dataLength, NAME);

4
src/BtFileAllocationEntry.cc
View File

@ -49,8 +49,8 @@ BtFileAllocationEntry::BtFileAllocationEntry(RequestGroup* requestGroup):
BtFileAllocationEntry::~BtFileAllocationEntry() {}
void BtFileAllocationEntry::prepareForNextAction(std::deque<Command*>& commands,
DownloadEngine* e)
void BtFileAllocationEntry::prepareForNextAction
(std::vector<Command*>& commands, DownloadEngine* e)
{
BtSetup().setup(commands, _requestGroup, e, _requestGroup->getOption().get());
if(!_requestGroup->downloadFinished()) {

2
src/BtFileAllocationEntry.h
View File

@ -45,7 +45,7 @@ public:
virtual ~BtFileAllocationEntry();
virtual void prepareForNextAction(std::deque<Command*>& commands,
virtual void prepareForNextAction(std::vector<Command*>& commands,
DownloadEngine* e);
};

5
src/BtHandshakeMessageValidator.h
View File

@ -57,8 +57,8 @@ public:
memcpy(this->infoHash, infoHash, sizeof(this->infoHash));
}
virtual bool validate(Errors& error) {
// TODO
virtual void validate()
{
if(message->getPstrlen() != 19) {
throw DL_ABORT_EX(StringFormat("invalid handshake pstrlen=%u",
message->getPstrlen()).str());
@ -74,7 +74,6 @@ public:
util::toHex(infoHash, 20).c_str(),
util::toHex(message->getInfoHash(), 20).c_str()).str());
}
return true;
}
};

17
src/BtLeecherStateChoke.cc
View File

@ -120,12 +120,12 @@ public:
};
void BtLeecherStateChoke::plannedOptimisticUnchoke
(std::deque<PeerEntry>& peerEntries)
(std::vector<PeerEntry>& peerEntries)
{
std::for_each(peerEntries.begin(), peerEntries.end(),
std::mem_fun_ref(&PeerEntry::disableOptUnchoking));
std::deque<PeerEntry>::iterator i =
std::vector<PeerEntry>::iterator i =
std::partition(peerEntries.begin(), peerEntries.end(),
PeerFilter(true, true));
if(i != peerEntries.begin()) {
@ -136,9 +136,9 @@ void BtLeecherStateChoke::plannedOptimisticUnchoke
}
}
void BtLeecherStateChoke::regularUnchoke(std::deque<PeerEntry>& peerEntries)
void BtLeecherStateChoke::regularUnchoke(std::vector<PeerEntry>& peerEntries)
{
std::deque<PeerEntry>::iterator rest =
std::vector<PeerEntry>::iterator rest =
std::partition(peerEntries.begin(), peerEntries.end(),
std::mem_fun_ref(&PeerEntry::isRegularUnchoker));
@ -151,7 +151,7 @@ void BtLeecherStateChoke::regularUnchoke(std::deque<PeerEntry>& peerEntries)
int count = 3;
bool fastOptUnchoker = false;
std::deque<PeerEntry>::iterator peerIter = peerEntries.begin();
std::vector<PeerEntry>::iterator peerIter = peerEntries.begin();
for(;peerIter != rest && count; ++peerIter, --count) {
(*peerIter).disableChokingRequired();
_logger->info("RU: %s, dlspd=%u",
@ -165,7 +165,7 @@ void BtLeecherStateChoke::regularUnchoke(std::deque<PeerEntry>& peerEntries)
if(fastOptUnchoker) {
std::random_shuffle(peerIter, peerEntries.end(),
*(SimpleRandomizer::getInstance().get()));
for(std::deque<PeerEntry>::iterator i = peerIter; i != peerEntries.end();
for(std::vector<PeerEntry>::iterator i = peerIter; i != peerEntries.end();
++i) {
if((*i).getPeer()->peerInterested()) {
(*i).enableOptUnchoking();
@ -196,12 +196,13 @@ public:
};
void
BtLeecherStateChoke::executeChoke(const std::deque<SharedHandle<Peer> >& peerSet)
BtLeecherStateChoke::executeChoke
(const std::vector<SharedHandle<Peer> >& peerSet)
{
_logger->info("Leecher state, %d choke round started", _round);
_lastRound.reset();
std::deque<PeerEntry> peerEntries;
std::vector<PeerEntry> peerEntries;
std::transform(peerSet.begin(), peerSet.end(),
std::back_inserter(peerEntries),
BtLeecherStateChokeGenPeerEntry());

8
src/BtLeecherStateChoke.h
View File

@ -37,7 +37,7 @@
#include "common.h"
#include <deque>
#include <vector>
#include "SharedHandle.h"
#include "TimeA2.h"
@ -82,9 +82,9 @@ private:
void disableOptUnchoking();
};
void plannedOptimisticUnchoke(std::deque<PeerEntry>& peerEntries);
void plannedOptimisticUnchoke(std::vector<PeerEntry>& peerEntries);
void regularUnchoke(std::deque<PeerEntry>& peerEntries);
void regularUnchoke(std::vector<PeerEntry>& peerEntries);
friend class PeerFilter;
friend class BtLeecherStateChokeGenPeerEntry;
@ -93,7 +93,7 @@ public:
~BtLeecherStateChoke();
void executeChoke(const std::deque<SharedHandle<Peer> >& peerSet);
void executeChoke(const std::vector<SharedHandle<Peer> >& peerSet);
const Time& getLastRound() const;
};

4
src/BtMessage.h
View File

@ -38,7 +38,6 @@
#include "common.h"
#include <string>
#include <deque>
#include "SharedHandle.h"
#include "BtAbortOutstandingRequestEvent.h"
@ -69,7 +68,7 @@ public:
virtual void send() = 0;
virtual bool validate(std::deque<std::string>& errors) = 0;
virtual void validate() = 0;
virtual void onAbortOutstandingRequestEvent
(const BtAbortOutstandingRequestEvent& event) = 0;
@ -86,7 +85,6 @@ public:
};
typedef SharedHandle<BtMessage> BtMessageHandle;
typedef std::deque<BtMessageHandle> BtMessages;
} // namespace aria2

6
src/BtMessageDispatcher.h
View File

@ -36,9 +36,11 @@
#define _D_BT_MESSAGE_DISPATCHER_H_
#include "common.h"
#include <vector>
#include "SharedHandle.h"
#include "RequestSlot.h"
#include <deque>
namespace aria2 {
@ -52,7 +54,7 @@ public:
virtual void addMessageToQueue(const SharedHandle<BtMessage>& btMessage) = 0;
virtual void
addMessageToQueue(const std::deque<SharedHandle<BtMessage> >& btMessages) = 0;
addMessageToQueue(const std::vector<SharedHandle<BtMessage> >& btMessages) =0;
virtual void sendMessages() = 0;

10
src/BtMessageValidator.h
View File

@ -36,19 +36,19 @@
#define _D_BT_MESSAGE_VALIDATOR_H_
#include "common.h"
#include "SharedHandle.h"
#include <string>
#include <deque>
#include "SharedHandle.h"
namespace aria2 {
typedef std::deque<std::string> Errors;
class BtMessageValidator {
public:
virtual ~BtMessageValidator() {}
virtual bool validate(Errors& errors) = 0;
// Throws RecoverableException on error.
virtual void validate() = 0;
};
typedef SharedHandle<BtMessageValidator> BtMessageValidatorHandle;

10
src/BtPieceMessage.cc
View File

@ -86,7 +86,7 @@ void BtPieceMessage::doReceivedAction() {
peer->updateDownloadLength(blockLength);
if(!RequestSlot::isNull(slot)) {
peer->snubbing(false);
PieceHandle piece = pieceStorage->getPiece(index);
SharedHandle<Piece> piece = pieceStorage->getPiece(index);
off_t offset = (off_t)index*_downloadContext->getPieceLength()+begin;
if(logger->debug()) {
logger->debug(MSG_PIECE_RECEIVED,
@ -183,7 +183,7 @@ std::string BtPieceMessage::toString() const {
util::itos(begin), ", length=", util::itos(blockLength));
}
bool BtPieceMessage::checkPieceHash(const PieceHandle& piece) {
bool BtPieceMessage::checkPieceHash(const SharedHandle<Piece>& piece) {
if(piece->isHashCalculated()) {
if(logger->debug()) {
logger->debug("Hash is available!! index=%lu",
@ -199,13 +199,13 @@ bool BtPieceMessage::checkPieceHash(const PieceHandle& piece) {
}
}
void BtPieceMessage::onNewPiece(const PieceHandle& piece) {
void BtPieceMessage::onNewPiece(const SharedHandle<Piece>& piece) {
logger->info(MSG_GOT_NEW_PIECE, cuid, piece->getIndex());
pieceStorage->completePiece(piece);
pieceStorage->advertisePiece(cuid, piece->getIndex());
}
void BtPieceMessage::onWrongPiece(const PieceHandle& piece) {
void BtPieceMessage::onWrongPiece(const SharedHandle<Piece>& piece) {
logger->info(MSG_GOT_WRONG_PIECE, cuid, piece->getIndex());
erasePieceOnDisk(piece);
piece->clearAllBlock();
@ -213,7 +213,7 @@ void BtPieceMessage::onWrongPiece(const PieceHandle& piece) {
requestFactory->removeTargetPiece(piece);
}
void BtPieceMessage::erasePieceOnDisk(const PieceHandle& piece) {
void BtPieceMessage::erasePieceOnDisk(const SharedHandle<Piece>& piece) {
size_t BUFSIZE = 4096;
unsigned char buf[BUFSIZE];
memset(buf, 0, BUFSIZE);

5
src/BtPieceMessageValidator.h
View File

@ -54,11 +54,10 @@ public:
numPiece(numPiece),
pieceLength(pieceLength) {}
virtual bool validate(Errors& error) {
// TODO
virtual void validate()
{
bittorrent::checkIndex(message->getIndex(), numPiece);
bittorrent::checkBegin(message->getBegin(), pieceLength);
return true;
}
};

6
src/BtPostDownloadHandler.cc
View File

@ -63,7 +63,7 @@ BtPostDownloadHandler::BtPostDownloadHandler()
BtPostDownloadHandler::~BtPostDownloadHandler() {}
void BtPostDownloadHandler::getNextRequestGroups
(std::deque<SharedHandle<RequestGroup> >& groups,
(std::vector<SharedHandle<RequestGroup> >& groups,
RequestGroup* requestGroup)
{
_logger->info("Generating RequestGroups for Torrent file %s",
@ -77,9 +77,9 @@ void BtPostDownloadHandler::getNextRequestGroups
requestGroup->getPieceStorage()->getDiskAdaptor()->closeFile();
throw;
}
std::deque<SharedHandle<RequestGroup> > newRgs;
std::vector<SharedHandle<RequestGroup> > newRgs;
createRequestGroupForBitTorrent(newRgs, requestGroup->getOption(),
std::deque<std::string>(),
std::vector<std::string>(),
content);
requestGroup->followedBy(newRgs.begin(), newRgs.end());
groups.insert(groups.end(), newRgs.begin(), newRgs.end());

4
src/BtPostDownloadHandler.h
View File

@ -47,12 +47,10 @@ public:
virtual ~BtPostDownloadHandler();
virtual void
getNextRequestGroups(std::deque<SharedHandle<RequestGroup> >& groups,
getNextRequestGroups(std::vector<SharedHandle<RequestGroup> >& groups,
RequestGroup* requestGroup);
};
typedef SharedHandle<BtPostDownloadHandler> BtPostDownloadHandlerHandle;
} // namespace aria2
#endif // _D_BT_POST_DOWNLOAD_HANDLER_H_

10
src/BtRequestFactory.h
View File

@ -36,8 +36,10 @@
#define _D_BT_REQUEST_FACTORY_H_
#include "common.h"
#include <vector>
#include "SharedHandle.h"
#include <deque>
namespace aria2 {
@ -68,20 +70,20 @@ public:
* The number of objects returned is capped by max.
*/
virtual void createRequestMessages
(std::deque<SharedHandle<BtMessage> >& requests, size_t max) = 0;
(std::vector<SharedHandle<BtMessage> >& requests, size_t max) = 0;
/**
* Use this method in end game mode.
*
*/
virtual void createRequestMessagesOnEndGame
(std::deque<SharedHandle<BtMessage> >& requests, size_t max) = 0;
(std::vector<SharedHandle<BtMessage> >& requests, size_t max) = 0;
/**
* Stores the list of index of pieces added using addTargetPiece() into
* indexes.
*/
virtual void getTargetPieceIndexes(std::deque<size_t>& indexes) const = 0;
virtual void getTargetPieceIndexes(std::vector<size_t>& indexes) const = 0;
};

9
src/BtSeederStateChoke.cc
View File

@ -83,13 +83,13 @@ void BtSeederStateChoke::PeerEntry::disableOptUnchoking()
}
void BtSeederStateChoke::unchoke
(std::deque<BtSeederStateChoke::PeerEntry>& peers)
(std::vector<BtSeederStateChoke::PeerEntry>& peers)
{
int count = (_round == 2) ? 4 : 3;
std::sort(peers.begin(), peers.end());
std::deque<PeerEntry>::iterator r = peers.begin();
std::vector<PeerEntry>::iterator r = peers.begin();
for(; r != peers.end() && count; ++r, --count) {
(*r).getPeer()->chokingRequired(false);
_logger->info("RU: %s, ulspd=%u", (*r).getPeer()->ipaddr.c_str(),
@ -140,12 +140,13 @@ public:
};
void
BtSeederStateChoke::executeChoke(const std::deque<SharedHandle<Peer> >& peerSet)
BtSeederStateChoke::executeChoke
(const std::vector<SharedHandle<Peer> >& peerSet)
{
_logger->info("Seeder state, %d choke round started", _round);
_lastRound.reset();
std::deque<PeerEntry> peerEntries;
std::vector<PeerEntry> peerEntries;
std::for_each(peerSet.begin(), peerSet.end(), ChokingRequired());

6
src/BtSeederStateChoke.h
View File

@ -37,7 +37,7 @@
#include "common.h"
#include <deque>
#include <vector>
#include "SharedHandle.h"
#include "TimeA2.h"
@ -76,7 +76,7 @@ private:
void disableOptUnchoking();
};
void unchoke(std::deque<PeerEntry>& peers);
void unchoke(std::vector<PeerEntry>& peers);
friend class GenPeerEntry;
friend class NotInterestedPeer;
@ -85,7 +85,7 @@ public:
~BtSeederStateChoke();
void executeChoke(const std::deque<SharedHandle<Peer> >& peerSet);
void executeChoke(const std::vector<SharedHandle<Peer> >& peerSet);
const Time& getLastRound() const { return _lastRound; }
};

2
src/BtSetup.cc
View File

@ -74,7 +74,7 @@ namespace aria2 {
BtSetup::BtSetup():_logger(LogFactory::getInstance()) {}
void BtSetup::setup(std::deque<Command*>& commands,
void BtSetup::setup(std::vector<Command*>& commands,
RequestGroup* requestGroup,
DownloadEngine* e,
const Option* option)

4
src/BtSetup.h
View File

@ -36,7 +36,7 @@
#define _D_BT_SETUP_H_
#include "common.h"
#include <deque>
#include <vector>
namespace aria2 {
@ -52,7 +52,7 @@ private:
public:
BtSetup();
void setup(std::deque<Command*>& commands,
void setup(std::vector<Command*>& commands,
RequestGroup* requestGroup,
DownloadEngine* e,
const Option* option);

6
src/CheckIntegrityCommand.cc
View File

@ -47,7 +47,7 @@ namespace aria2 {
CheckIntegrityCommand::CheckIntegrityCommand
(int32_t cuid, RequestGroup* requestGroup, DownloadEngine* e,
const CheckIntegrityEntryHandle& entry):
const SharedHandle<CheckIntegrityEntry>& entry):
RealtimeCommand(cuid, requestGroup, e),
_entry(entry)
{}
@ -69,7 +69,7 @@ bool CheckIntegrityCommand::executeInternal()
if(_requestGroup->downloadFinished()) {
logger->notice(MSG_VERIFICATION_SUCCESSFUL,
_requestGroup->getDownloadContext()->getBasePath().c_str());
std::deque<Command*> commands;
std::vector<Command*> commands;
try {
_entry->onDownloadFinished(commands, _e);
} catch(RecoverableException& e) {
@ -80,7 +80,7 @@ bool CheckIntegrityCommand::executeInternal()
} else {
logger->error(MSG_VERIFICATION_FAILED,
_requestGroup->getDownloadContext()->getBasePath().c_str());
std::deque<Command*> commands;
std::vector<Command*> commands;
try {
_entry->onDownloadIncomplete(commands,_e);
} catch(RecoverableException& e) {

2
src/CheckIntegrityEntry.cc
View File

@ -86,7 +86,7 @@ void CheckIntegrityEntry::cutTrailingGarbage()
}
void CheckIntegrityEntry::proceedFileAllocation
(std::deque<Command*>& commands,
(std::vector<Command*>& commands,
const SharedHandle<FileAllocationEntry>& entry,
DownloadEngine* e)
{

12
src/CheckIntegrityEntry.h
View File

@ -37,7 +37,8 @@
#include "RequestGroupEntry.h"
#include "ProgressAwareEntry.h"
#include <deque>
#include <vector>
namespace aria2 {
@ -50,7 +51,7 @@ class CheckIntegrityEntry : public RequestGroupEntry,
protected:
SharedHandle<IteratableValidator> _validator;
void proceedFileAllocation(std::deque<Command*>& commands,
void proceedFileAllocation(std::vector<Command*>& commands,
const SharedHandle<FileAllocationEntry>& entry,
DownloadEngine* e);
public:
@ -70,18 +71,15 @@ public:
virtual void initValidator() = 0;
virtual void onDownloadFinished(std::deque<Command*>& commands,
virtual void onDownloadFinished(std::vector<Command*>& commands,
DownloadEngine* e) = 0;
virtual void onDownloadIncomplete(std::deque<Command*>& commands,
virtual void onDownloadIncomplete(std::vector<Command*>& commands,
DownloadEngine* e) = 0;
void cutTrailingGarbage();
};
typedef SharedHandle<CheckIntegrityEntry> CheckIntegrityEntryHandle;
typedef std::deque<CheckIntegrityEntryHandle> CheckIntegrityEntries;
} // namespace aria2
#endif // _D_CHECK_INTEGRITY_ENTRY_H_

8
src/ChecksumCheckIntegrityEntry.cc
View File

@ -62,13 +62,13 @@ void ChecksumCheckIntegrityEntry::initValidator()
}
void
ChecksumCheckIntegrityEntry::onDownloadFinished(std::deque<Command*>& commands,
DownloadEngine* e)
ChecksumCheckIntegrityEntry::onDownloadFinished
(std::vector<Command*>& commands, DownloadEngine* e)
{}
void
ChecksumCheckIntegrityEntry::onDownloadIncomplete(std::deque<Command*>& commands,
DownloadEngine* e)
ChecksumCheckIntegrityEntry::onDownloadIncomplete
(std::vector<Command*>& commands, DownloadEngine* e)
{}
} // namespace aria2

4
src/ChecksumCheckIntegrityEntry.h
View File

@ -50,10 +50,10 @@ public:
virtual void initValidator();
virtual void onDownloadFinished(std::deque<Command*>& commands,
virtual void onDownloadFinished(std::vector<Command*>& commands,
DownloadEngine* e);
virtual void onDownloadIncomplete(std::deque<Command*>& commands,
virtual void onDownloadIncomplete(std::vector<Command*>& commands,
DownloadEngine* e);
};

3
src/Command.h
View File

@ -37,7 +37,6 @@
#include "common.h"
#include <stdint.h>
#include <deque>
namespace aria2 {
@ -105,8 +104,6 @@ public:
void clearIOEvents();
};
typedef std::deque<Command*> Commands;
} // namespace aria2
#endif // _D_COMMAND_H_

8
src/ConsoleStatCalc.cc
View File

@ -120,7 +120,7 @@ static void printProgress
SharedHandle<PeerStorage> ps =
e->getBtRegistry()->get(rg->getGID())._peerStorage;
if(!ps.isNull()) {
std::deque<SharedHandle<Peer> > peers;
std::vector<SharedHandle<Peer> > peers;
ps->getActivePeers(peers);
o << " " << "SEED:"
<< countSeeder(peers.begin(), peers.end());
@ -250,7 +250,8 @@ ConsoleStatCalc::calculateStat(const DownloadEngine* e)
std::cout << "\n";
}
RequestGroupHandle firstRequestGroup = e->_requestGroupMan->getRequestGroup(0);
SharedHandle<RequestGroup> firstRequestGroup =
e->_requestGroupMan->getRequestGroup(0);
printProgress(o, firstRequestGroup, e, sizeFormatter);
@ -297,7 +298,8 @@ ConsoleStatCalc::calculateStat(const DownloadEngine* e)
}
#ifdef ENABLE_MESSAGE_DIGEST
{
CheckIntegrityEntryHandle entry = e->_checkIntegrityMan->getPickedEntry();
SharedHandle<CheckIntegrityEntry> entry =
e->_checkIntegrityMan->getPickedEntry();
if(!entry.isNull()) {
o << " "
<< "[Checksum:"

3
src/Cookie.h
View File

@ -38,7 +38,6 @@
#include "common.h"
#include <string>
#include <deque>
#include "a2time.h"
@ -155,8 +154,6 @@ public:
static std::string normalizeDomain(const std::string& domain);
};
typedef std::deque<Cookie> Cookies;
} // namespace aria2
#endif // _D_COOKIE_H_

18
src/CookieStorage.cc
View File

@ -140,14 +140,6 @@ bool CookieStorage::store(const Cookie& cookie)
return added;
}
void CookieStorage::storeCookies(const std::deque<Cookie>& cookies)
{
for(std::deque<Cookie>::const_iterator i = cookies.begin();
i != cookies.end(); ++i) {
store(*i);
}
}
bool CookieStorage::parseAndStore(const std::string& setCookieString,
const std::string& requestHost,
const std::string& requestPath)
@ -240,11 +232,11 @@ bool CookieStorage::contains(const Cookie& cookie) const
}
}
std::deque<Cookie> CookieStorage::criteriaFind(const std::string& requestHost,
std::vector<Cookie> CookieStorage::criteriaFind(const std::string& requestHost,
const std::string& requestPath,
time_t date, bool secure)
{
std::deque<Cookie> res;
std::vector<Cookie> res;
bool numericHost = util::isNumericHost(requestHost);
searchCookieByDomainSuffix
((!numericHost && requestHost.find(A2STR::DOT_C) == std::string::npos)?
@ -307,14 +299,16 @@ bool CookieStorage::load(const std::string& filename)
try {
if(std::string(header) == "SQLite format 3") {
#ifdef HAVE_SQLITE3
storeCookies(Sqlite3MozCookieParser().parse(filename));
std::vector<Cookie> cookies = Sqlite3MozCookieParser().parse(filename);
storeCookies(cookies.begin(), cookies.end());
#else // !HAVE_SQLITE3
throw DL_ABORT_EX
("Cannot read SQLite3 database because SQLite3 support is disabled by"
" configuration.");
#endif // !HAVE_SQLITE3
} else {
storeCookies(NsCookieParser().parse(filename));
std::vector<Cookie> cookies = NsCookieParser().parse(filename);
storeCookies(cookies.begin(), cookies.end());
}
return true;
} catch(RecoverableException& e) {

15
src/CookieStorage.h
View File

@ -39,6 +39,7 @@
#include <string>
#include <deque>
#include <vector>
#include <algorithm>
#include "a2time.h"
@ -122,7 +123,13 @@ private:
Logger* _logger;
void storeCookies(const std::deque<Cookie>& cookies);
template<typename InputIterator>
void storeCookies(InputIterator first, InputIterator last)
{
for(; first != last; ++first) {
store(*first);
}
}
public:
CookieStorage();
@ -140,9 +147,9 @@ public:
// Finds cookies matched with given criteria and returns them.
// Matched cookies' _lastAccess property is updated.
std::deque<Cookie> criteriaFind(const std::string& requestHost,
const std::string& requestPath,
time_t date, bool secure);
std::vector<Cookie> criteriaFind(const std::string& requestHost,
const std::string& requestPath,
time_t date, bool secure);
// Loads Cookies from file denoted by filename. If compiled with
// libsqlite3, this method automatically detects the specified file

23
src/DHTAbstractNodeLookupTask.cc
View File

@ -38,7 +38,6 @@
#include "DHTMessageFactory.h"
#include "DHTMessage.h"
#include "DHTNode.h"
#include "DHTNodeLookupEntry.h"
#include "DHTMessageCallbackImpl.h"
#include "DHTBucket.h"
#include "LogFactory.h"
@ -60,13 +59,13 @@ void DHTAbstractNodeLookupTask::onReceived(const SharedHandle<DHTMessage>& messa
{
--_inFlightMessage;
onReceivedInternal(message);
std::deque<SharedHandle<DHTNode> > nodes;
std::vector<SharedHandle<DHTNode> > nodes;
getNodesFromMessage(nodes, message);
std::deque<SharedHandle<DHTNodeLookupEntry> > newEntries;
std::vector<SharedHandle<DHTNodeLookupEntry> > newEntries;
toEntries(newEntries, nodes);
size_t count = 0;
for(std::deque<SharedHandle<DHTNodeLookupEntry> >::const_iterator i =
for(std::vector<SharedHandle<DHTNodeLookupEntry> >::const_iterator i =
newEntries.begin(); i != newEntries.end(); ++i) {
if(memcmp(_localNode->getID(), (*i)->_node->getID(), DHT_ID_LENGTH) != 0) {
_entries.push_front(*i);
@ -132,7 +131,9 @@ void DHTAbstractNodeLookupTask::sendMessageAndCheckFinish()
void DHTAbstractNodeLookupTask::sendMessage()
{
for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i = _entries.begin(); i != _entries.end() && _inFlightMessage < ALPHA; ++i) {
for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i =
_entries.begin();
i != _entries.end() && _inFlightMessage < ALPHA; ++i) {
if((*i)->_used == false) {
++_inFlightMessage;
(*i)->_used = true;
@ -151,7 +152,7 @@ void DHTAbstractNodeLookupTask::updateBucket()
void DHTAbstractNodeLookupTask::startup()
{
std::deque<SharedHandle<DHTNode> > nodes;
std::vector<SharedHandle<DHTNode> > nodes;
_routingTable->getClosestKNodes(nodes, _targetID);
_entries.clear();
toEntries(_entries, nodes);
@ -170,14 +171,4 @@ void DHTAbstractNodeLookupTask::startup()
}
}
void DHTAbstractNodeLookupTask::toEntries
(std::deque<SharedHandle<DHTNodeLookupEntry> >& entries,
const std::deque<SharedHandle<DHTNode> >& nodes) const
{
for(std::deque<SharedHandle<DHTNode> >::const_iterator i = nodes.begin(); i != nodes.end(); ++i) {
SharedHandle<DHTNodeLookupEntry> e(new DHTNodeLookupEntry(*i));
entries.push_back(e);
}
}
} // namespace aria2

21
src/DHTAbstractNodeLookupTask.h
View File

@ -36,14 +36,17 @@
#define _D_DHT_ABSTRACT_NODE_LOOKUP_TASK_H_
#include "DHTAbstractTask.h"
#include <deque>
#include <vector>
#include "DHTMessageCallbackListener.h"
#include "DHTConstants.h"
#include <deque>
#include "DHTNodeLookupEntry.h"
namespace aria2 {
class DHTNode;
class DHTNodeLookupEntry;
class DHTMessage;
class DHTAbstractNodeLookupTask:public DHTAbstractTask, public DHTMessageCallbackListener {
@ -54,8 +57,16 @@ protected:
size_t _inFlightMessage;
void toEntries(std::deque<SharedHandle<DHTNodeLookupEntry> >& entries,
const std::deque<SharedHandle<DHTNode> >& nodes) const;
template<typename Container>
void toEntries
(Container& entries, const std::vector<SharedHandle<DHTNode> >& nodes) const
{
for(std::vector<SharedHandle<DHTNode> >::const_iterator i = nodes.begin();
i != nodes.end(); ++i) {
SharedHandle<DHTNodeLookupEntry> e(new DHTNodeLookupEntry(*i));
entries.push_back(e);
}
}
void sendMessage();
@ -73,7 +84,7 @@ public:
virtual void onTimeout(const SharedHandle<DHTNode>& node);
virtual void getNodesFromMessage(std::deque<SharedHandle<DHTNode> >& nodes,
virtual void getNodesFromMessage(std::vector<SharedHandle<DHTNode> >& nodes,
const SharedHandle<DHTMessage>& message) = 0;
virtual void onReceivedInternal(const SharedHandle<DHTMessage>& message) {}

10
src/DHTAutoSaveCommand.cc
View File

@ -98,13 +98,13 @@ void DHTAutoSaveCommand::save()
}
}
}
std::deque<SharedHandle<DHTNode> > nodes;
std::deque<SharedHandle<DHTBucket> > buckets;
std::vector<SharedHandle<DHTNode> > nodes;
std::vector<SharedHandle<DHTBucket> > buckets;
_routingTable->getBuckets(buckets);
for(std::deque<SharedHandle<DHTBucket> >::const_iterator i = buckets.begin(); i != buckets.end(); ++i) {
for(std::vector<SharedHandle<DHTBucket> >::const_iterator i = buckets.begin();
i != buckets.end(); ++i) {
const SharedHandle<DHTBucket>& bucket = *i;
std::deque<SharedHandle<DHTNode> > goodNodes;
std::vector<SharedHandle<DHTNode> > goodNodes;
bucket->getGoodNodes(goodNodes);
nodes.insert(nodes.end(), goodNodes.begin(), goodNodes.end());
}

5
src/DHTBucket.cc
View File

@ -214,9 +214,10 @@ SharedHandle<DHTBucket> DHTBucket::split()
return rBucket;
}
void DHTBucket::getGoodNodes(std::deque<SharedHandle<DHTNode> >& goodNodes) const
void DHTBucket::getGoodNodes
(std::vector<SharedHandle<DHTNode> >& goodNodes) const
{
goodNodes = _nodes;
goodNodes.insert(goodNodes.end(), _nodes.begin(), _nodes.end());
goodNodes.erase(std::remove_if(goodNodes.begin(), goodNodes.end(),
mem_fun_sh(&DHTNode::isBad)), goodNodes.end());
}

9
src/DHTBucket.h
View File

@ -36,11 +36,14 @@
#define _D_DHT_BUCKET_H_
#include "common.h"
#include <string>
#include <deque>
#include <vector>
#include "SharedHandle.h"
#include "DHTConstants.h"
#include "TimeA2.h"
#include <string>
#include <deque>
namespace aria2 {
@ -123,7 +126,7 @@ public:
return _nodes;
}
void getGoodNodes(std::deque<SharedHandle<DHTNode> >& nodes) const;
void getGoodNodes(std::vector<SharedHandle<DHTNode> >& nodes) const;
void dropNode(const SharedHandle<DHTNode>& node);

5
src/DHTBucketRefreshTask.cc
View File

@ -51,9 +51,10 @@ DHTBucketRefreshTask::~DHTBucketRefreshTask() {}
void DHTBucketRefreshTask::startup()
{
std::deque<SharedHandle<DHTBucket> > buckets;
std::vector<SharedHandle<DHTBucket> > buckets;
_routingTable->getBuckets(buckets);
for(std::deque<SharedHandle<DHTBucket> >::iterator i = buckets.begin(); i != buckets.end(); ++i) {
for(std::vector<SharedHandle<DHTBucket> >::iterator i = buckets.begin();
i != buckets.end(); ++i) {
if(_forceRefresh || (*i)->needsRefresh()) {
(*i)->notifyUpdate();
unsigned char targetID[DHT_ID_LENGTH];

5
src/DHTConnectionImpl.cc
View File

@ -35,7 +35,6 @@
#include "DHTConnectionImpl.h"
#include <utility>
#include <deque>
#include <algorithm>
#include "LogFactory.h"
@ -54,11 +53,11 @@ DHTConnectionImpl::~DHTConnectionImpl() {}
bool DHTConnectionImpl::bind(uint16_t& port, IntSequence& ports)
{
std::deque<int32_t> randPorts = ports.flush();
std::vector<int32_t> randPorts = ports.flush();
std::random_shuffle(randPorts.begin(), randPorts.end(),
*SimpleRandomizer::getInstance().get());
for(std::deque<int32_t>::const_iterator portItr = randPorts.begin();
for(std::vector<int32_t>::const_iterator portItr = randPorts.begin();
portItr != randPorts.end(); ++portItr) {
if(!(0 < (*portItr) && (*portItr) <= 65535)) {
continue;

16
src/DHTEntryPointNameResolveCommand.cc
View File

@ -55,10 +55,12 @@
namespace aria2 {
DHTEntryPointNameResolveCommand::DHTEntryPointNameResolveCommand(int32_t cuid, DownloadEngine* e, const std::deque<std::pair<std::string, uint16_t> >& entryPoints):
DHTEntryPointNameResolveCommand::DHTEntryPointNameResolveCommand
(int32_t cuid, DownloadEngine* e,
const std::vector<std::pair<std::string, uint16_t> >& entryPoints):
Command(cuid),
_e(e),
_entryPoints(entryPoints),
_entryPoints(entryPoints.begin(), entryPoints.end()),
_bootstrapEnabled(false)
{}
@ -82,7 +84,7 @@ bool DHTEntryPointNameResolveCommand::execute()
try {
#ifdef ENABLE_ASYNC_DNS
if(_e->option->getAsBool(PREF_ASYNC_DNS)) {
while(_entryPoints.size()) {
while(!_entryPoints.empty()) {
std::string hostname = _entryPoints.front().first;
try {
if(resolveHostname(hostname, _resolver)) {
@ -99,17 +101,17 @@ bool DHTEntryPointNameResolveCommand::execute()
logger->error(EX_EXCEPTION_CAUGHT, e);
}
_resolver->reset();
_entryPoints.erase(_entryPoints.begin());
_entryPoints.pop_front();
}
} else
#endif // ENABLE_ASYNC_DNS
{
NameResolver res;
res.setSocktype(SOCK_DGRAM);
while(_entryPoints.size()) {
while(!_entryPoints.empty()) {
std::string hostname = _entryPoints.front().first;
try {
std::deque<std::string> addrs;
std::vector<std::string> addrs;
res.resolve(addrs, hostname);
std::pair<std::string, uint16_t> p(addrs.front(),
@ -119,7 +121,7 @@ bool DHTEntryPointNameResolveCommand::execute()
} catch(RecoverableException& e) {
logger->error(EX_EXCEPTION_CAUGHT, e);
}
_entryPoints.erase(_entryPoints.begin());
_entryPoints.pop_front();
}
}
if(_bootstrapEnabled && _resolvedEntryPoints.size()) {

12
src/DHTEntryPointNameResolveCommand.h
View File

@ -36,10 +36,13 @@
#define _D_DHT_ENTRY_POINT_NAME_RESOVE_COMMAND_H_
#include "Command.h"
#include "SharedHandle.h"
#include <utility>
#include <vector>
#include <deque>
#include "SharedHandle.h"
namespace aria2 {
class DHTTaskQueue;
@ -69,7 +72,7 @@ private:
std::deque<std::pair<std::string, uint16_t> > _entryPoints;
std::deque<std::pair<std::string, uint16_t> > _resolvedEntryPoints;
std::vector<std::pair<std::string, uint16_t> > _resolvedEntryPoints;
bool _bootstrapEnabled;
@ -85,8 +88,9 @@ private:
#endif // ENABLE_ASYNC_DNS
public:
DHTEntryPointNameResolveCommand(int32_t cuid, DownloadEngine* e,
const std::deque<std::pair<std:: string, uint16_t> >& entryPoints);
DHTEntryPointNameResolveCommand
(int32_t cuid, DownloadEngine* e,
const std::vector<std::pair<std:: string, uint16_t> >& entryPoints);
virtual ~DHTEntryPointNameResolveCommand();

2
src/DHTFindNodeMessage.cc
View File

@ -63,7 +63,7 @@ DHTFindNodeMessage::~DHTFindNodeMessage() {}
void DHTFindNodeMessage::doReceivedAction()
{
std::deque<SharedHandle<DHTNode> > nodes;
std::vector<SharedHandle<DHTNode> > nodes;
_routingTable->getClosestKNodes(nodes, _targetNodeID);
SharedHandle<DHTMessage> reply =
_factory->createFindNodeReplyMessage(_remoteNode, nodes, _transactionID);

8
src/DHTFindNodeReplyMessage.cc
View File

@ -61,7 +61,8 @@ DHTFindNodeReplyMessage::~DHTFindNodeReplyMessage() {}
void DHTFindNodeReplyMessage::doReceivedAction()
{
for(std::deque<SharedHandle<DHTNode> >::iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) {
for(std::vector<SharedHandle<DHTNode> >::iterator i = _closestKNodes.begin();
i != _closestKNodes.end(); ++i) {
if(memcmp((*i)->getID(), _localNode->getID(), DHT_ID_LENGTH) != 0) {
_routingTable->addNode(*i);
}
@ -75,7 +76,7 @@ BDE DHTFindNodeReplyMessage::getResponse()
size_t offset = 0;
unsigned char buffer[DHTBucket::K*26];
// TODO if _closestKNodes.size() > DHTBucket::K ??
for(std::deque<SharedHandle<DHTNode> >::const_iterator i =
for(std::vector<SharedHandle<DHTNode> >::const_iterator i =
_closestKNodes.begin();
i != _closestKNodes.end() && offset < DHTBucket::K*26; ++i) {
SharedHandle<DHTNode> node = *i;
@ -96,7 +97,8 @@ std::string DHTFindNodeReplyMessage::getMessageType() const
void DHTFindNodeReplyMessage::validate() const {}
void DHTFindNodeReplyMessage::setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes)
void DHTFindNodeReplyMessage::setClosestKNodes
(const std::vector<SharedHandle<DHTNode> >& closestKNodes)
{
_closestKNodes = closestKNodes;
}

9
src/DHTFindNodeReplyMessage.h
View File

@ -36,13 +36,13 @@
#define _D_DHT_FIND_NODE_REPLY_MESSAGE_H_
#include "DHTResponseMessage.h"
#include <deque>
#include <vector>
namespace aria2 {
class DHTFindNodeReplyMessage:public DHTResponseMessage {
private:
std::deque<SharedHandle<DHTNode> > _closestKNodes;
std::vector<SharedHandle<DHTNode> > _closestKNodes;
protected:
virtual std::string toStringOptional() const;
public:
@ -60,12 +60,13 @@ public:
virtual void validate() const;
const std::deque<SharedHandle<DHTNode> >& getClosestKNodes() const
const std::vector<SharedHandle<DHTNode> >& getClosestKNodes() const
{
return _closestKNodes;
}
void setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes);
void setClosestKNodes
(const std::vector<SharedHandle<DHTNode> >& closestKNodes);
static const std::string FIND_NODE;

4
src/DHTGetPeersMessage.cc
View File

@ -70,11 +70,11 @@ void DHTGetPeersMessage::doReceivedAction()
_remoteNode->getIPAddress(),
_remoteNode->getPort());
// Check to see localhost has the contents which has same infohash
std::deque<SharedHandle<Peer> > peers;
std::vector<SharedHandle<Peer> > peers;
_peerAnnounceStorage->getPeers(peers, _infoHash);
SharedHandle<DHTMessage> reply;
if(peers.empty()) {
std::deque<SharedHandle<DHTNode> > nodes;
std::vector<SharedHandle<DHTNode> > nodes;
_routingTable->getClosestKNodes(nodes, _infoHash);
reply =
_factory->createGetPeersReplyMessage(_remoteNode, nodes, token,

23
src/DHTGetPeersReplyMessage.cc
View File

@ -58,10 +58,11 @@ const std::string DHTGetPeersReplyMessage::VALUES("values");
const std::string DHTGetPeersReplyMessage::NODES("nodes");
DHTGetPeersReplyMessage::DHTGetPeersReplyMessage(const SharedHandle<DHTNode>& localNode,
const SharedHandle<DHTNode>& remoteNode,
const std::string& token,
const std::string& transactionID):
DHTGetPeersReplyMessage::DHTGetPeersReplyMessage
(const SharedHandle<DHTNode>& localNode,
const SharedHandle<DHTNode>& remoteNode,
const std::string& token,
const std::string& transactionID):
DHTResponseMessage(localNode, remoteNode, transactionID),
_token(token) {}
@ -80,7 +81,7 @@ BDE DHTGetPeersReplyMessage::getResponse()
if(_values.empty()) {
size_t offset = 0;
unsigned char buffer[DHTBucket::K*26];
for(std::deque<SharedHandle<DHTNode> >::const_iterator i =
for(std::vector<SharedHandle<DHTNode> >::const_iterator i =
_closestKNodes.begin();
i != _closestKNodes.end() && offset < DHTBucket::K*26; ++i) {
SharedHandle<DHTNode> node = *i;
@ -113,7 +114,7 @@ BDE DHTGetPeersReplyMessage::getResponse()
// number of peer info that a message can carry.
static const size_t MAX_VALUES_SIZE = 100;
BDE valuesList = BDE::list();
for(std::deque<SharedHandle<Peer> >::const_iterator i = _values.begin();
for(std::vector<SharedHandle<Peer> >::const_iterator i = _values.begin();
i != _values.end() && valuesList.size() < MAX_VALUES_SIZE; ++i) {
const SharedHandle<Peer>& peer = *i;
unsigned char buffer[6];
@ -133,16 +134,6 @@ std::string DHTGetPeersReplyMessage::getMessageType() const
void DHTGetPeersReplyMessage::validate() const {}
void DHTGetPeersReplyMessage::setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes)
{
_closestKNodes = closestKNodes;
}
void DHTGetPeersReplyMessage::setValues(const std::deque<SharedHandle<Peer> >& peers)
{
_values = peers;
}
std::string DHTGetPeersReplyMessage::toStringOptional() const
{
return strconcat("token=", util::toHex(_token),

21
src/DHTGetPeersReplyMessage.h
View File

@ -37,7 +37,7 @@
#include "DHTResponseMessage.h"
#include <deque>
#include <vector>
#include "DHTConstants.h"
@ -49,9 +49,9 @@ class DHTGetPeersReplyMessage:public DHTResponseMessage {
private:
std::string _token;
std::deque<SharedHandle<DHTNode> > _closestKNodes;
std::vector<SharedHandle<DHTNode> > _closestKNodes;
std::deque<SharedHandle<Peer> > _values;
std::vector<SharedHandle<Peer> > _values;
protected:
virtual std::string toStringOptional() const;
public:
@ -70,19 +70,26 @@ public:
virtual void validate() const;
const std::deque<SharedHandle<DHTNode> >& getClosestKNodes() const
const std::vector<SharedHandle<DHTNode> >& getClosestKNodes() const
{
return _closestKNodes;
}
const std::deque<SharedHandle<Peer> >& getValues() const
const std::vector<SharedHandle<Peer> >& getValues() const
{
return _values;
}
void setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes);
void setClosestKNodes
(const std::vector<SharedHandle<DHTNode> >& closestKNodes)
{
_closestKNodes = closestKNodes;
}
void setValues(const std::deque<SharedHandle<Peer> >& peers);
void setValues(const std::vector<SharedHandle<Peer> >& peers)
{
_values = peers;
}
const std::string& getToken() const
{

27
src/DHTMessageFactory.h
View File

@ -38,7 +38,7 @@
#include "common.h"
#include <string>
#include <deque>
#include <vector>
#include "SharedHandle.h"
#include "A2STR.h"
@ -78,9 +78,10 @@ public:
const std::string& transactionID = A2STR::NIL) = 0;
virtual SharedHandle<DHTMessage>
createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
const std::deque<SharedHandle<DHTNode> >& closestKNodes,
const std::string& transactionID) = 0;
createFindNodeReplyMessage
(const SharedHandle<DHTNode>& remoteNode,
const std::vector<SharedHandle<DHTNode> >& closestKNodes,
const std::string& transactionID) = 0;
virtual SharedHandle<DHTMessage>
createGetPeersMessage(const SharedHandle<DHTNode>& remoteNode,
@ -88,16 +89,18 @@ public:
const std::string& transactionID = A2STR::NIL) = 0;
virtual SharedHandle<DHTMessage>
createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
const std::deque<SharedHandle<DHTNode> >& closestKNodes,
const std::string& token,
const std::string& transactionID) = 0;
createGetPeersReplyMessage
(const SharedHandle<DHTNode>& remoteNode,
const std::vector<SharedHandle<DHTNode> >& closestKNodes,
const std::string& token,
const std::string& transactionID) = 0;
virtual SharedHandle<DHTMessage>
createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
const std::deque<SharedHandle<Peer> >& peers,
const std::string& token,
const std::string& transactionID) = 0;
createGetPeersReplyMessage
(const SharedHandle<DHTNode>& remoteNode,
const std::vector<SharedHandle<Peer> >& peers,
const std::string& token,
const std::string& transactionID) = 0;
virtual SharedHandle<DHTMessage>
createAnnouncePeerMessage(const SharedHandle<DHTNode>& remoteNode,

44
src/DHTMessageFactoryImpl.cc
View File

@ -314,23 +314,25 @@ DHTMessageFactoryImpl::createFindNodeMessage(const SharedHandle<DHTNode>& remote
}
SharedHandle<DHTMessage>
DHTMessageFactoryImpl::createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
const std::deque<SharedHandle<DHTNode> >& closestKNodes,
const std::string& transactionID)
DHTMessageFactoryImpl::createFindNodeReplyMessage
(const SharedHandle<DHTNode>& remoteNode,
const std::vector<SharedHandle<DHTNode> >& closestKNodes,
const std::string& transactionID)
{
SharedHandle<DHTFindNodeReplyMessage> m(new DHTFindNodeReplyMessage(_localNode, remoteNode, transactionID));
SharedHandle<DHTFindNodeReplyMessage> m
(new DHTFindNodeReplyMessage(_localNode, remoteNode, transactionID));
m->setClosestKNodes(closestKNodes);
setCommonProperty(m);
return m;
}
std::deque<SharedHandle<DHTNode> >
std::vector<SharedHandle<DHTNode> >
DHTMessageFactoryImpl::extractNodes(const unsigned char* src, size_t length)
{
if(length%26 != 0) {
throw DL_ABORT_EX("Nodes length is not multiple of 26");
}
std::deque<SharedHandle<DHTNode> > nodes;
std::vector<SharedHandle<DHTNode> > nodes;
for(size_t offset = 0; offset < length; offset += 26) {
SharedHandle<DHTNode> node(new DHTNode(src+offset));
std::pair<std::string, uint16_t> addr =
@ -354,8 +356,8 @@ DHTMessageFactoryImpl::createFindNodeReplyMessage
const BDE& nodesData =
getString(getDictionary(dict, DHTResponseMessage::R),
DHTFindNodeReplyMessage::NODES);
std::deque<SharedHandle<DHTNode> > nodes = extractNodes(nodesData.uc(),
nodesData.s().size());
std::vector<SharedHandle<DHTNode> > nodes =
extractNodes(nodesData.uc(), nodesData.s().size());
return createFindNodeReplyMessage(remoteNode, nodes, transactionID);
}
@ -383,18 +385,19 @@ DHTMessageFactoryImpl::createGetPeersReplyMessageWithNodes
const BDE& rDict = getDictionary(dict, DHTResponseMessage::R);
const BDE& nodesData = getString(rDict,
DHTGetPeersReplyMessage::NODES);
std::deque<SharedHandle<DHTNode> > nodes = extractNodes(nodesData.uc(),
nodesData.s().size());
std::vector<SharedHandle<DHTNode> > nodes =
extractNodes(nodesData.uc(), nodesData.s().size());
const BDE& token = getString(rDict, DHTGetPeersReplyMessage::TOKEN);
return createGetPeersReplyMessage(remoteNode, nodes, token.s(),
transactionID);
}
SharedHandle<DHTMessage>
DHTMessageFactoryImpl::createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
const std::deque<SharedHandle<DHTNode> >& closestKNodes,
const std::string& token,
const std::string& transactionID)
DHTMessageFactoryImpl::createGetPeersReplyMessage
(const SharedHandle<DHTNode>& remoteNode,
const std::vector<SharedHandle<DHTNode> >& closestKNodes,
const std::string& token,
const std::string& transactionID)
{
SharedHandle<DHTGetPeersReplyMessage> m
(new DHTGetPeersReplyMessage(_localNode, remoteNode, token, transactionID));
@ -412,14 +415,14 @@ DHTMessageFactoryImpl::createGetPeersReplyMessageWithValues
const BDE& rDict = getDictionary(dict, DHTResponseMessage::R);
const BDE& valuesList = getList(rDict,
DHTGetPeersReplyMessage::VALUES);
std::deque<SharedHandle<Peer> > peers;
std::vector<SharedHandle<Peer> > peers;
for(BDE::List::const_iterator i = valuesList.listBegin();
i != valuesList.listEnd(); ++i) {
const BDE& data = *i;
if(data.isString() && data.s().size() == 6) {
std::pair<std::string, uint16_t> addr =
bittorrent::unpackcompact(data.uc());
PeerHandle peer(new Peer(addr.first, addr.second));
SharedHandle<Peer> peer(new Peer(addr.first, addr.second));
peers.push_back(peer);
}
}
@ -429,10 +432,11 @@ DHTMessageFactoryImpl::createGetPeersReplyMessageWithValues
}
SharedHandle<DHTMessage>
DHTMessageFactoryImpl::createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
const std::deque<SharedHandle<Peer> >& values,
const std::string& token,
const std::string& transactionID)
DHTMessageFactoryImpl::createGetPeersReplyMessage
(const SharedHandle<DHTNode>& remoteNode,
const std::vector<SharedHandle<Peer> >& values,
const std::string& token,
const std::string& transactionID)
{
SharedHandle<DHTGetPeersReplyMessage> m(new DHTGetPeersReplyMessage(_localNode, remoteNode, token, transactionID));
m->setValues(values);

28
src/DHTMessageFactoryImpl.h
View File

@ -72,7 +72,8 @@ private:
void validatePort(const BDE& i) const;
std::deque<SharedHandle<DHTNode> > extractNodes(const unsigned char* src, size_t length);
std::vector<SharedHandle<DHTNode> >
extractNodes(const unsigned char* src, size_t length);
void setCommonProperty(const SharedHandle<DHTAbstractMessage>& m);
@ -111,9 +112,10 @@ public:
virtual SharedHandle<DHTMessage>
createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
const std::deque<SharedHandle<DHTNode> >& closestKNodes,
const std::string& transactionID);
createFindNodeReplyMessage
(const SharedHandle<DHTNode>& remoteNode,
const std::vector<SharedHandle<DHTNode> >& closestKNodes,
const std::string& transactionID);
virtual SharedHandle<DHTMessage>
createGetPeersMessage(const SharedHandle<DHTNode>& remoteNode,
@ -121,10 +123,11 @@ public:
const std::string& transactionID = A2STR::NIL);
virtual SharedHandle<DHTMessage>
createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
const std::deque<SharedHandle<DHTNode> >& closestKNodes,
const std::string& token,
const std::string& transactionID);
createGetPeersReplyMessage
(const SharedHandle<DHTNode>& remoteNode,
const std::vector<SharedHandle<DHTNode> >& closestKNodes,
const std::string& token,
const std::string& transactionID);
SharedHandle<DHTMessage>
createGetPeersReplyMessageWithNodes(const SharedHandle<DHTNode>& remoteNode,
@ -132,10 +135,11 @@ public:
const std::string& transactionID);
virtual SharedHandle<DHTMessage>
createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
const std::deque<SharedHandle<Peer> >& peers,
const std::string& token,
const std::string& transactionID);
createGetPeersReplyMessage
(const SharedHandle<DHTNode>& remoteNode,
const std::vector<SharedHandle<Peer> >& peers,
const std::string& token,
const std::string& transactionID);
SharedHandle<DHTMessage>
createGetPeersReplyMessageWithValues(const SharedHandle<DHTNode>& remoteNode,

8
src/DHTNodeLookupTask.cc
View File

@ -39,7 +39,6 @@
#include "DHTNodeLookupEntry.h"
#include "LogFactory.h"
#include "util.h"
#include <cassert>
namespace aria2 {
@ -48,13 +47,14 @@ DHTNodeLookupTask::DHTNodeLookupTask(const unsigned char* targetNodeID):
{}
void
DHTNodeLookupTask::getNodesFromMessage(std::deque<SharedHandle<DHTNode> >& nodes,
const SharedHandle<DHTMessage>& message)
DHTNodeLookupTask::getNodesFromMessage
(std::vector<SharedHandle<DHTNode> >& nodes,
const SharedHandle<DHTMessage>& message)
{
SharedHandle<DHTFindNodeReplyMessage> m
(dynamic_pointer_cast<DHTFindNodeReplyMessage>(message));
if(!m.isNull()) {
const std::deque<SharedHandle<DHTNode> >& knodes = m->getClosestKNodes();
const std::vector<SharedHandle<DHTNode> >& knodes = m->getClosestKNodes();
nodes.insert(nodes.end(), knodes.begin(), knodes.end());
}
}

2
src/DHTNodeLookupTask.h
View File

@ -43,7 +43,7 @@ class DHTNodeLookupTask:public DHTAbstractNodeLookupTask {
public:
DHTNodeLookupTask(const unsigned char* targetNodeID);
virtual void getNodesFromMessage(std::deque<SharedHandle<DHTNode> >& nodes,
virtual void getNodesFromMessage(std::vector<SharedHandle<DHTNode> >& nodes,
const SharedHandle<DHTMessage>& message);
virtual SharedHandle<DHTMessage> createMessage(const SharedHandle<DHTNode>& remoteNode);

8
src/DHTPeerAnnounceEntry.cc
View File

@ -50,7 +50,8 @@ DHTPeerAnnounceEntry::~DHTPeerAnnounceEntry() {}
void DHTPeerAnnounceEntry::addPeerAddrEntry(const PeerAddrEntry& entry)
{
std::deque<PeerAddrEntry>::iterator i = std::find(_peerAddrEntries.begin(), _peerAddrEntries.end(), entry);
std::vector<PeerAddrEntry>::iterator i =
std::find(_peerAddrEntries.begin(), _peerAddrEntries.end(), entry);
if(i == _peerAddrEntries.end()) {
_peerAddrEntries.push_back(entry);
} else {
@ -91,9 +92,10 @@ bool DHTPeerAnnounceEntry::empty() const
return _peerAddrEntries.empty();
}
void DHTPeerAnnounceEntry::getPeers(std::deque<SharedHandle<Peer> >& peers) const
void DHTPeerAnnounceEntry::getPeers
(std::vector<SharedHandle<Peer> >& peers) const
{
for(std::deque<PeerAddrEntry>::const_iterator i = _peerAddrEntries.begin();
for(std::vector<PeerAddrEntry>::const_iterator i = _peerAddrEntries.begin();
i != _peerAddrEntries.end(); ++i) {
SharedHandle<Peer> peer(new Peer((*i).getIPAddress(), (*i).getPort()));
peers.push_back(peer);

8
src/DHTPeerAnnounceEntry.h
View File

@ -37,7 +37,7 @@
#include "common.h"
#include <deque>
#include <vector>
#include "SharedHandle.h"
#include "DHTConstants.h"
@ -52,7 +52,7 @@ class DHTPeerAnnounceEntry {
private:
unsigned char _infoHash[DHT_ID_LENGTH];
std::deque<PeerAddrEntry> _peerAddrEntries;
std::vector<PeerAddrEntry> _peerAddrEntries;
Time _lastUpdated;
public:
@ -66,7 +66,7 @@ public:
size_t countPeerAddrEntry() const;
const std::deque<PeerAddrEntry>& getPeerAddrEntries() const
const std::vector<PeerAddrEntry>& getPeerAddrEntries() const
{
return _peerAddrEntries;
}
@ -87,7 +87,7 @@ public:
return _infoHash;
}
void getPeers(std::deque<SharedHandle<Peer> >& peers) const;
void getPeers(std::vector<SharedHandle<Peer> >& peers) const;
};

2
src/DHTPeerAnnounceStorage.cc
View File

@ -101,7 +101,7 @@ bool DHTPeerAnnounceStorage::contains(const unsigned char* infoHash) const
std::binary_search(_entries.begin(), _entries.end(), entry, InfoHashLess());
}
void DHTPeerAnnounceStorage::getPeers(std::deque<SharedHandle<Peer> >& peers,
void DHTPeerAnnounceStorage::getPeers(std::vector<SharedHandle<Peer> >& peers,
const unsigned char* infoHash)
{
SharedHandle<DHTPeerAnnounceEntry> entry(new DHTPeerAnnounceEntry(infoHash));

7
src/DHTPeerAnnounceStorage.h
View File

@ -36,8 +36,11 @@
#define _D_DHT_PEER_ANNOUNCE_STORAGE_H_
#include "common.h"
#include "SharedHandle.h"
#include <deque>
#include <vector>
#include "SharedHandle.h"
namespace aria2 {
@ -68,7 +71,7 @@ public:
bool contains(const unsigned char* infoHash) const;
void getPeers(std::deque<SharedHandle<Peer> >& peers,
void getPeers(std::vector<SharedHandle<Peer> >& peers,
const unsigned char* infoHash);
// drop peer announce entry which is not updated in the past

10
src/DHTPeerLookupTask.cc
View File

@ -54,12 +54,14 @@ DHTPeerLookupTask::DHTPeerLookupTask
DHTAbstractNodeLookupTask(bittorrent::getInfoHash(downloadContext)) {}
void
DHTPeerLookupTask::getNodesFromMessage(std::deque<SharedHandle<DHTNode> >& nodes,
const SharedHandle<DHTMessage>& message)
DHTPeerLookupTask::getNodesFromMessage
(std::vector<SharedHandle<DHTNode> >& nodes,
const SharedHandle<DHTMessage>& message)
{
SharedHandle<DHTGetPeersReplyMessage> m(dynamic_pointer_cast<DHTGetPeersReplyMessage>(message));
SharedHandle<DHTGetPeersReplyMessage> m
(dynamic_pointer_cast<DHTGetPeersReplyMessage>(message));
if(!m.isNull()) {
const std::deque<SharedHandle<DHTNode> >& knodes = m->getClosestKNodes();
const std::vector<SharedHandle<DHTNode> >& knodes = m->getClosestKNodes();
nodes.insert(nodes.end(), knodes.begin(), knodes.end());
}
}

6
src/DHTPeerLookupTask.h
View File

@ -49,7 +49,7 @@ class DHTPeerLookupTask:public DHTAbstractNodeLookupTask {
private:
std::map<std::string, std::string> _tokenStorage;
std::deque<SharedHandle<Peer> > _peers;
std::vector<SharedHandle<Peer> > _peers;
SharedHandle<PeerStorage> _peerStorage;
@ -57,7 +57,7 @@ private:
public:
DHTPeerLookupTask(const SharedHandle<DownloadContext>& downloadContext);
virtual void getNodesFromMessage(std::deque<SharedHandle<DHTNode> >& nodes,
virtual void getNodesFromMessage(std::vector<SharedHandle<DHTNode> >& nodes,
const SharedHandle<DHTMessage>& message);
virtual void onReceivedInternal(const SharedHandle<DHTMessage>& message);
@ -66,7 +66,7 @@ public:
virtual void onFinish();
const std::deque<SharedHandle<Peer> >& getPeers() const
const std::vector<SharedHandle<Peer> >& getPeers() const
{
return _peers;
}

8
src/DHTRoutingTable.cc
View File

@ -126,8 +126,9 @@ bool DHTRoutingTable::addNode(const SharedHandle<DHTNode>& node, bool good)
return false;
}
void DHTRoutingTable::getClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
const unsigned char* key) const
void DHTRoutingTable::getClosestKNodes
(std::vector<SharedHandle<DHTNode> >& nodes,
const unsigned char* key) const
{
BNode::findClosestKNodes(nodes, _root, key);
}
@ -177,7 +178,8 @@ void DHTRoutingTable::moveBucketTail(const SharedHandle<DHTNode>& node)
getBucketFor(node)->moveToTail(node);
}
void DHTRoutingTable::getBuckets(std::deque<SharedHandle<DHTBucket> >& buckets) const
void DHTRoutingTable::getBuckets
(std::vector<SharedHandle<DHTBucket> >& buckets) const
{
BNode::enumerateBucket(buckets, _root);
}

10
src/DHTRoutingTable.h
View File

@ -36,9 +36,11 @@
#define _D_DHT_ROUTING_TABLE_H_
#include "common.h"
#include "SharedHandle.h"
#include <string>
#include <deque>
#include <vector>
#include "SharedHandle.h"
namespace aria2 {
@ -73,7 +75,7 @@ public:
bool addGoodNode(const SharedHandle<DHTNode>& node);
void getClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
void getClosestKNodes(std::vector<SharedHandle<DHTNode> >& nodes,
const unsigned char* key) const;
size_t countBucket() const;
@ -92,7 +94,7 @@ public:
SharedHandle<DHTNode> getNode(const unsigned char* id, const std::string& ipaddr, uint16_t port) const;
void getBuckets(std::deque<SharedHandle<DHTBucket> >& buckets) const;
void getBuckets(std::vector<SharedHandle<DHTBucket> >& buckets) const;
void setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue);

2
src/DHTRoutingTableDeserializer.cc
View File

@ -157,7 +157,7 @@ void DHTRoutingTableDeserializer::deserialize(std::istream& in)
readBytes(buf, buf.size(), in, 4);
CHECK_STREAM(in, 4);
std::deque<SharedHandle<DHTNode> > nodes;
std::vector<SharedHandle<DHTNode> > nodes;
// nodes
for(size_t i = 0; i < numNodes; ++i) {
// Currently, only IPv4 addresses are supported.

10
src/DHTRoutingTableDeserializer.h
View File

@ -36,10 +36,12 @@
#define _D_DHT_ROUTING_TABLE_DESERIALIZER_H_
#include "common.h"
#include <vector>
#include <iosfwd>
#include "SharedHandle.h"
#include "TimeA2.h"
#include <deque>
#include <iosfwd>
namespace aria2 {
@ -49,7 +51,7 @@ class DHTRoutingTableDeserializer {
private:
SharedHandle<DHTNode> _localNode;
std::deque<SharedHandle<DHTNode> > _nodes;
std::vector<SharedHandle<DHTNode> > _nodes;
Time _serializedTime;
public:
@ -62,7 +64,7 @@ public:
return _localNode;
}
const std::deque<SharedHandle<DHTNode> >& getNodes() const
const std::vector<SharedHandle<DHTNode> >& getNodes() const
{
return _nodes;
}

9
src/DHTRoutingTableSerializer.cc
View File

@ -53,12 +53,14 @@ DHTRoutingTableSerializer::DHTRoutingTableSerializer() {}
DHTRoutingTableSerializer::~DHTRoutingTableSerializer() {}
void DHTRoutingTableSerializer::setLocalNode(const SharedHandle<DHTNode>& localNode)
void DHTRoutingTableSerializer::setLocalNode
(const SharedHandle<DHTNode>& localNode)
{
_localNode = localNode;
}
void DHTRoutingTableSerializer::setNodes(const std::deque<SharedHandle<DHTNode> >& nodes)
void DHTRoutingTableSerializer::setNodes
(const std::vector<SharedHandle<DHTNode> >& nodes)
{
_nodes = nodes;
}
@ -99,7 +101,8 @@ void DHTRoutingTableSerializer::serialize(std::ostream& o)
o.write(zero, 4);
// nodes
for(std::deque<SharedHandle<DHTNode> >::const_iterator i = _nodes.begin(); i != _nodes.end(); ++i) {
for(std::vector<SharedHandle<DHTNode> >::const_iterator i = _nodes.begin();
i != _nodes.end(); ++i) {
const SharedHandle<DHTNode>& node = *i;
// Currently, only IPv4 address and IPv4-mapped address are saved.
// 6bytes: write IP address + port in Compact IP-address/port info form.

10
src/DHTRoutingTableSerializer.h
View File

@ -36,10 +36,12 @@
#define _D_DHT_ROUTING_TABLE_SERIALIZER_H_
#include "common.h"
#include "SharedHandle.h"
#include <deque>
#include <vector>
#include <iosfwd>
#include "SharedHandle.h"
namespace aria2 {
class DHTNode;
@ -48,7 +50,7 @@ class DHTRoutingTableSerializer {
private:
SharedHandle<DHTNode> _localNode;
std::deque<SharedHandle<DHTNode> > _nodes;
std::vector<SharedHandle<DHTNode> > _nodes;
public:
DHTRoutingTableSerializer();
@ -56,7 +58,7 @@ public:
void setLocalNode(const SharedHandle<DHTNode>& localNode);
void setNodes(const std::deque<SharedHandle<DHTNode> >& nodes);
void setNodes(const std::vector<SharedHandle<DHTNode> >& nodes);
void serialize(std::ostream& o);
};

12
src/DHTSetup.cc
View File

@ -80,13 +80,13 @@ DHTSetup::DHTSetup():_logger(LogFactory::getInstance()) {}
DHTSetup::~DHTSetup() {}
void DHTSetup::setup(std::deque<Command*>& commands,
void DHTSetup::setup(std::vector<Command*>& commands,
DownloadEngine* e, const Option* option)
{
if(_initialized) {
return;
}
std::deque<Command*> tempCommands;
std::vector<Command*> tempCommands;
try {
// load routing table and localnode id here
@ -179,8 +179,10 @@ void DHTSetup::setup(std::deque<Command*>& commands,
DHTRegistry::_messageFactory = factory;
// add deserialized nodes to routing table
const std::deque<SharedHandle<DHTNode> >& desnodes = deserializer.getNodes();
for(std::deque<SharedHandle<DHTNode> >::const_iterator i = desnodes.begin(); i != desnodes.end(); ++i) {
const std::vector<SharedHandle<DHTNode> >& desnodes =
deserializer.getNodes();
for(std::vector<SharedHandle<DHTNode> >::const_iterator i =
desnodes.begin(); i != desnodes.end(); ++i) {
routingTable->addNode(*i);
}
if(!desnodes.empty() && deserializer.getSerializedTime().elapsed(DHT_BUCKET_REFRESH_INTERVAL)) {
@ -194,7 +196,7 @@ void DHTSetup::setup(std::deque<Command*>& commands,
{
std::pair<std::string, uint16_t> addr(option->get(PREF_DHT_ENTRY_POINT_HOST),
option->getAsInt(PREF_DHT_ENTRY_POINT_PORT));
std::deque<std::pair<std::string, uint16_t> > entryPoints;
std::vector<std::pair<std::string, uint16_t> > entryPoints;
entryPoints.push_back(addr);
DHTEntryPointNameResolveCommand* command =
new DHTEntryPointNameResolveCommand(e->newCUID(), e, entryPoints);

4
src/DHTSetup.h
View File

@ -36,7 +36,7 @@
#define _D_DHT_SETUP_H_
#include "common.h"
#include <deque>
#include <vector>
namespace aria2 {
class Logger;
@ -55,7 +55,7 @@ public:
~DHTSetup();
void setup(std::deque<Command*>& commands,
void setup(std::vector<Command*>& commands,
DownloadEngine* e, const Option* option);
static bool initialized();

2
src/DefaultBtAnnounce.cc
View File

@ -274,7 +274,7 @@ DefaultBtAnnounce::processAnnounceResponse(const unsigned char* trackerResponse,
logger->info(MSG_NO_PEER_LIST_RECEIVED);
} else {
if(!btRuntime->isHalt() && btRuntime->lessThanMinPeers()) {
std::deque<SharedHandle<Peer> > peers;
std::vector<SharedHandle<Peer> > peers;
PeerListProcessor().extractPeer(peerData, std::back_inserter(peers));
peerStorage->addPeer(peers);
}

15
src/DefaultBtInteractive.cc
View File

@ -35,6 +35,7 @@
#include "DefaultBtInteractive.h"
#include <cstring>
#include <vector>
#include "prefs.h"
#include "message.h"
@ -226,7 +227,7 @@ void DefaultBtInteractive::decideChoking() {
}
void DefaultBtInteractive::checkHave() {
std::deque<size_t> indexes;
std::vector<size_t> indexes;
_pieceStorage->getAdvertisedPieceIndexes(indexes, cuid, haveCheckPoint);
haveCheckPoint.reset();
if(indexes.size() >= 20) {
@ -236,7 +237,7 @@ void DefaultBtInteractive::checkHave() {
dispatcher->addMessageToQueue(messageFactory->createBitfieldMessage());
}
} else {
for(std::deque<size_t>::iterator itr = indexes.begin();
for(std::vector<size_t>::iterator itr = indexes.begin();
itr != indexes.end(); ++itr) {
dispatcher->addMessageToQueue(messageFactory->createHaveMessage(*itr));
}
@ -326,7 +327,7 @@ void DefaultBtInteractive::fillPiece(size_t maxMissingBlock) {
if(peer->peerChoking()) {
if(peer->isFastExtensionEnabled()) {
std::deque<size_t> excludedIndexes;
std::vector<size_t> excludedIndexes;
btRequestFactory->getTargetPieceIndexes(excludedIndexes);
while(numMissingBlock < maxMissingBlock) {
SharedHandle<Piece> piece =
@ -341,7 +342,7 @@ void DefaultBtInteractive::fillPiece(size_t maxMissingBlock) {
}
}
} else {
std::deque<size_t> excludedIndexes;
std::vector<size_t> excludedIndexes;
btRequestFactory->getTargetPieceIndexes(excludedIndexes);
while(numMissingBlock < maxMissingBlock) {
SharedHandle<Piece> piece =
@ -364,7 +365,7 @@ void DefaultBtInteractive::addRequests() {
_maxOutstandingRequest <= dispatcher->countOutstandingRequest() ?
0 : _maxOutstandingRequest-dispatcher->countOutstandingRequest();
if(reqNumToCreate > 0) {
BtMessages requests;
std::vector<SharedHandle<BtMessage> > requests;
if(_pieceStorage->isEndGame()) {
btRequestFactory->createRequestMessagesOnEndGame(requests,reqNumToCreate);
} else {
@ -437,7 +438,7 @@ void DefaultBtInteractive::addPeerExchangeMessage()
if(_pexCheckPoint.elapsed(UTPexExtensionMessage::DEFAULT_INTERVAL)) {
UTPexExtensionMessageHandle m
(new UTPexExtensionMessage(peer->getExtensionMessageID("ut_pex")));
const Peers& peers = _peerStorage->getPeers();
const std::deque<SharedHandle<Peer> >& peers = _peerStorage->getPeers();
{
for(std::deque<SharedHandle<Peer> >::const_iterator i =
peers.begin(); i != peers.end() && !m->freshPeersAreFull(); ++i) {
@ -474,7 +475,7 @@ void DefaultBtInteractive::doInteractionProcessing() {
_downloadContext->getTotalLength() > 0) {
size_t num = _utMetadataRequestTracker->avail();
if(num > 0) {
std::deque<SharedHandle<BtMessage> > requests;
std::vector<SharedHandle<BtMessage> > requests;
_utMetadataRequestFactory->create(requests, num, _pieceStorage);
dispatcher->addMessageToQueue(requests);
}

28
src/DefaultBtMessageDispatcher.cc
View File

@ -75,15 +75,17 @@ void DefaultBtMessageDispatcher::addMessageToQueue(const BtMessageHandle& btMess
messageQueue.push_back(btMessage);
}
void DefaultBtMessageDispatcher::addMessageToQueue(const BtMessages& btMessages)
void DefaultBtMessageDispatcher::addMessageToQueue
(const std::vector<SharedHandle<BtMessage> >& btMessages)
{
for(BtMessages::const_iterator itr = btMessages.begin(); itr != btMessages.end(); itr++) {
for(std::vector<SharedHandle<BtMessage> >::const_iterator itr =
btMessages.begin(); itr != btMessages.end(); ++itr) {
addMessageToQueue(*itr);
}
}
void DefaultBtMessageDispatcher::sendMessages() {
BtMessages tempQueue;
std::vector<SharedHandle<BtMessage> > tempQueue;
while(!messageQueue.empty()) {
BtMessageHandle msg = messageQueue.front();
messageQueue.pop_front();
@ -121,7 +123,8 @@ void DefaultBtMessageDispatcher::doCancelSendingPieceAction(size_t index, uint32
{
BtCancelSendingPieceEvent event(index, begin, length);
BtMessages tempQueue = messageQueue;
std::vector<SharedHandle<BtMessage> > tempQueue
(messageQueue.begin(), messageQueue.end());
forEachMemFunSH(tempQueue.begin(), tempQueue.end(),
&BtMessage::onCancelSendingPieceEvent, event);
@ -129,7 +132,8 @@ void DefaultBtMessageDispatcher::doCancelSendingPieceAction(size_t index, uint32
// Cancel sending piece message to peer.
// TODO Is this method really necessary?
void DefaultBtMessageDispatcher::doCancelSendingPieceAction(const PieceHandle& piece)
void DefaultBtMessageDispatcher::doCancelSendingPieceAction
(const SharedHandle<Piece>& piece)
{
}
@ -158,7 +162,8 @@ public:
};
// localhost cancels outstanding download requests to the peer.
void DefaultBtMessageDispatcher::doAbortOutstandingRequestAction(const PieceHandle& piece) {
void DefaultBtMessageDispatcher::doAbortOutstandingRequestAction
(const SharedHandle<Piece>& piece) {
RequestSlot rs(piece->getIndex(), 0, 0, 0);
std::deque<RequestSlot>::iterator first =
std::lower_bound(requestSlots.begin(), requestSlots.end(), rs);
@ -172,7 +177,8 @@ void DefaultBtMessageDispatcher::doAbortOutstandingRequestAction(const PieceHand
BtAbortOutstandingRequestEvent event(piece);
BtMessages tempQueue = messageQueue;
std::vector<SharedHandle<BtMessage> > tempQueue
(messageQueue.begin(), messageQueue.end());
forEachMemFunSH(tempQueue.begin(), tempQueue.end(),
&BtMessage::onAbortOutstandingRequestEvent, event);
}
@ -238,7 +244,8 @@ void DefaultBtMessageDispatcher::doChokingAction()
{
BtChokingEvent event;
BtMessages tempQueue = messageQueue;
std::vector<SharedHandle<BtMessage> > tempQueue
(messageQueue.begin(), messageQueue.end());
forEachMemFunSH(tempQueue.begin(), tempQueue.end(),
&BtMessage::onChokingEvent, event);
}
@ -351,11 +358,6 @@ bool DefaultBtMessageDispatcher::isSendingInProgress()
}
}
size_t DefaultBtMessageDispatcher::countOutstandingRequest()
{
return requestSlots.size();
}
class BlockIndexLess {
public:
bool operator()(const RequestSlot& lhs, const RequestSlot& rhs) const

15
src/DefaultBtMessageDispatcher.h
View File

@ -36,6 +36,9 @@
#define _D_DEFAULT_BT_MESSAGE_DISPATCHER_H_
#include "BtMessageDispatcher.h"
#include <deque>
#include "a2time.h"
namespace aria2 {
@ -70,7 +73,8 @@ public:
virtual void addMessageToQueue(const SharedHandle<BtMessage>& btMessage);
virtual void addMessageToQueue(const std::deque<SharedHandle<BtMessage> >& btMessages);
virtual void addMessageToQueue
(const std::vector<SharedHandle<BtMessage> >& btMessages);
virtual void sendMessages();
@ -92,8 +96,11 @@ public:
return messageQueue.size();
}
virtual size_t countOutstandingRequest();
virtual size_t countOutstandingRequest()
{
return requestSlots.size();
}
virtual bool isOutstandingRequest(size_t index, size_t blockIndex);
virtual RequestSlot getOutstandingRequest(size_t index, uint32_t begin, size_t length);
@ -109,7 +116,7 @@ public:
return messageQueue;
}
const RequestSlots& getRequestSlots() const
const std::deque<RequestSlot>& getRequestSlots() const
{
return requestSlots;
}

3
src/DefaultBtMessageFactory.cc
View File

@ -278,7 +278,8 @@ DefaultBtMessageFactory::createHandshakeMessage(const unsigned char* infoHash,
}
BtMessageHandle
DefaultBtMessageFactory::createRequestMessage(const PieceHandle& piece, size_t blockIndex)
DefaultBtMessageFactory::createRequestMessage
(const SharedHandle<Piece>& piece, size_t blockIndex)
{
BtRequestMessageHandle msg
(new BtRequestMessage(piece->getIndex(),

12
src/DefaultBtMessageReceiver.cc
View File

@ -85,8 +85,7 @@ DefaultBtMessageReceiver::receiveHandshake(bool quickReply)
return SharedHandle<BtHandshakeMessage>();
}
SharedHandle<BtHandshakeMessage> msg = messageFactory->createHandshakeMessage(data, dataLength);
std::deque<std::string> errors;
msg->validate(errors);
msg->validate();
return msg;
}
@ -111,13 +110,8 @@ BtMessageHandle DefaultBtMessageReceiver::receiveMessage() {
return SharedHandle<BtMessage>();
}
BtMessageHandle msg = messageFactory->createBtMessage(data, dataLength);
std::deque<std::string> errors;
if(msg->validate(errors)) {
return msg;
} else {
// TODO throw exception here based on errors;
return SharedHandle<BtMessage>();
}
msg->validate();
return msg;
}
void DefaultBtMessageReceiver::setDownloadContext

9
src/DefaultBtProgressInfoFile.cc
View File

@ -179,9 +179,10 @@ void DefaultBtProgressInfoFile::save()
uint32_t numInFlightPieceNL = htonl(_pieceStorage->countInFlightPiece());
o.write(reinterpret_cast<const char*>(&numInFlightPieceNL),
sizeof(numInFlightPieceNL));
Pieces inFlightPieces;
std::vector<SharedHandle<Piece> > inFlightPieces;
_pieceStorage->getInFlightPieces(inFlightPieces);
for(Pieces::const_iterator itr = inFlightPieces.begin();
for(std::vector<SharedHandle<Piece> >::const_iterator itr =
inFlightPieces.begin();
itr != inFlightPieces.end(); ++itr) {
uint32_t indexNL = htonl((*itr)->getIndex());
o.write(reinterpret_cast<const char*>(&indexNL), sizeof(indexNL));
@ -343,7 +344,7 @@ void DefaultBtProgressInfoFile::load()
if(version >= 1) {
numInFlightPiece = ntohl(numInFlightPiece);
}
Pieces inFlightPieces;
std::vector<SharedHandle<Piece> > inFlightPieces;
while(numInFlightPiece--) {
uint32_t index;
in.read(reinterpret_cast<char*>(&index), sizeof(index));
@ -365,7 +366,7 @@ void DefaultBtProgressInfoFile::load()
throw DL_ABORT_EX
(StringFormat("piece length out of range: %u", length).str());
}
PieceHandle piece(new Piece(index, length));
SharedHandle<Piece> piece(new Piece(index, length));
uint32_t bitfieldLength;
in.read(reinterpret_cast<char*>(&bitfieldLength),
sizeof(bitfieldLength));

23
src/DefaultBtRequestFactory.cc
View File

@ -66,7 +66,7 @@ DefaultBtRequestFactory::~DefaultBtRequestFactory()
}
}
void DefaultBtRequestFactory::addTargetPiece(const PieceHandle& piece)
void DefaultBtRequestFactory::addTargetPiece(const SharedHandle<Piece>& piece)
{
pieces.push_back(piece);
}
@ -95,7 +95,7 @@ void DefaultBtRequestFactory::removeCompletedPiece() {
pieces.end());
}
void DefaultBtRequestFactory::removeTargetPiece(const PieceHandle& piece) {
void DefaultBtRequestFactory::removeTargetPiece(const SharedHandle<Piece>& piece) {
pieces.erase(std::remove(pieces.begin(), pieces.end(), piece),
pieces.end());
dispatcher->doAbortOutstandingRequestAction(piece);
@ -142,7 +142,8 @@ void DefaultBtRequestFactory::doChokedAction()
}
void DefaultBtRequestFactory::removeAllTargetPiece() {
for(Pieces::iterator itr = pieces.begin(); itr != pieces.end(); ++itr) {
for(std::deque<SharedHandle<Piece> >::iterator itr = pieces.begin();
itr != pieces.end(); ++itr) {
dispatcher->doAbortOutstandingRequestAction(*itr);
_pieceStorage->cancelPiece(*itr);
}
@ -150,7 +151,7 @@ void DefaultBtRequestFactory::removeAllTargetPiece() {
}
void DefaultBtRequestFactory::createRequestMessages
(std::deque<SharedHandle<BtMessage> >& requests, size_t max)
(std::vector<SharedHandle<BtMessage> >& requests, size_t max)
{
if(requests.size() >= max) {
return;
@ -158,7 +159,7 @@ void DefaultBtRequestFactory::createRequestMessages
size_t getnum = max-requests.size();
std::vector<size_t> blockIndexes;
blockIndexes.reserve(getnum);
for(Pieces::iterator itr = pieces.begin();
for(std::deque<SharedHandle<Piece> >::iterator itr = pieces.begin();
itr != pieces.end() && getnum; ++itr) {
SharedHandle<Piece>& piece = *itr;
if(piece->getMissingUnusedBlockIndex(blockIndexes, getnum)) {
@ -181,17 +182,17 @@ void DefaultBtRequestFactory::createRequestMessages
}
void DefaultBtRequestFactory::createRequestMessagesOnEndGame
(std::deque<SharedHandle<BtMessage> >& requests, size_t max)
(std::vector<SharedHandle<BtMessage> >& requests, size_t max)
{
for(Pieces::iterator itr = pieces.begin();
for(std::deque<SharedHandle<Piece> >::iterator itr = pieces.begin();
itr != pieces.end() && requests.size() < max; ++itr) {
PieceHandle& piece = *itr;
SharedHandle<Piece>& piece = *itr;
const size_t mislen = piece->getBitfieldLength();
array_ptr<unsigned char> misbitfield(new unsigned char[mislen]);
piece->getAllMissingBlockIndexes(misbitfield, mislen);
std::deque<size_t> missingBlockIndexes;
std::vector<size_t> missingBlockIndexes;
size_t blockIndex = 0;
for(size_t i = 0; i < mislen; ++i) {
unsigned char bits = misbitfield[i];
@ -204,7 +205,7 @@ void DefaultBtRequestFactory::createRequestMessagesOnEndGame
}
std::random_shuffle(missingBlockIndexes.begin(), missingBlockIndexes.end(),
*(SimpleRandomizer::getInstance().get()));
for(std::deque<size_t>::const_iterator bitr = missingBlockIndexes.begin();
for(std::vector<size_t>::const_iterator bitr = missingBlockIndexes.begin();
bitr != missingBlockIndexes.end() && requests.size() < max; bitr++) {
const size_t& blockIndex = *bitr;
if(!dispatcher->isOutstandingRequest(piece->getIndex(),
@ -247,7 +248,7 @@ size_t DefaultBtRequestFactory::countMissingBlock()
}
void DefaultBtRequestFactory::getTargetPieceIndexes
(std::deque<size_t>& indexes) const
(std::vector<size_t>& indexes) const
{
std::transform(pieces.begin(), pieces.end(), std::back_inserter(indexes),
mem_fun_sh(&Piece::getIndex));

8
src/DefaultBtRequestFactory.h
View File

@ -37,6 +37,8 @@
#include "BtRequestFactory.h"
#include <deque>
namespace aria2 {
class PieceStorage;
@ -77,12 +79,12 @@ public:
virtual void doChokedAction();
virtual void createRequestMessages
(std::deque<SharedHandle<BtMessage> >& requests, size_t max);
(std::vector<SharedHandle<BtMessage> >& requests, size_t max);
virtual void createRequestMessagesOnEndGame
(std::deque<SharedHandle<BtMessage> >& requests, size_t max);
(std::vector<SharedHandle<BtMessage> >& requests, size_t max);
virtual void getTargetPieceIndexes(std::deque<size_t>& indexes) const;
virtual void getTargetPieceIndexes(std::vector<size_t>& indexes) const;
std::deque<SharedHandle<Piece> >& getTargetPieces()
{

4
src/DefaultExtensionMessageFactory.cc
View File

@ -60,7 +60,7 @@ DefaultExtensionMessageFactory::DefaultExtensionMessageFactory():
_logger(LogFactory::getInstance()) {}
DefaultExtensionMessageFactory::DefaultExtensionMessageFactory
(const PeerHandle& peer,
(const SharedHandle<Peer>& peer,
const SharedHandle<ExtensionMessageRegistry>& registry):
_peer(peer),
_registry(registry),
@ -163,7 +163,7 @@ void DefaultExtensionMessageFactory::setPeerStorage
_peerStorage = peerStorage;
}
void DefaultExtensionMessageFactory::setPeer(const PeerHandle& peer)
void DefaultExtensionMessageFactory::setPeer(const SharedHandle<Peer>& peer)
{
_peer = peer;
}

70
src/DefaultPeerStorage.cc
View File

@ -68,19 +68,20 @@ DefaultPeerStorage::~DefaultPeerStorage()
class FindIdenticalPeer {
private:
PeerHandle _peer;
SharedHandle<Peer> _peer;
public:
FindIdenticalPeer(const PeerHandle& peer):_peer(peer) {}
FindIdenticalPeer(const SharedHandle<Peer>& peer):_peer(peer) {}
bool operator()(const PeerHandle& peer) const {
bool operator()(const SharedHandle<Peer>& peer) const {
return (_peer == peer) ||
((_peer->ipaddr == peer->ipaddr) && (_peer->port == peer->port));
}
};
bool DefaultPeerStorage::isPeerAlreadyAdded(const PeerHandle& peer)
bool DefaultPeerStorage::isPeerAlreadyAdded(const SharedHandle<Peer>& peer)
{
return std::find_if(peers.begin(), peers.end(), FindIdenticalPeer(peer)) != peers.end();
return std::find_if(peers.begin(), peers.end(),
FindIdenticalPeer(peer)) != peers.end();
}
static size_t calculateMaxPeerListSize(const SharedHandle<BtRuntime>& btRuntime)
@ -93,7 +94,7 @@ static size_t calculateMaxPeerListSize(const SharedHandle<BtRuntime>& btRuntime)
btRuntime->getMaxPeers()+(btRuntime->getMaxPeers() >> 2);
}
bool DefaultPeerStorage::addPeer(const PeerHandle& peer) {
bool DefaultPeerStorage::addPeer(const SharedHandle<Peer>& peer) {
if(isPeerAlreadyAdded(peer)) {
if(logger->debug()) {
logger->debug("Adding %s:%u is rejected because it has been already"
@ -109,10 +110,11 @@ bool DefaultPeerStorage::addPeer(const PeerHandle& peer) {
return true;
}
void DefaultPeerStorage::addPeer(const Peers& peers) {
for(Peers::const_iterator itr = peers.begin();
void DefaultPeerStorage::addPeer(const std::vector<SharedHandle<Peer> >& peers)
{
for(std::vector<SharedHandle<Peer> >::const_iterator itr = peers.begin();
itr != peers.end(); ++itr) {
const PeerHandle& peer = *itr;
const SharedHandle<Peer>& peer = *itr;
if(addPeer(peer)) {
if(logger->debug()) {
logger->debug(MSG_ADDING_PEER, peer->ipaddr.c_str(), peer->port);
@ -121,20 +123,21 @@ void DefaultPeerStorage::addPeer(const Peers& peers) {
}
}
const Peers& DefaultPeerStorage::getPeers() {
const std::deque<SharedHandle<Peer> >& DefaultPeerStorage::getPeers()
{
return peers;
}
class FindFinePeer {
public:
bool operator()(const PeerHandle& peer) const {
bool operator()(const SharedHandle<Peer>& peer) const {
return peer->unused() && peer->isGood();
}
};
PeerHandle DefaultPeerStorage::getUnusedPeer() {
Peers::const_iterator itr = std::find_if(peers.begin(), peers.end(),
FindFinePeer());
SharedHandle<Peer> DefaultPeerStorage::getUnusedPeer() {
std::deque<SharedHandle<Peer> >::const_iterator itr =
std::find_if(peers.begin(), peers.end(), FindFinePeer());
if(itr == peers.end()) {
return SharedHandle<Peer>();
} else {
@ -147,17 +150,18 @@ private:
std::string ipaddr;
uint16_t port;
public:
FindPeer(const std::string& ipaddr, uint16_t port):ipaddr(ipaddr), port(port) {}
FindPeer(const std::string& ipaddr, uint16_t port):
ipaddr(ipaddr), port(port) {}
bool operator()(const PeerHandle& peer) const {
bool operator()(const SharedHandle<Peer>& peer) const {
return ipaddr == peer->ipaddr && port == peer->port;
}
};
PeerHandle DefaultPeerStorage::getPeer(const std::string& ipaddr,
uint16_t port) const {
Peers::const_iterator itr = std::find_if(peers.begin(), peers.end(),
FindPeer(ipaddr, port));
SharedHandle<Peer> DefaultPeerStorage::getPeer(const std::string& ipaddr,
uint16_t port) const {
std::deque<SharedHandle<Peer> >::const_iterator itr =
std::find_if(peers.begin(), peers.end(), FindPeer(ipaddr, port));
if(itr == peers.end()) {
return SharedHandle<Peer>();
} else {
@ -175,9 +179,9 @@ bool DefaultPeerStorage::isPeerAvailable() {
class CollectActivePeer {
private:
std::deque<SharedHandle<Peer> >& _activePeers;
std::vector<SharedHandle<Peer> >& _activePeers;
public:
CollectActivePeer(std::deque<SharedHandle<Peer> >& activePeers):
CollectActivePeer(std::vector<SharedHandle<Peer> >& activePeers):
_activePeers(activePeers) {}
void operator()(const SharedHandle<Peer>& peer)
@ -188,7 +192,8 @@ public:
}
};
void DefaultPeerStorage::getActivePeers(std::deque<SharedHandle<Peer> >& activePeers)
void DefaultPeerStorage::getActivePeers
(std::vector<SharedHandle<Peer> >& activePeers)
{
std::for_each(peers.begin(), peers.end(), CollectActivePeer(activePeers));
}
@ -214,12 +219,12 @@ TransferStat DefaultPeerStorage::calculateStat()
}
_lastTransferStatMapUpdated.reset();
_peerTransferStatMap.clear();
std::deque<SharedHandle<Peer> > activePeers;
std::vector<SharedHandle<Peer> > activePeers;
getActivePeers(activePeers);
struct timeval now;
gettimeofday(&now, 0);
for(std::deque<SharedHandle<Peer> >::const_iterator i = activePeers.begin();
i != activePeers.end(); ++i) {
for(std::vector<SharedHandle<Peer> >::const_iterator i =
activePeers.begin(); i != activePeers.end(); ++i) {
TransferStat s;
s.downloadSpeed = (*i)->calculateDownloadSpeed(now);
s.uploadSpeed = (*i)->calculateUploadSpeed(now);
@ -261,10 +266,10 @@ TransferStat DefaultPeerStorage::getTransferStatFor
}
void DefaultPeerStorage::deleteUnusedPeer(size_t delSize) {
Peers temp;
for(Peers::reverse_iterator itr = peers.rbegin();
std::deque<SharedHandle<Peer> > temp;
for(std::deque<SharedHandle<Peer> >::reverse_iterator itr = peers.rbegin();
itr != peers.rend(); ++itr) {
const PeerHandle& p = *itr;
const SharedHandle<Peer>& p = *itr;
if(p->unused() && delSize > 0) {
onErasingPeer(p);
delSize--;
@ -293,9 +298,10 @@ void DefaultPeerStorage::onReturningPeer(const SharedHandle<Peer>& peer)
}
}
void DefaultPeerStorage::returnPeer(const PeerHandle& peer)
void DefaultPeerStorage::returnPeer(const SharedHandle<Peer>& peer)
{
Peers::iterator itr = std::find(peers.begin(), peers.end(), peer);
std::deque<SharedHandle<Peer> >::iterator itr =
std::find(peers.begin(), peers.end(), peer);
if(itr == peers.end()) {
if(logger->debug()) {
logger->debug("Cannot find peer %s:%u in PeerStorage.",
@ -321,7 +327,7 @@ bool DefaultPeerStorage::chokeRoundIntervalElapsed()
void DefaultPeerStorage::executeChoke()
{
std::deque<SharedHandle<Peer> > activePeers;
std::vector<SharedHandle<Peer> > activePeers;
getActivePeers(activePeers);
if(_pieceStorage->downloadFinished()) {
return _seederStateChoke->executeChoke(activePeers);

4
src/DefaultPeerStorage.h
View File

@ -83,13 +83,13 @@ public:
SharedHandle<Peer> getPeer(const std::string& ipaddr, uint16_t port) const;
virtual void addPeer(const std::deque<SharedHandle<Peer> >& peers);
virtual void addPeer(const std::vector<SharedHandle<Peer> >& peers);
virtual const std::deque<SharedHandle<Peer> >& getPeers();
virtual bool isPeerAvailable();
virtual void getActivePeers(std::deque<SharedHandle<Peer> >& peers);
virtual void getActivePeers(std::vector<SharedHandle<Peer> >& peers);
virtual TransferStat calculateStat();

63
src/DefaultPieceStorage.cc
View File

@ -105,11 +105,11 @@ bool DefaultPieceStorage::getMissingPieceIndex(size_t& index,
}
}
PieceHandle DefaultPieceStorage::checkOutPiece(size_t index)
SharedHandle<Piece> DefaultPieceStorage::checkOutPiece(size_t index)
{
bitfieldMan->setUseBit(index);
PieceHandle piece = findUsedPiece(index);
SharedHandle<Piece> piece = findUsedPiece(index);
if(piece.isNull()) {
piece.reset(new Piece(index, bitfieldMan->getBlockLength(index)));
@ -130,9 +130,9 @@ PieceHandle DefaultPieceStorage::checkOutPiece(size_t index)
* Newly instantiated piece is not added to usedPieces.
* Because it is waste of memory and there is no chance to use them later.
*/
PieceHandle DefaultPieceStorage::getPiece(size_t index)
SharedHandle<Piece> DefaultPieceStorage::getPiece(size_t index)
{
PieceHandle piece;
SharedHandle<Piece> piece;
if(0 <= index && index <= bitfieldMan->getMaxIndex()) {
piece = findUsedPiece(index);
if(piece.isNull()) {
@ -145,7 +145,7 @@ PieceHandle DefaultPieceStorage::getPiece(size_t index)
return piece;
}
void DefaultPieceStorage::addUsedPiece(const PieceHandle& piece)
void DefaultPieceStorage::addUsedPiece(const SharedHandle<Piece>& piece)
{
std::deque<SharedHandle<Piece> >::iterator i =
std::lower_bound(usedPieces.begin(), usedPieces.end(), piece);
@ -156,7 +156,7 @@ void DefaultPieceStorage::addUsedPiece(const PieceHandle& piece)
}
}
PieceHandle DefaultPieceStorage::findUsedPiece(size_t index) const
SharedHandle<Piece> DefaultPieceStorage::findUsedPiece(size_t index) const
{
SharedHandle<Piece> p(new Piece());
p->setIndex(index);
@ -190,13 +190,14 @@ SharedHandle<Piece> DefaultPieceStorage::getMissingPiece
#ifdef ENABLE_BITTORRENT
bool DefaultPieceStorage::hasMissingPiece(const PeerHandle& peer)
bool DefaultPieceStorage::hasMissingPiece(const SharedHandle<Peer>& peer)
{
return bitfieldMan->hasMissingPiece(peer->getBitfield(),
peer->getBitfieldLength());
}
PieceHandle DefaultPieceStorage::getMissingPiece(const SharedHandle<Peer>& peer)
SharedHandle<Piece>
DefaultPieceStorage::getMissingPiece(const SharedHandle<Peer>& peer)
{
return getMissingPiece(peer->getBitfield(), peer->getBitfieldLength());
}
@ -204,7 +205,7 @@ PieceHandle DefaultPieceStorage::getMissingPiece(const SharedHandle<Peer>& peer)
void DefaultPieceStorage::createFastIndexBitfield
(BitfieldMan& bitfield, const SharedHandle<Peer>& peer)
{
for(std::deque<size_t>::const_iterator itr =
for(std::vector<size_t>::const_iterator itr =
peer->getPeerAllowedIndexSet().begin();
itr != peer->getPeerAllowedIndexSet().end(); ++itr) {
if(!bitfieldMan->isBitSet(*itr) && peer->hasPiece(*itr)) {
@ -213,7 +214,7 @@ void DefaultPieceStorage::createFastIndexBitfield
}
}
PieceHandle DefaultPieceStorage::getMissingFastPiece
SharedHandle<Piece> DefaultPieceStorage::getMissingFastPiece
(const SharedHandle<Peer>& peer)
{
if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) {
@ -227,16 +228,14 @@ PieceHandle DefaultPieceStorage::getMissingFastPiece
}
static void unsetExcludedIndexes(BitfieldMan& bitfield,
const std::deque<size_t>& excludedIndexes)
const std::vector<size_t>& excludedIndexes)
{
for(std::deque<size_t>::const_iterator i = excludedIndexes.begin();
i != excludedIndexes.end(); ++i) {
bitfield.unsetBit(*i);
}
std::for_each(excludedIndexes.begin(), excludedIndexes.end(),
std::bind1st(std::mem_fun(&BitfieldMan::unsetBit), &bitfield));
}
SharedHandle<Piece> DefaultPieceStorage::getMissingPiece
(const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes)
(const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes)
{
BitfieldMan tempBitfield(bitfieldMan->getBlockLength(),
bitfieldMan->getTotalLength());
@ -246,7 +245,7 @@ SharedHandle<Piece> DefaultPieceStorage::getMissingPiece
}
SharedHandle<Piece> DefaultPieceStorage::getMissingFastPiece
(const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes)
(const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes)
{
if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) {
BitfieldMan tempBitfield(bitfieldMan->getBlockLength(),
@ -267,7 +266,7 @@ bool DefaultPieceStorage::hasMissingUnusedPiece()
return bitfieldMan->getFirstMissingUnusedIndex(index);
}
PieceHandle DefaultPieceStorage::getSparseMissingUnusedPiece
SharedHandle<Piece> DefaultPieceStorage::getSparseMissingUnusedPiece
(const unsigned char* ignoreBitfield, size_t length)
{
size_t index;
@ -278,7 +277,7 @@ PieceHandle DefaultPieceStorage::getSparseMissingUnusedPiece
}
}
PieceHandle DefaultPieceStorage::getMissingPiece(size_t index)
SharedHandle<Piece> DefaultPieceStorage::getMissingPiece(size_t index)
{
if(hasPiece(index) || isPieceUsed(index)) {
return SharedHandle<Piece>();
@ -287,7 +286,7 @@ PieceHandle DefaultPieceStorage::getMissingPiece(size_t index)
}
}
void DefaultPieceStorage::deleteUsedPiece(const PieceHandle& piece)
void DefaultPieceStorage::deleteUsedPiece(const SharedHandle<Piece>& piece)
{
if(piece.isNull()) {
return;
@ -319,7 +318,7 @@ void DefaultPieceStorage::deleteUsedPiece(const PieceHandle& piece)
// size_t deleted = 0;
// for(Pieces::iterator itr = usedPieces.begin();
// itr != usedPieces.end() && deleted < delNum;) {
// PieceHandle& piece = *itr;
// SharedHandle<Piece>& piece = *itr;
// if(!bitfieldMan->isUseBitSet(piece->getIndex()) &&
// piece->countCompleteBlock() <= piece->countBlock()*(fillRate/100.0)) {
// logger->info(MSG_DELETING_USED_PIECE,
@ -335,7 +334,7 @@ void DefaultPieceStorage::deleteUsedPiece(const PieceHandle& piece)
// return deleted;
// }
void DefaultPieceStorage::completePiece(const PieceHandle& piece)
void DefaultPieceStorage::completePiece(const SharedHandle<Piece>& piece)
{
if(piece.isNull()) {
return;
@ -369,7 +368,7 @@ bool DefaultPieceStorage::isSelectiveDownloadingMode()
}
// not unittested
void DefaultPieceStorage::cancelPiece(const PieceHandle& piece)
void DefaultPieceStorage::cancelPiece(const SharedHandle<Piece>& piece)
{
if(piece.isNull()) {
return;
@ -541,12 +540,13 @@ void DefaultPieceStorage::advertisePiece(int32_t cuid, size_t index)
}
void
DefaultPieceStorage::getAdvertisedPieceIndexes(std::deque<size_t>& indexes,
DefaultPieceStorage::getAdvertisedPieceIndexes(std::vector<size_t>& indexes,
int32_t myCuid,
const Time& lastCheckTime)
{
for(Haves::const_iterator itr = haves.begin(); itr != haves.end(); itr++) {
const Haves::value_type& have = *itr;
for(std::deque<HaveEntry>::const_iterator itr = haves.begin();
itr != haves.end(); ++itr) {
const HaveEntry& have = *itr;
if(have.getCuid() == myCuid) {
continue;
}
@ -575,7 +575,7 @@ public:
void DefaultPieceStorage::removeAdvertisedPiece(time_t elapsed)
{
Haves::iterator itr =
std::deque<HaveEntry>::iterator itr =
std::find_if(haves.begin(), haves.end(), FindElapsedHave(elapsed));
if(itr != haves.end()) {
if(logger->debug()) {
@ -601,7 +601,8 @@ void DefaultPieceStorage::markPiecesDone(uint64_t length)
}
size_t r = (length%bitfieldMan->getBlockLength())/Piece::BLOCK_LENGTH;
if(r > 0) {
PieceHandle p(new Piece(numPiece, bitfieldMan->getBlockLength(numPiece)));
SharedHandle<Piece> p
(new Piece(numPiece, bitfieldMan->getBlockLength(numPiece)));
for(size_t i = 0; i < r; ++i) {
p->completeBlock(i);
@ -623,7 +624,8 @@ void DefaultPieceStorage::markPieceMissing(size_t index)
bitfieldMan->unsetBit(index);
}
void DefaultPieceStorage::addInFlightPiece(const Pieces& pieces)
void DefaultPieceStorage::addInFlightPiece
(const std::vector<SharedHandle<Piece> >& pieces)
{
usedPieces.insert(usedPieces.end(), pieces.begin(), pieces.end());
std::sort(usedPieces.begin(), usedPieces.end());
@ -634,7 +636,8 @@ size_t DefaultPieceStorage::countInFlightPiece()
return usedPieces.size();
}
void DefaultPieceStorage::getInFlightPieces(std::deque<SharedHandle<Piece> >& pieces)
void DefaultPieceStorage::getInFlightPieces
(std::vector<SharedHandle<Piece> >& pieces)
{
pieces.insert(pieces.end(), usedPieces.begin(), usedPieces.end());
}

18
src/DefaultPieceStorage.h
View File

@ -37,6 +37,8 @@
#include "PieceStorage.h"
#include <deque>
namespace aria2 {
class DownloadContext;
@ -67,8 +69,6 @@ public:
const Time& getRegisteredTime() const { return registeredTime; }
};
typedef std::deque<HaveEntry> Haves;
class DefaultPieceStorage : public PieceStorage {
private:
SharedHandle<DownloadContext> downloadContext;
@ -80,7 +80,7 @@ private:
size_t endGamePieceNum;
Logger* logger;
const Option* option;
Haves haves;
std::deque<HaveEntry> haves;
SharedHandle<PieceStatMan> _pieceStatMan;
@ -126,10 +126,10 @@ public:
virtual SharedHandle<Piece> getMissingFastPiece(const SharedHandle<Peer>& peer);
virtual SharedHandle<Piece> getMissingPiece
(const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes);
(const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes);
virtual SharedHandle<Piece> getMissingFastPiece
(const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes);
(const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes);
#endif // ENABLE_BITTORRENT
@ -194,7 +194,7 @@ public:
virtual void advertisePiece(int32_t cuid, size_t index);
virtual void
getAdvertisedPieceIndexes(std::deque<size_t>& indexes,
getAdvertisedPieceIndexes(std::vector<size_t>& indexes,
int32_t myCuid, const Time& lastCheckTime);
virtual void removeAdvertisedPiece(time_t elapsed);
@ -205,11 +205,13 @@ public:
virtual void markPieceMissing(size_t index);
virtual void addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces);
virtual void addInFlightPiece
(const std::vector<SharedHandle<Piece> >& pieces);
virtual size_t countInFlightPiece();
virtual void getInFlightPieces(std::deque<SharedHandle<Piece> >& pieces);
virtual void getInFlightPieces
(std::vector<SharedHandle<Piece> >& pieces);
virtual void addPieceStats(size_t index);

11
src/DownloadCommand.cc
View File

@ -67,7 +67,7 @@ namespace aria2 {
static const size_t BUFSIZE = 16*1024;
DownloadCommand::DownloadCommand(int cuid,
const RequestHandle& req,
const SharedHandle<Request>& req,
const SharedHandle<FileEntry>& fileEntry,
RequestGroup* requestGroup,
DownloadEngine* e,
@ -112,7 +112,7 @@ bool DownloadCommand::executeInternal() {
return false;
}
setReadCheckSocket(socket);
SegmentHandle segment = _segments.front();
SharedHandle<Segment> segment = _segments.front();
size_t bufSize;
if(segment->getLength() > 0) {
@ -279,7 +279,8 @@ bool DownloadCommand::prepareForNextSegment() {
}
}
#ifdef ENABLE_MESSAGE_DIGEST
CheckIntegrityEntryHandle entry(new ChecksumCheckIntegrityEntry(_requestGroup));
SharedHandle<CheckIntegrityEntry> entry
(new ChecksumCheckIntegrityEntry(_requestGroup));
if(entry->isValidationReady()) {
entry->initValidator();
// TODO do we need cuttrailinggarbage here?
@ -293,11 +294,11 @@ bool DownloadCommand::prepareForNextSegment() {
// The number of segments should be 1 in order to pass through the next
// segment.
if(_segments.size() == 1) {
SegmentHandle tempSegment = _segments.front();
SharedHandle<Segment> tempSegment = _segments.front();
if(!tempSegment->complete()) {
return prepareForRetry(0);
}
SegmentHandle nextSegment =
SharedHandle<Segment> nextSegment =
_requestGroup->getSegmentMan()->getSegment(cuid,
tempSegment->getIndex()+1);
if(!nextSegment.isNull() && nextSegment->getWrittenLength() == 0) {

2
src/DownloadContext.cc
View File

@ -120,7 +120,7 @@ void DownloadContext::setFilePathWithIndex
void DownloadContext::setFileFilter(IntSequence seq)
{
std::deque<int32_t> fileIndexes = seq.flush();
std::vector<int32_t> fileIndexes = seq.flush();
std::sort(fileIndexes.begin(), fileIndexes.end());
fileIndexes.erase(std::unique(fileIndexes.begin(), fileIndexes.end()),
fileIndexes.end());

10
src/DownloadEngine.cc
View File

@ -237,7 +237,7 @@ void DownloadEngine::setStatCalc(const StatCalcHandle& statCalc)
_statCalc = statCalc;
}
void DownloadEngine::addCommand(const Commands& commands)
void DownloadEngine::addCommand(const std::vector<Command*>& commands)
{
this->commands.insert(this->commands.end(), commands.begin(), commands.end());
}
@ -398,10 +398,10 @@ DownloadEngine::popPooledSocket(std::map<std::string, std::string>& options,
SharedHandle<SocketCore>
DownloadEngine::popPooledSocket
(const std::deque<std::string>& ipaddrs, uint16_t port)
(const std::vector<std::string>& ipaddrs, uint16_t port)
{
SharedHandle<SocketCore> s;
for(std::deque<std::string>::const_iterator i = ipaddrs.begin();
for(std::vector<std::string>::const_iterator i = ipaddrs.begin();
i != ipaddrs.end(); ++i) {
s = popPooledSocket(*i, port);
if(!s.isNull()) {
@ -414,10 +414,10 @@ DownloadEngine::popPooledSocket
SharedHandle<SocketCore>
DownloadEngine::popPooledSocket
(std::map<std::string, std::string>& options,
const std::deque<std::string>& ipaddrs, uint16_t port)
const std::vector<std::string>& ipaddrs, uint16_t port)
{
SharedHandle<SocketCore> s;
for(std::deque<std::string>::const_iterator i = ipaddrs.begin();
for(std::vector<std::string>::const_iterator i = ipaddrs.begin();
i != ipaddrs.end(); ++i) {
s = popPooledSocket(options, *i, port);
if(!s.isNull()) {

7
src/DownloadEngine.h
View File

@ -40,6 +40,7 @@
#include <string>
#include <deque>
#include <map>
#include <vector>
#include "SharedHandle.h"
#include "a2netcompat.h"
@ -184,7 +185,7 @@ public:
Command* command);
#endif // ENABLE_ASYNC_DNS
void addCommand(const std::deque<Command*>& commands);
void addCommand(const std::vector<Command*>& commands);
void setStatCalc(const SharedHandle<StatCalc>& statCalc);
@ -228,12 +229,12 @@ public:
uint16_t port);
SharedHandle<SocketCore>
popPooledSocket(const std::deque<std::string>& ipaddrs, uint16_t port);
popPooledSocket(const std::vector<std::string>& ipaddrs, uint16_t port);
SharedHandle<SocketCore>
popPooledSocket
(std::map<std::string, std::string>& options,
const std::deque<std::string>& ipaddrs,
const std::vector<std::string>& ipaddrs,
uint16_t port);
const SharedHandle<CookieStorage>& getCookieStorage() const

Some files were not shown because too many files have changed in this diff Show More