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

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

Renamed member variables.
	* src/DefaultPieceStorage.cc
	* src/DefaultPieceStorage.h
pull/1/head
Tatsuhiro Tsujikawa 2010-06-12 09:05:26 +00:00
parent 4f7746a89c
commit e1d0911020
3 changed files with 145 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ChangeLog
View File

@ -1,3 +1,9 @@
2010-06-12 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Renamed member variables.
* src/DefaultPieceStorage.cc
* src/DefaultPieceStorage.h
2010-06-12 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net> 2010-06-12 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Renamed member variables. Removed unused member variable. Renamed member variables. Removed unused member variable.

224
src/DefaultPieceStorage.cc
View File

@ -64,43 +64,44 @@ namespace aria2 {
DefaultPieceStorage::DefaultPieceStorage DefaultPieceStorage::DefaultPieceStorage
(const SharedHandle<DownloadContext>& downloadContext, const Option* option): (const SharedHandle<DownloadContext>& downloadContext, const Option* option):
downloadContext(downloadContext), _downloadContext(downloadContext),
bitfieldMan(new BitfieldMan(downloadContext->getPieceLength(), _bitfieldMan(new BitfieldMan(downloadContext->getPieceLength(),
downloadContext->getTotalLength())), downloadContext->getTotalLength())),
_diskWriterFactory(new DefaultDiskWriterFactory()), _diskWriterFactory(new DefaultDiskWriterFactory()),
endGamePieceNum(END_GAME_PIECE_NUM), _endGamePieceNum(END_GAME_PIECE_NUM),
logger(LogFactory::getInstance()), _logger(LogFactory::getInstance()),
option(option), _option(option),
_pieceStatMan(new PieceStatMan(downloadContext->getNumPieces(), true)), _pieceStatMan(new PieceStatMan(downloadContext->getNumPieces(), true)),
_pieceSelector(new RarestPieceSelector(_pieceStatMan)) _pieceSelector(new RarestPieceSelector(_pieceStatMan))
{} {}
DefaultPieceStorage::~DefaultPieceStorage() { DefaultPieceStorage::~DefaultPieceStorage() {
delete bitfieldMan; delete _bitfieldMan;
} }
bool DefaultPieceStorage::isEndGame() bool DefaultPieceStorage::isEndGame()
{ {
return bitfieldMan->countMissingBlock() <= endGamePieceNum; return _bitfieldMan->countMissingBlock() <= _endGamePieceNum;
} }
bool DefaultPieceStorage::getMissingPieceIndex(size_t& index, bool DefaultPieceStorage::getMissingPieceIndex(size_t& index,
const unsigned char* bitfield, const unsigned char* bitfield,
size_t length) size_t length)
{ {
const size_t mislen = bitfieldMan->getBitfieldLength(); const size_t mislen = _bitfieldMan->getBitfieldLength();
array_ptr<unsigned char> misbitfield(new unsigned char[mislen]); array_ptr<unsigned char> misbitfield(new unsigned char[mislen]);
bool r; bool r;
if(isEndGame()) { if(isEndGame()) {
r = bitfieldMan->getAllMissingIndexes(misbitfield, mislen, r = _bitfieldMan->getAllMissingIndexes(misbitfield, mislen,
bitfield, length); bitfield, length);
} else { } else {
r = bitfieldMan->getAllMissingUnusedIndexes(misbitfield, mislen, r = _bitfieldMan->getAllMissingUnusedIndexes(misbitfield, mislen,
bitfield, length); bitfield, length);
} }
if(r) { if(r) {
// We assume indexes is sorted using comparator less. // We assume indexes is sorted using comparator less.
return _pieceSelector->select(index, misbitfield,bitfieldMan->countBlock()); return
_pieceSelector->select(index, misbitfield,_bitfieldMan->countBlock());
} else { } else {
return false; return false;
} }
@ -108,15 +109,15 @@ bool DefaultPieceStorage::getMissingPieceIndex(size_t& index,
SharedHandle<Piece> DefaultPieceStorage::checkOutPiece(size_t index) SharedHandle<Piece> DefaultPieceStorage::checkOutPiece(size_t index)
{ {
bitfieldMan->setUseBit(index); _bitfieldMan->setUseBit(index);
SharedHandle<Piece> piece = findUsedPiece(index); SharedHandle<Piece> piece = findUsedPiece(index);
if(piece.isNull()) { if(piece.isNull()) {
piece.reset(new Piece(index, bitfieldMan->getBlockLength(index))); piece.reset(new Piece(index, _bitfieldMan->getBlockLength(index)));
#ifdef ENABLE_MESSAGE_DIGEST #ifdef ENABLE_MESSAGE_DIGEST
piece->setHashAlgo(downloadContext->getPieceHashAlgo()); piece->setHashAlgo(_downloadContext->getPieceHashAlgo());
#endif // ENABLE_MESSAGE_DIGEST #endif // ENABLE_MESSAGE_DIGEST
@ -134,10 +135,10 @@ SharedHandle<Piece> DefaultPieceStorage::checkOutPiece(size_t index)
SharedHandle<Piece> DefaultPieceStorage::getPiece(size_t index) SharedHandle<Piece> DefaultPieceStorage::getPiece(size_t index)
{ {
SharedHandle<Piece> piece; SharedHandle<Piece> piece;
if(0 <= index && index <= bitfieldMan->getMaxIndex()) { if(0 <= index && index <= _bitfieldMan->getMaxIndex()) {
piece = findUsedPiece(index); piece = findUsedPiece(index);
if(piece.isNull()) { if(piece.isNull()) {
piece.reset(new Piece(index, bitfieldMan->getBlockLength(index))); piece.reset(new Piece(index, _bitfieldMan->getBlockLength(index)));
if(hasPiece(index)) { if(hasPiece(index)) {
piece->setAllBlock(); piece->setAllBlock();
} }
@ -149,11 +150,11 @@ SharedHandle<Piece> DefaultPieceStorage::getPiece(size_t index)
void DefaultPieceStorage::addUsedPiece(const SharedHandle<Piece>& piece) void DefaultPieceStorage::addUsedPiece(const SharedHandle<Piece>& piece)
{ {
std::deque<SharedHandle<Piece> >::iterator i = std::deque<SharedHandle<Piece> >::iterator i =
std::lower_bound(usedPieces.begin(), usedPieces.end(), piece); std::lower_bound(_usedPieces.begin(), _usedPieces.end(), piece);
usedPieces.insert(i, piece); _usedPieces.insert(i, piece);
if(logger->debug()) { if(_logger->debug()) {
logger->debug("usedPieces.size()=%lu", _logger->debug("_usedPieces.size()=%lu",
static_cast<unsigned long>(usedPieces.size())); static_cast<unsigned long>(_usedPieces.size()));
} }
} }
@ -163,8 +164,8 @@ SharedHandle<Piece> DefaultPieceStorage::findUsedPiece(size_t index) const
p->setIndex(index); p->setIndex(index);
std::deque<SharedHandle<Piece> >::const_iterator i = std::deque<SharedHandle<Piece> >::const_iterator i =
std::lower_bound(usedPieces.begin(), usedPieces.end(), p); std::lower_bound(_usedPieces.begin(), _usedPieces.end(), p);
if(i != usedPieces.end() && (*i) == p) { if(i != _usedPieces.end() && (*i) == p) {
return *i; return *i;
} else { } else {
p.reset(0); p.reset(0);
@ -193,8 +194,8 @@ SharedHandle<Piece> DefaultPieceStorage::getMissingPiece
bool DefaultPieceStorage::hasMissingPiece(const SharedHandle<Peer>& peer) bool DefaultPieceStorage::hasMissingPiece(const SharedHandle<Peer>& peer)
{ {
return bitfieldMan->hasMissingPiece(peer->getBitfield(), return _bitfieldMan->hasMissingPiece(peer->getBitfield(),
peer->getBitfieldLength()); peer->getBitfieldLength());
} }
SharedHandle<Piece> SharedHandle<Piece>
@ -209,7 +210,7 @@ void DefaultPieceStorage::createFastIndexBitfield
for(std::vector<size_t>::const_iterator itr = for(std::vector<size_t>::const_iterator itr =
peer->getPeerAllowedIndexSet().begin(), peer->getPeerAllowedIndexSet().begin(),
eoi = peer->getPeerAllowedIndexSet().end(); itr != eoi; ++itr) { eoi = peer->getPeerAllowedIndexSet().end(); itr != eoi; ++itr) {
if(!bitfieldMan->isBitSet(*itr) && peer->hasPiece(*itr)) { if(!_bitfieldMan->isBitSet(*itr) && peer->hasPiece(*itr)) {
bitfield.setBit(*itr); bitfield.setBit(*itr);
} }
} }
@ -219,8 +220,8 @@ SharedHandle<Piece> DefaultPieceStorage::getMissingFastPiece
(const SharedHandle<Peer>& peer) (const SharedHandle<Peer>& peer)
{ {
if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) { if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) {
BitfieldMan tempBitfield(bitfieldMan->getBlockLength(), BitfieldMan tempBitfield(_bitfieldMan->getBlockLength(),
bitfieldMan->getTotalLength()); _bitfieldMan->getTotalLength());
createFastIndexBitfield(tempBitfield, peer); createFastIndexBitfield(tempBitfield, peer);
return getMissingPiece(tempBitfield); return getMissingPiece(tempBitfield);
} else { } else {
@ -238,8 +239,8 @@ static void unsetExcludedIndexes(BitfieldMan& bitfield,
SharedHandle<Piece> DefaultPieceStorage::getMissingPiece SharedHandle<Piece> DefaultPieceStorage::getMissingPiece
(const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes) (const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes)
{ {
BitfieldMan tempBitfield(bitfieldMan->getBlockLength(), BitfieldMan tempBitfield(_bitfieldMan->getBlockLength(),
bitfieldMan->getTotalLength()); _bitfieldMan->getTotalLength());
tempBitfield.setBitfield(peer->getBitfield(), peer->getBitfieldLength()); tempBitfield.setBitfield(peer->getBitfield(), peer->getBitfieldLength());
unsetExcludedIndexes(tempBitfield, excludedIndexes); unsetExcludedIndexes(tempBitfield, excludedIndexes);
return getMissingPiece(tempBitfield); return getMissingPiece(tempBitfield);
@ -249,8 +250,8 @@ SharedHandle<Piece> DefaultPieceStorage::getMissingFastPiece
(const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes) (const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes)
{ {
if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) { if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) {
BitfieldMan tempBitfield(bitfieldMan->getBlockLength(), BitfieldMan tempBitfield(_bitfieldMan->getBlockLength(),
bitfieldMan->getTotalLength()); _bitfieldMan->getTotalLength());
createFastIndexBitfield(tempBitfield, peer); createFastIndexBitfield(tempBitfield, peer);
unsetExcludedIndexes(tempBitfield, excludedIndexes); unsetExcludedIndexes(tempBitfield, excludedIndexes);
return getMissingPiece(tempBitfield); return getMissingPiece(tempBitfield);
@ -264,14 +265,14 @@ SharedHandle<Piece> DefaultPieceStorage::getMissingFastPiece
bool DefaultPieceStorage::hasMissingUnusedPiece() bool DefaultPieceStorage::hasMissingUnusedPiece()
{ {
size_t index; size_t index;
return bitfieldMan->getFirstMissingUnusedIndex(index); return _bitfieldMan->getFirstMissingUnusedIndex(index);
} }
SharedHandle<Piece> DefaultPieceStorage::getSparseMissingUnusedPiece SharedHandle<Piece> DefaultPieceStorage::getSparseMissingUnusedPiece
(const unsigned char* ignoreBitfield, size_t length) (const unsigned char* ignoreBitfield, size_t length)
{ {
size_t index; size_t index;
if(bitfieldMan->getSparseMissingUnusedIndex(index, ignoreBitfield, length)) { if(_bitfieldMan->getSparseMissingUnusedIndex(index, ignoreBitfield, length)) {
return checkOutPiece(index); return checkOutPiece(index);
} else { } else {
return SharedHandle<Piece>(); return SharedHandle<Piece>();
@ -293,9 +294,9 @@ void DefaultPieceStorage::deleteUsedPiece(const SharedHandle<Piece>& piece)
return; return;
} }
std::deque<SharedHandle<Piece> >::iterator i = std::deque<SharedHandle<Piece> >::iterator i =
std::lower_bound(usedPieces.begin(), usedPieces.end(), piece); std::lower_bound(_usedPieces.begin(), _usedPieces.end(), piece);
if(i != usedPieces.end() && (*i) == piece) { if(i != _usedPieces.end() && (*i) == piece) {
usedPieces.erase(i); _usedPieces.erase(i);
} }
} }
@ -347,25 +348,25 @@ void DefaultPieceStorage::completePiece(const SharedHandle<Piece>& piece)
if(allDownloadFinished()) { if(allDownloadFinished()) {
return; return;
} }
bitfieldMan->setBit(piece->getIndex()); _bitfieldMan->setBit(piece->getIndex());
bitfieldMan->unsetUseBit(piece->getIndex()); _bitfieldMan->unsetUseBit(piece->getIndex());
addPieceStats(piece->getIndex()); addPieceStats(piece->getIndex());
if(downloadFinished()) { if(downloadFinished()) {
downloadContext->resetDownloadStopTime(); _downloadContext->resetDownloadStopTime();
if(isSelectiveDownloadingMode()) { if(isSelectiveDownloadingMode()) {
logger->notice(MSG_SELECTIVE_DOWNLOAD_COMPLETED); _logger->notice(MSG_SELECTIVE_DOWNLOAD_COMPLETED);
// following line was commented out in order to stop sending request // following line was commented out in order to stop sending request
// message after user-specified files were downloaded. // message after user-specified files were downloaded.
//finishSelectiveDownloadingMode(); //finishSelectiveDownloadingMode();
} else { } else {
logger->info(MSG_DOWNLOAD_COMPLETED); _logger->info(MSG_DOWNLOAD_COMPLETED);
} }
} }
} }
bool DefaultPieceStorage::isSelectiveDownloadingMode() bool DefaultPieceStorage::isSelectiveDownloadingMode()
{ {
return bitfieldMan->isFilterEnabled(); return _bitfieldMan->isFilterEnabled();
} }
// not unittested // not unittested
@ -374,7 +375,7 @@ void DefaultPieceStorage::cancelPiece(const SharedHandle<Piece>& piece)
if(piece.isNull()) { if(piece.isNull()) {
return; return;
} }
bitfieldMan->unsetUseBit(piece->getIndex()); _bitfieldMan->unsetUseBit(piece->getIndex());
if(!isEndGame()) { if(!isEndGame()) {
if(piece->getCompletedLength() == 0) { if(piece->getCompletedLength() == 0) {
deleteUsedPiece(piece); deleteUsedPiece(piece);
@ -384,28 +385,28 @@ void DefaultPieceStorage::cancelPiece(const SharedHandle<Piece>& piece)
bool DefaultPieceStorage::hasPiece(size_t index) bool DefaultPieceStorage::hasPiece(size_t index)
{ {
return bitfieldMan->isBitSet(index); return _bitfieldMan->isBitSet(index);
} }
bool DefaultPieceStorage::isPieceUsed(size_t index) bool DefaultPieceStorage::isPieceUsed(size_t index)
{ {
return bitfieldMan->isUseBitSet(index); return _bitfieldMan->isUseBitSet(index);
} }
uint64_t DefaultPieceStorage::getTotalLength() uint64_t DefaultPieceStorage::getTotalLength()
{ {
return bitfieldMan->getTotalLength(); return _bitfieldMan->getTotalLength();
} }
uint64_t DefaultPieceStorage::getFilteredTotalLength() uint64_t DefaultPieceStorage::getFilteredTotalLength()
{ {
return bitfieldMan->getFilteredTotalLength(); return _bitfieldMan->getFilteredTotalLength();
} }
uint64_t DefaultPieceStorage::getCompletedLength() uint64_t DefaultPieceStorage::getCompletedLength()
{ {
uint64_t completedLength = uint64_t completedLength =
bitfieldMan->getCompletedLength()+getInFlightPieceCompletedLength(); _bitfieldMan->getCompletedLength()+getInFlightPieceCompletedLength();
uint64_t totalLength = getTotalLength(); uint64_t totalLength = getTotalLength();
if(completedLength > totalLength) { if(completedLength > totalLength) {
completedLength = totalLength; completedLength = totalLength;
@ -415,19 +416,22 @@ uint64_t DefaultPieceStorage::getCompletedLength()
uint64_t DefaultPieceStorage::getFilteredCompletedLength() uint64_t DefaultPieceStorage::getFilteredCompletedLength()
{ {
return bitfieldMan->getFilteredCompletedLength()+getInFlightPieceCompletedLength(); return _bitfieldMan->getFilteredCompletedLength()+
getInFlightPieceCompletedLength();
} }
size_t DefaultPieceStorage::getInFlightPieceCompletedLength() const size_t DefaultPieceStorage::getInFlightPieceCompletedLength() const
{ {
return std::accumulate(usedPieces.begin(), usedPieces.end(), 0, adopt2nd(std::plus<size_t>(), mem_fun_sh(&Piece::getCompletedLength))); return std::accumulate(_usedPieces.begin(), _usedPieces.end(),
0, adopt2nd(std::plus<size_t>(),
mem_fun_sh(&Piece::getCompletedLength)));
} }
// not unittested // not unittested
void DefaultPieceStorage::setupFileFilter() void DefaultPieceStorage::setupFileFilter()
{ {
const std::vector<SharedHandle<FileEntry> >& fileEntries = const std::vector<SharedHandle<FileEntry> >& fileEntries =
downloadContext->getFileEntries(); _downloadContext->getFileEntries();
bool allSelected = true; bool allSelected = true;
for(std::vector<SharedHandle<FileEntry> >::const_iterator i = for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
fileEntries.begin(), eoi = fileEntries.end(); fileEntries.begin(), eoi = fileEntries.end();
@ -443,68 +447,71 @@ void DefaultPieceStorage::setupFileFilter()
for(std::vector<SharedHandle<FileEntry> >::const_iterator i = for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
fileEntries.begin(), eoi = fileEntries.end(); i != eoi; ++i) { fileEntries.begin(), eoi = fileEntries.end(); i != eoi; ++i) {
if((*i)->isRequested()) { if((*i)->isRequested()) {
bitfieldMan->addFilter((*i)->getOffset(), (*i)->getLength()); _bitfieldMan->addFilter((*i)->getOffset(), (*i)->getLength());
} }
} }
bitfieldMan->enableFilter(); _bitfieldMan->enableFilter();
} }
// not unittested // not unittested
void DefaultPieceStorage::clearFileFilter() void DefaultPieceStorage::clearFileFilter()
{ {
bitfieldMan->clearFilter(); _bitfieldMan->clearFilter();
} }
// not unittested // not unittested
bool DefaultPieceStorage::downloadFinished() bool DefaultPieceStorage::downloadFinished()
{ {
// TODO iterate all requested FileEntry and Call bitfieldMan->isBitSetOffsetRange() // TODO iterate all requested FileEntry and Call
return bitfieldMan->isFilteredAllBitSet(); // bitfieldMan->isBitSetOffsetRange()
return _bitfieldMan->isFilteredAllBitSet();
} }
// not unittested // not unittested
bool DefaultPieceStorage::allDownloadFinished() bool DefaultPieceStorage::allDownloadFinished()
{ {
return bitfieldMan->isAllBitSet(); return _bitfieldMan->isAllBitSet();
} }
// not unittested // not unittested
void DefaultPieceStorage::initStorage() void DefaultPieceStorage::initStorage()
{ {
if(downloadContext->getFileEntries().size() == 1) { if(_downloadContext->getFileEntries().size() == 1) {
if(logger->debug()) { if(_logger->debug()) {
logger->debug("Instantiating DirectDiskAdaptor"); _logger->debug("Instantiating DirectDiskAdaptor");
} }
DirectDiskAdaptorHandle directDiskAdaptor(new DirectDiskAdaptor()); DirectDiskAdaptorHandle directDiskAdaptor(new DirectDiskAdaptor());
directDiskAdaptor->setTotalLength(downloadContext->getTotalLength()); directDiskAdaptor->setTotalLength(_downloadContext->getTotalLength());
directDiskAdaptor->setFileEntries(downloadContext->getFileEntries().begin(), directDiskAdaptor->setFileEntries
downloadContext->getFileEntries().end()); (_downloadContext->getFileEntries().begin(),
_downloadContext->getFileEntries().end());
DiskWriterHandle writer = DiskWriterHandle writer =
_diskWriterFactory->newDiskWriter(directDiskAdaptor->getFilePath()); _diskWriterFactory->newDiskWriter(directDiskAdaptor->getFilePath());
if(option->getAsBool(PREF_ENABLE_DIRECT_IO)) { if(_option->getAsBool(PREF_ENABLE_DIRECT_IO)) {
writer->allowDirectIO(); writer->allowDirectIO();
} }
directDiskAdaptor->setDiskWriter(writer); directDiskAdaptor->setDiskWriter(writer);
this->diskAdaptor = directDiskAdaptor; _diskAdaptor = directDiskAdaptor;
} else { } else {
if(logger->debug()) { if(_logger->debug()) {
logger->debug("Instantiating MultiDiskAdaptor"); _logger->debug("Instantiating MultiDiskAdaptor");
} }
MultiDiskAdaptorHandle multiDiskAdaptor(new MultiDiskAdaptor()); MultiDiskAdaptorHandle multiDiskAdaptor(new MultiDiskAdaptor());
multiDiskAdaptor->setFileEntries(downloadContext->getFileEntries().begin(), multiDiskAdaptor->setFileEntries(_downloadContext->getFileEntries().begin(),
downloadContext->getFileEntries().end()); _downloadContext->getFileEntries().end());
if(option->getAsBool(PREF_ENABLE_DIRECT_IO)) { if(_option->getAsBool(PREF_ENABLE_DIRECT_IO)) {
multiDiskAdaptor->allowDirectIO(); multiDiskAdaptor->allowDirectIO();
} }
multiDiskAdaptor->setPieceLength(downloadContext->getPieceLength()); multiDiskAdaptor->setPieceLength(_downloadContext->getPieceLength());
multiDiskAdaptor->setMaxOpenFiles(option->getAsInt(PREF_BT_MAX_OPEN_FILES)); multiDiskAdaptor->setMaxOpenFiles
this->diskAdaptor = multiDiskAdaptor; (_option->getAsInt(PREF_BT_MAX_OPEN_FILES));
_diskAdaptor = multiDiskAdaptor;
} }
#ifdef HAVE_POSIX_FALLOCATE #ifdef HAVE_POSIX_FALLOCATE
if(option->get(PREF_FILE_ALLOCATION) == V_FALLOC) { if(_option->get(PREF_FILE_ALLOCATION) == V_FALLOC) {
diskAdaptor->enableFallocate(); _diskAdaptor->enableFallocate();
} }
#endif // HAVE_POSIX_FALLOCATE #endif // HAVE_POSIX_FALLOCATE
} }
@ -512,33 +519,33 @@ void DefaultPieceStorage::initStorage()
void DefaultPieceStorage::setBitfield(const unsigned char* bitfield, void DefaultPieceStorage::setBitfield(const unsigned char* bitfield,
size_t bitfieldLength) size_t bitfieldLength)
{ {
bitfieldMan->setBitfield(bitfield, bitfieldLength); _bitfieldMan->setBitfield(bitfield, bitfieldLength);
addPieceStats(bitfield, bitfieldLength); addPieceStats(bitfield, bitfieldLength);
} }
size_t DefaultPieceStorage::getBitfieldLength() size_t DefaultPieceStorage::getBitfieldLength()
{ {
return bitfieldMan->getBitfieldLength(); return _bitfieldMan->getBitfieldLength();
} }
const unsigned char* DefaultPieceStorage::getBitfield() const unsigned char* DefaultPieceStorage::getBitfield()
{ {
return bitfieldMan->getBitfield(); return _bitfieldMan->getBitfield();
} }
DiskAdaptorHandle DefaultPieceStorage::getDiskAdaptor() { DiskAdaptorHandle DefaultPieceStorage::getDiskAdaptor() {
return diskAdaptor; return _diskAdaptor;
} }
size_t DefaultPieceStorage::getPieceLength(size_t index) size_t DefaultPieceStorage::getPieceLength(size_t index)
{ {
return bitfieldMan->getBlockLength(index); return _bitfieldMan->getBlockLength(index);
} }
void DefaultPieceStorage::advertisePiece(cuid_t cuid, size_t index) void DefaultPieceStorage::advertisePiece(cuid_t cuid, size_t index)
{ {
HaveEntry entry(cuid, index, global::wallclock); HaveEntry entry(cuid, index, global::wallclock);
haves.push_front(entry); _haves.push_front(entry);
} }
void void
@ -546,8 +553,8 @@ DefaultPieceStorage::getAdvertisedPieceIndexes(std::vector<size_t>& indexes,
cuid_t myCuid, cuid_t myCuid,
const Timer& lastCheckTime) const Timer& lastCheckTime)
{ {
for(std::deque<HaveEntry>::const_iterator itr = haves.begin(), for(std::deque<HaveEntry>::const_iterator itr = _haves.begin(),
eoi = haves.end(); itr != eoi; ++itr) { eoi = _haves.end(); itr != eoi; ++itr) {
const HaveEntry& have = *itr; const HaveEntry& have = *itr;
if(have.getCuid() == myCuid) { if(have.getCuid() == myCuid) {
continue; continue;
@ -578,37 +585,37 @@ public:
void DefaultPieceStorage::removeAdvertisedPiece(time_t elapsed) void DefaultPieceStorage::removeAdvertisedPiece(time_t elapsed)
{ {
std::deque<HaveEntry>::iterator itr = std::deque<HaveEntry>::iterator itr =
std::find_if(haves.begin(), haves.end(), FindElapsedHave(elapsed)); std::find_if(_haves.begin(), _haves.end(), FindElapsedHave(elapsed));
if(itr != haves.end()) { if(itr != _haves.end()) {
if(logger->debug()) { if(_logger->debug()) {
logger->debug(MSG_REMOVED_HAVE_ENTRY, haves.end()-itr); _logger->debug(MSG_REMOVED_HAVE_ENTRY, _haves.end()-itr);
} }
haves.erase(itr, haves.end()); _haves.erase(itr, _haves.end());
} }
} }
void DefaultPieceStorage::markAllPiecesDone() void DefaultPieceStorage::markAllPiecesDone()
{ {
bitfieldMan->setAllBit(); _bitfieldMan->setAllBit();
} }
void DefaultPieceStorage::markPiecesDone(uint64_t length) void DefaultPieceStorage::markPiecesDone(uint64_t length)
{ {
if(length == bitfieldMan->getTotalLength()) { if(length == _bitfieldMan->getTotalLength()) {
bitfieldMan->setAllBit(); _bitfieldMan->setAllBit();
} else if(length == 0) { } else if(length == 0) {
// TODO this would go to markAllPiecesUndone() // TODO this would go to markAllPiecesUndone()
bitfieldMan->clearAllBit(); _bitfieldMan->clearAllBit();
usedPieces.clear(); _usedPieces.clear();
} else { } else {
size_t numPiece = length/bitfieldMan->getBlockLength(); size_t numPiece = length/_bitfieldMan->getBlockLength();
if(numPiece > 0) { if(numPiece > 0) {
bitfieldMan->setBitRange(0, numPiece-1); _bitfieldMan->setBitRange(0, numPiece-1);
} }
size_t r = (length%bitfieldMan->getBlockLength())/Piece::BLOCK_LENGTH; size_t r = (length%_bitfieldMan->getBlockLength())/Piece::BLOCK_LENGTH;
if(r > 0) { if(r > 0) {
SharedHandle<Piece> p SharedHandle<Piece> p
(new Piece(numPiece, bitfieldMan->getBlockLength(numPiece))); (new Piece(numPiece, _bitfieldMan->getBlockLength(numPiece)));
for(size_t i = 0; i < r; ++i) { for(size_t i = 0; i < r; ++i) {
p->completeBlock(i); p->completeBlock(i);
@ -616,7 +623,7 @@ void DefaultPieceStorage::markPiecesDone(uint64_t length)
#ifdef ENABLE_MESSAGE_DIGEST #ifdef ENABLE_MESSAGE_DIGEST
p->setHashAlgo(downloadContext->getPieceHashAlgo()); p->setHashAlgo(_downloadContext->getPieceHashAlgo());
#endif // ENABLE_MESSAGE_DIGEST #endif // ENABLE_MESSAGE_DIGEST
@ -627,28 +634,29 @@ void DefaultPieceStorage::markPiecesDone(uint64_t length)
void DefaultPieceStorage::markPieceMissing(size_t index) void DefaultPieceStorage::markPieceMissing(size_t index)
{ {
bitfieldMan->unsetBit(index); _bitfieldMan->unsetBit(index);
} }
void DefaultPieceStorage::addInFlightPiece void DefaultPieceStorage::addInFlightPiece
(const std::vector<SharedHandle<Piece> >& pieces) (const std::vector<SharedHandle<Piece> >& pieces)
{ {
usedPieces.insert(usedPieces.end(), pieces.begin(), pieces.end()); _usedPieces.insert(_usedPieces.end(), pieces.begin(), pieces.end());
std::sort(usedPieces.begin(), usedPieces.end()); std::sort(_usedPieces.begin(), _usedPieces.end());
} }
size_t DefaultPieceStorage::countInFlightPiece() size_t DefaultPieceStorage::countInFlightPiece()
{ {
return usedPieces.size(); return _usedPieces.size();
} }
void DefaultPieceStorage::getInFlightPieces void DefaultPieceStorage::getInFlightPieces
(std::vector<SharedHandle<Piece> >& pieces) (std::vector<SharedHandle<Piece> >& pieces)
{ {
pieces.insert(pieces.end(), usedPieces.begin(), usedPieces.end()); pieces.insert(pieces.end(), _usedPieces.begin(), _usedPieces.end());
} }
void DefaultPieceStorage::setDiskWriterFactory(const DiskWriterFactoryHandle& diskWriterFactory) void DefaultPieceStorage::setDiskWriterFactory
(const DiskWriterFactoryHandle& diskWriterFactory)
{ {
_diskWriterFactory = diskWriterFactory; _diskWriterFactory = diskWriterFactory;
} }

44
src/DefaultPieceStorage.h
View File

@ -54,34 +54,34 @@ class PieceSelector;
class HaveEntry { class HaveEntry {
private: private:
cuid_t cuid; cuid_t _cuid;
size_t index; size_t _index;
Timer registeredTime; Timer _registeredTime;
public: public:
HaveEntry(cuid_t cuid, size_t index, const Timer& registeredTime): HaveEntry(cuid_t cuid, size_t index, const Timer& registeredTime):
cuid(cuid), _cuid(cuid),
index(index), _index(index),
registeredTime(registeredTime) {} _registeredTime(registeredTime) {}
cuid_t getCuid() const { return cuid; } cuid_t getCuid() const { return _cuid; }
size_t getIndex() const { return index; } size_t getIndex() const { return _index; }
const Timer& getRegisteredTime() const { return registeredTime; } const Timer& getRegisteredTime() const { return _registeredTime; }
}; };
class DefaultPieceStorage : public PieceStorage { class DefaultPieceStorage : public PieceStorage {
private: private:
SharedHandle<DownloadContext> downloadContext; SharedHandle<DownloadContext> _downloadContext;
BitfieldMan* bitfieldMan; BitfieldMan* _bitfieldMan;
SharedHandle<DiskAdaptor> diskAdaptor; SharedHandle<DiskAdaptor> _diskAdaptor;
SharedHandle<DiskWriterFactory> _diskWriterFactory; SharedHandle<DiskWriterFactory> _diskWriterFactory;
std::deque<SharedHandle<Piece> > usedPieces; std::deque<SharedHandle<Piece> > _usedPieces;
size_t endGamePieceNum; size_t _endGamePieceNum;
Logger* logger; Logger* _logger;
const Option* option; const Option* _option;
std::deque<HaveEntry> haves; std::deque<HaveEntry> _haves;
SharedHandle<PieceStatMan> _pieceStatMan; SharedHandle<PieceStatMan> _pieceStatMan;
@ -124,7 +124,8 @@ public:
virtual SharedHandle<Piece> getMissingPiece(const SharedHandle<Peer>& peer); virtual SharedHandle<Piece> getMissingPiece(const SharedHandle<Peer>& peer);
virtual SharedHandle<Piece> getMissingFastPiece(const SharedHandle<Peer>& peer); virtual SharedHandle<Piece> getMissingFastPiece
(const SharedHandle<Peer>& peer);
virtual SharedHandle<Piece> getMissingPiece virtual SharedHandle<Piece> getMissingPiece
(const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes); (const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes);
@ -177,11 +178,11 @@ public:
virtual const unsigned char* getBitfield(); virtual const unsigned char* getBitfield();
virtual void setEndGamePieceNum(size_t num) { virtual void setEndGamePieceNum(size_t num) {
endGamePieceNum = num; _endGamePieceNum = num;
} }
size_t getEndGamePieceNum() const { size_t getEndGamePieceNum() const {
return endGamePieceNum; return _endGamePieceNum;
} }
virtual bool isSelectiveDownloadingMode(); virtual bool isSelectiveDownloadingMode();
@ -231,7 +232,8 @@ public:
*/ */
void addUsedPiece(const SharedHandle<Piece>& piece); void addUsedPiece(const SharedHandle<Piece>& piece);
void setDiskWriterFactory(const SharedHandle<DiskWriterFactory>& diskWriterFactory); void setDiskWriterFactory
(const SharedHandle<DiskWriterFactory>& diskWriterFactory);
const SharedHandle<PieceStatMan>& getPieceStatMan() const const SharedHandle<PieceStatMan>& getPieceStatMan() const
{ {