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

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

Made protected member variable private. Added accessor funcs.
	* src/AbstractSingleDiskAdaptor.cc
	* src/AbstractSingleDiskAdaptor.h
	* src/DirectDiskAdaptor.cc
	* src/DirectDiskAdaptor.h
	* src/DiskAdaptor.cc
	* src/DiskAdaptor.h
	* src/MultiDiskAdaptor.cc
	* src/MultiDiskAdaptor.h
	* src/MultiFileAllocationIterator.cc
	* src/MultiFileAllocationIterator.h
	* test/BtBitfieldMessageTest.cc
	* test/BtHaveAllMessageTest.cc
	* test/BtHaveMessageTest.cc
pull/1/head
Tatsuhiro Tsujikawa 2010-06-11 12:49:14 +00:00
parent 56ea539975
commit b914f6d810
14 changed files with 165 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
ChangeLog
View File

@ -1,3 +1,20 @@
2010-06-11 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Made protected member variable private. Added accessor funcs.
* src/AbstractSingleDiskAdaptor.cc
* src/AbstractSingleDiskAdaptor.h
* src/DirectDiskAdaptor.cc
* src/DirectDiskAdaptor.h
* src/DiskAdaptor.cc
* src/DiskAdaptor.h
* src/MultiDiskAdaptor.cc
* src/MultiDiskAdaptor.h
* src/MultiFileAllocationIterator.cc
* src/MultiFileAllocationIterator.h
* test/BtBitfieldMessageTest.cc
* test/BtHaveAllMessageTest.cc
* test/BtHaveMessageTest.cc
2010-06-11 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Made protected member variable private. Added accessor funcs.

53
src/AbstractSingleDiskAdaptor.cc
View File

@ -39,42 +39,45 @@
# include "FallocFileAllocationIterator.h"
#endif // HAVE_POSIX_FALLOCATE
#include "DiskWriter.h"
#include "FileEntry.h"
namespace aria2 {
AbstractSingleDiskAdaptor::AbstractSingleDiskAdaptor():
totalLength(0), _readOnly(false) {}
_totalLength(0), _readOnly(false) {}
AbstractSingleDiskAdaptor::~AbstractSingleDiskAdaptor() {}
void AbstractSingleDiskAdaptor::initAndOpenFile()
{
diskWriter->initAndOpenFile(totalLength);
_diskWriter->initAndOpenFile(_totalLength);
}
void AbstractSingleDiskAdaptor::openFile()
{
diskWriter->openFile(totalLength);
_diskWriter->openFile(_totalLength);
}
void AbstractSingleDiskAdaptor::closeFile()
{
diskWriter->closeFile();
_diskWriter->closeFile();
}
void AbstractSingleDiskAdaptor::openExistingFile()
{
diskWriter->openExistingFile(totalLength);
_diskWriter->openExistingFile(_totalLength);
}
void AbstractSingleDiskAdaptor::writeData(const unsigned char* data, size_t len, off_t offset)
void AbstractSingleDiskAdaptor::writeData
(const unsigned char* data, size_t len, off_t offset)
{
diskWriter->writeData(data, len, offset);
_diskWriter->writeData(data, len, offset);
}
ssize_t AbstractSingleDiskAdaptor::readData(unsigned char* data, size_t len, off_t offset)
ssize_t AbstractSingleDiskAdaptor::readData
(unsigned char* data, size_t len, off_t offset)
{
return diskWriter->readData(data, len, offset);
return _diskWriter->readData(data, len, offset);
}
bool AbstractSingleDiskAdaptor::fileExists()
@ -89,21 +92,24 @@ uint64_t AbstractSingleDiskAdaptor::size()
void AbstractSingleDiskAdaptor::truncate(uint64_t length)
{
diskWriter->truncate(length);
_diskWriter->truncate(length);
}
FileAllocationIteratorHandle AbstractSingleDiskAdaptor::fileAllocationIterator()
FileAllocationIteratorHandle
AbstractSingleDiskAdaptor::fileAllocationIterator()
{
#ifdef HAVE_POSIX_FALLOCATE
if(_fallocate) {
if(doesFallocate()) {
SharedHandle<FallocFileAllocationIterator> h
(new FallocFileAllocationIterator(diskWriter.get(), size(), totalLength));
(new FallocFileAllocationIterator
(_diskWriter.get(), size() ,_totalLength));
return h;
} else
#endif // HAVE_POSIX_FALLOCATE
{
SingleFileAllocationIteratorHandle h
(new SingleFileAllocationIterator(diskWriter.get(),size(),totalLength));
(new SingleFileAllocationIterator
(_diskWriter.get(), size(), _totalLength));
h->init();
return h;
}
@ -111,41 +117,42 @@ FileAllocationIteratorHandle AbstractSingleDiskAdaptor::fileAllocationIterator()
void AbstractSingleDiskAdaptor::enableDirectIO()
{
diskWriter->enableDirectIO();
_diskWriter->enableDirectIO();
}
void AbstractSingleDiskAdaptor::disableDirectIO()
{
diskWriter->disableDirectIO();
_diskWriter->disableDirectIO();
}
void AbstractSingleDiskAdaptor::enableReadOnly()
{
diskWriter->enableReadOnly();
_diskWriter->enableReadOnly();
_readOnly = true;
}
void AbstractSingleDiskAdaptor::disableReadOnly()
{
diskWriter->disableReadOnly();
_diskWriter->disableReadOnly();
_readOnly = false;
}
void AbstractSingleDiskAdaptor::cutTrailingGarbage()
{
if(File(getFilePath()).size() > totalLength) {
diskWriter->truncate(totalLength);
if(File(getFilePath()).size() > _totalLength) {
_diskWriter->truncate(_totalLength);
}
}
void AbstractSingleDiskAdaptor::setDiskWriter(const DiskWriterHandle& diskWriter)
void AbstractSingleDiskAdaptor::setDiskWriter
(const DiskWriterHandle& diskWriter)
{
this->diskWriter = diskWriter;
_diskWriter = diskWriter;
}
void AbstractSingleDiskAdaptor::setTotalLength(const uint64_t& totalLength)
{
this->totalLength = totalLength;
_totalLength = totalLength;
}
} // namespace aria2

10
src/AbstractSingleDiskAdaptor.h
View File

@ -43,9 +43,9 @@ class DiskWriter;
class FileAllocationIterator;
class AbstractSingleDiskAdaptor : public DiskAdaptor {
protected:
SharedHandle<DiskWriter> diskWriter;
uint64_t totalLength;
private:
SharedHandle<DiskWriter> _diskWriter;
uint64_t _totalLength;
bool _readOnly;
public:
AbstractSingleDiskAdaptor();
@ -93,14 +93,14 @@ public:
const SharedHandle<DiskWriter>& getDiskWriter() const
{
return diskWriter;
return _diskWriter;
}
void setTotalLength(const uint64_t& totalLength);
uint64_t getTotalLength() const
{
return totalLength;
return _totalLength;
}
};

2
src/DirectDiskAdaptor.cc
View File

@ -40,7 +40,7 @@ namespace aria2 {
const std::string& DirectDiskAdaptor::getFilePath()
{
return fileEntries.front()->getPath();
return getFileEntries().front()->getPath();
}
size_t DirectDiskAdaptor::utime(const Time& actime, const Time& modtime)

3
src/DirectDiskAdaptor.h
View File

@ -41,9 +41,6 @@ namespace aria2 {
class DirectDiskAdaptor : public AbstractSingleDiskAdaptor {
public:
DirectDiskAdaptor() {};
virtual ~DirectDiskAdaptor() {};
virtual const std::string& getFilePath();
virtual size_t utime(const Time& actime, const Time& modtime);

4
src/DiskAdaptor.cc
View File

@ -43,8 +43,6 @@ DiskAdaptor::DiskAdaptor():
#ifdef HAVE_POSIX_FALLOCATE
_fallocate(false),
#endif // HAVE_POSIX_FALLOCATE
logger(LogFactory::getInstance()) {}
DiskAdaptor::~DiskAdaptor() {}
_logger(LogFactory::getInstance()) {}
} // namespace aria2

17
src/DiskAdaptor.h
View File

@ -49,15 +49,20 @@ class Logger;
class FileAllocationIterator;
class DiskAdaptor:public BinaryStream {
protected:
std::vector<SharedHandle<FileEntry> > fileEntries;
private:
std::vector<SharedHandle<FileEntry> > _fileEntries;
#ifdef HAVE_POSIX_FALLOCATE
bool _fallocate;
#endif // HAVE_POSIX_FALLOCATE
Logger* logger;
Logger* _logger;
protected:
Logger* getLogger() const
{
return _logger;
}
public:
DiskAdaptor();
virtual ~DiskAdaptor();
virtual ~DiskAdaptor() {}
virtual void openFile() = 0;
@ -74,12 +79,12 @@ public:
template<typename InputIterator>
void setFileEntries(InputIterator first, InputIterator last)
{
fileEntries.assign(first, last);
_fileEntries.assign(first, last);
}
const std::vector<SharedHandle<FileEntry> >& getFileEntries() const
{
return fileEntries;
return _fileEntries;
}
virtual SharedHandle<FileAllocationIterator> fileAllocationIterator() = 0;

174
src/MultiDiskAdaptor.cc
View File

@ -53,22 +53,20 @@
namespace aria2 {
DiskWriterEntry::DiskWriterEntry(const SharedHandle<FileEntry>& fileEntry):
fileEntry(fileEntry), _open(false), _directIO(false),
_fileEntry(fileEntry), _open(false), _directIO(false),
_needsFileAllocation(false) {}
DiskWriterEntry::~DiskWriterEntry() {}
const std::string& DiskWriterEntry::getFilePath() const
{
return fileEntry->getPath();
return _fileEntry->getPath();
}
void DiskWriterEntry::initAndOpenFile()
{
if(!diskWriter.isNull()) {
diskWriter->initAndOpenFile(fileEntry->getLength());
if(!_diskWriter.isNull()) {
_diskWriter->initAndOpenFile(_fileEntry->getLength());
if(_directIO) {
diskWriter->enableDirectIO();
_diskWriter->enableDirectIO();
}
_open = true;
}
@ -76,10 +74,10 @@ void DiskWriterEntry::initAndOpenFile()
void DiskWriterEntry::openFile()
{
if(!diskWriter.isNull()) {
diskWriter->openFile(fileEntry->getLength());
if(!_diskWriter.isNull()) {
_diskWriter->openFile(_fileEntry->getLength());
if(_directIO) {
diskWriter->enableDirectIO();
_diskWriter->enableDirectIO();
}
_open = true;
}
@ -87,10 +85,10 @@ void DiskWriterEntry::openFile()
void DiskWriterEntry::openExistingFile()
{
if(!diskWriter.isNull()) {
diskWriter->openExistingFile(fileEntry->getLength());
if(!_diskWriter.isNull()) {
_diskWriter->openExistingFile(_fileEntry->getLength());
if(_directIO) {
diskWriter->enableDirectIO();
_diskWriter->enableDirectIO();
}
_open = true;
}
@ -99,14 +97,14 @@ void DiskWriterEntry::openExistingFile()
void DiskWriterEntry::closeFile()
{
if(_open) {
diskWriter->closeFile();
_diskWriter->closeFile();
_open = false;
}
}
bool DiskWriterEntry::fileExists()
{
return fileEntry->exists();
return _fileEntry->exists();
}
uint64_t DiskWriterEntry::size() const
@ -116,18 +114,18 @@ uint64_t DiskWriterEntry::size() const
void DiskWriterEntry::setDiskWriter(const SharedHandle<DiskWriter>& diskWriter)
{
this->diskWriter = diskWriter;
_diskWriter = diskWriter;
}
bool DiskWriterEntry::operator<(const DiskWriterEntry& entry) const
{
return fileEntry < entry.fileEntry;
return _fileEntry < entry._fileEntry;
}
void DiskWriterEntry::enableDirectIO()
{
if(_open) {
diskWriter->enableDirectIO();
_diskWriter->enableDirectIO();
}
_directIO = true;
}
@ -135,19 +133,17 @@ void DiskWriterEntry::enableDirectIO()
void DiskWriterEntry::disableDirectIO()
{
if(_open) {
diskWriter->disableDirectIO();
_diskWriter->disableDirectIO();
}
_directIO = false;
}
MultiDiskAdaptor::MultiDiskAdaptor():
pieceLength(0),
_pieceLength(0),
_maxOpenFiles(DEFAULT_MAX_OPEN_FILES),
_directIOAllowed(false),
_readOnly(false) {}
MultiDiskAdaptor::~MultiDiskAdaptor() {}
static SharedHandle<DiskWriterEntry> createDiskWriterEntry
(const SharedHandle<FileEntry>& fileEntry,
bool needsFileAllocation)
@ -155,31 +151,28 @@ static SharedHandle<DiskWriterEntry> createDiskWriterEntry
SharedHandle<DiskWriterEntry> entry(new DiskWriterEntry(fileEntry));
entry->needsFileAllocation(needsFileAllocation);
return entry;
}
}
void MultiDiskAdaptor::resetDiskWriterEntries()
{
diskWriterEntries.clear();
_diskWriterEntries.clear();
if(fileEntries.empty()) {
if(getFileEntries().empty()) {
return;
}
for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
fileEntries.begin(), eoi = fileEntries.end(); i != eoi; ++i) {
diskWriterEntries.push_back
getFileEntries().begin(), eoi = getFileEntries().end(); i != eoi; ++i) {
_diskWriterEntries.push_back
(createDiskWriterEntry(*i, (*i)->isRequested()));
}
std::map<std::string, bool> dwreq;
// TODO Currently, pieceLength == 0 is used for unit testing only.
if(pieceLength > 0) {
// TODO Currently, _pieceLength == 0 is used for unit testing only.
if(_pieceLength > 0) {
std::vector<SharedHandle<DiskWriterEntry> >::const_iterator done =
diskWriterEntries.begin();
_diskWriterEntries.begin();
for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator itr =
diskWriterEntries.begin(), eoi = diskWriterEntries.end();
_diskWriterEntries.begin(), eoi = _diskWriterEntries.end();
itr != eoi;) {
const SharedHandle<FileEntry>& fileEntry = (*itr)->getFileEntry();
@ -188,8 +181,8 @@ void MultiDiskAdaptor::resetDiskWriterEntries()
continue;
}
off_t pieceStartOffset =
(fileEntry->getOffset()/pieceLength)*pieceLength;
if(itr != diskWriterEntries.begin()) {
(fileEntry->getOffset()/_pieceLength)*_pieceLength;
if(itr != _diskWriterEntries.begin()) {
for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator i =
itr-1; true; --i) {
const SharedHandle<FileEntry>& fileEntry = (*i)->getFileEntry();
@ -208,12 +201,13 @@ void MultiDiskAdaptor::resetDiskWriterEntries()
if(fileEntry->getLength() > 0) {
off_t lastPieceStartOffset =
(fileEntry->getOffset()+fileEntry->getLength()-1)/pieceLength*pieceLength;
if(logger->debug()) {
logger->debug("Checking adjacent backward file to %s"
" whose lastPieceStartOffset+pieceLength=%lld",
fileEntry->getPath().c_str(),
lastPieceStartOffset+pieceLength);
(fileEntry->getOffset()+fileEntry->getLength()-1)/
_pieceLength*_pieceLength;
if(getLogger()->debug()) {
getLogger()->debug("Checking adjacent backward file to %s"
" whose lastPieceStartOffset+_pieceLength=%lld",
fileEntry->getPath().c_str(),
lastPieceStartOffset+_pieceLength);
}
++itr;
// adjacent backward files are not needed to be allocated. They
@ -221,16 +215,16 @@ void MultiDiskAdaptor::resetDiskWriterEntries()
for(; itr != eoi &&
(!(*itr)->getFileEntry()->isRequested() ||
(*itr)->getFileEntry()->getLength() == 0); ++itr) {
if(logger->debug()) {
logger->debug("file=%s, offset=%lld",
(*itr)->getFileEntry()->getPath().c_str(),
(*itr)->getFileEntry()->getOffset());
if(getLogger()->debug()) {
getLogger()->debug("file=%s, offset=%lld",
(*itr)->getFileEntry()->getPath().c_str(),
(*itr)->getFileEntry()->getOffset());
}
if((*itr)->getFileEntry()->getOffset() <
static_cast<off_t>(lastPieceStartOffset+pieceLength)) {
if(logger->debug()) {
logger->debug("%s needs diskwriter",
(*itr)->getFileEntry()->getPath().c_str());
static_cast<off_t>(lastPieceStartOffset+_pieceLength)) {
if(getLogger()->debug()) {
getLogger()->debug("%s needs diskwriter",
(*itr)->getFileEntry()->getPath().c_str());
}
dwreq[(*itr)->getFileEntry()->getPath()] = true;
} else {
@ -246,14 +240,14 @@ void MultiDiskAdaptor::resetDiskWriterEntries()
}
DefaultDiskWriterFactory dwFactory;
for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator i =
diskWriterEntries.begin(), eoi = diskWriterEntries.end();
_diskWriterEntries.begin(), eoi = _diskWriterEntries.end();
i != eoi; ++i) {
if((*i)->needsFileAllocation() ||
dwreq.find((*i)->getFileEntry()->getPath()) != dwreq.end() ||
(*i)->fileExists()) {
if(logger->debug()) {
logger->debug("Creating DiskWriter for filename=%s",
(*i)->getFilePath().c_str());
if(getLogger()->debug()) {
getLogger()->debug("Creating DiskWriter for filename=%s",
(*i)->getFilePath().c_str());
}
(*i)->setDiskWriter(dwFactory.newDiskWriter((*i)->getFilePath()));
if(_directIOAllowed) {
@ -269,7 +263,7 @@ void MultiDiskAdaptor::resetDiskWriterEntries()
void MultiDiskAdaptor::mkdir() const
{
for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator i =
diskWriterEntries.begin(), eoi = diskWriterEntries.end();
_diskWriterEntries.begin(), eoi = _diskWriterEntries.end();
i != eoi; ++i) {
(*i)->getFileEntry()->setupDir();
}
@ -279,7 +273,7 @@ void MultiDiskAdaptor::openIfNot
(const SharedHandle<DiskWriterEntry>& entry, void (DiskWriterEntry::*open)())
{
if(!entry->isOpen()) {
// logger->debug("DiskWriterEntry: Cache MISS. offset=%s",
// getLogger()->debug("DiskWriterEntry: Cache MISS. offset=%s",
// util::itos(entry->getFileEntry()->getOffset()).c_str());
size_t numOpened = _openedDiskWriterEntries.size();
@ -287,7 +281,8 @@ void MultiDiskAdaptor::openIfNot
if(numOpened >= _maxOpenFiles) {
// Cache is full.
// Choose one DiskWriterEntry randomly and close it.
size_t index = SimpleRandomizer::getInstance()->getRandomNumber(numOpened);
size_t index =
SimpleRandomizer::getInstance()->getRandomNumber(numOpened);
std::vector<SharedHandle<DiskWriterEntry> >::iterator i =
_openedDiskWriterEntries.begin();
std::advance(i, index);
@ -297,7 +292,7 @@ void MultiDiskAdaptor::openIfNot
_openedDiskWriterEntries.push_back(entry);
}
} else {
// logger->debug("DiskWriterEntry: Cache HIT. offset=%s",
// getLogger()->debug("DiskWriterEntry: Cache HIT. offset=%s",
// util::itos(entry->getFileEntry()->getOffset()).c_str());
}
}
@ -308,8 +303,8 @@ void MultiDiskAdaptor::openFile()
mkdir();
// Call DiskWriterEntry::openFile to make sure that zero-length files are
// created.
for(DiskWriterEntries::const_iterator itr = diskWriterEntries.begin(),
eoi = diskWriterEntries.end(); itr != eoi; ++itr) {
for(DiskWriterEntries::const_iterator itr = _diskWriterEntries.begin(),
eoi = _diskWriterEntries.end(); itr != eoi; ++itr) {
openIfNot(*itr, &DiskWriterEntry::openFile);
}
}
@ -319,8 +314,8 @@ void MultiDiskAdaptor::initAndOpenFile()
resetDiskWriterEntries();
mkdir();
// Call DiskWriterEntry::initAndOpenFile to make files truncated.
for(DiskWriterEntries::const_iterator itr = diskWriterEntries.begin(),
eoi = diskWriterEntries.end(); itr != eoi; ++itr) {
for(DiskWriterEntries::const_iterator itr = _diskWriterEntries.begin(),
eoi = _diskWriterEntries.end(); itr != eoi; ++itr) {
openIfNot(*itr, &DiskWriterEntry::initAndOpenFile);
}
}
@ -333,16 +328,15 @@ void MultiDiskAdaptor::openExistingFile()
void MultiDiskAdaptor::closeFile()
{
for(DiskWriterEntries::const_iterator itr = diskWriterEntries.begin(),
eoi = diskWriterEntries.end(); itr != eoi; ++itr) {
(*itr)->closeFile();
}
std::for_each(_diskWriterEntries.begin(), _diskWriterEntries.end(),
mem_fun_sh(&DiskWriterEntry::closeFile));
}
static bool isInRange(const DiskWriterEntryHandle entry, off_t offset)
{
return entry->getFileEntry()->getOffset() <= offset &&
(uint64_t)offset < entry->getFileEntry()->getOffset()+entry->getFileEntry()->getLength();
(uint64_t)offset <
entry->getFileEntry()->getOffset()+entry->getFileEntry()->getLength();
}
static size_t calculateLength(const DiskWriterEntryHandle entry,
@ -366,7 +360,8 @@ public:
};
static DiskWriterEntries::const_iterator
findFirstDiskWriterEntry(const DiskWriterEntries& diskWriterEntries, off_t offset)
findFirstDiskWriterEntry
(const DiskWriterEntries& diskWriterEntries, off_t offset)
{
DiskWriterEntries::const_iterator first =
std::upper_bound(diskWriterEntries.begin(), diskWriterEntries.end(),
@ -395,12 +390,13 @@ static void throwOnDiskWriterNotOpened(const SharedHandle<DiskWriterEntry>& e,
void MultiDiskAdaptor::writeData(const unsigned char* data, size_t len,
off_t offset)
{
DiskWriterEntries::const_iterator first = findFirstDiskWriterEntry(diskWriterEntries, offset);
DiskWriterEntries::const_iterator first =
findFirstDiskWriterEntry(_diskWriterEntries, offset);
size_t rem = len;
off_t fileOffset = offset-(*first)->getFileEntry()->getOffset();
for(DiskWriterEntries::const_iterator i = first,
eoi = diskWriterEntries.end(); i != eoi; ++i) {
eoi = _diskWriterEntries.end(); i != eoi; ++i) {
size_t writeLength = calculateLength(*i, fileOffset, rem);
openIfNot(*i, &DiskWriterEntry::openFile);
@ -418,16 +414,17 @@ void MultiDiskAdaptor::writeData(const unsigned char* data, size_t len,
}
}
ssize_t MultiDiskAdaptor::readData(unsigned char* data, size_t len, off_t offset)
ssize_t MultiDiskAdaptor::readData
(unsigned char* data, size_t len, off_t offset)
{
DiskWriterEntries::const_iterator first =
findFirstDiskWriterEntry(diskWriterEntries, offset);
findFirstDiskWriterEntry(_diskWriterEntries, offset);
size_t rem = len;
size_t totalReadLength = 0;
off_t fileOffset = offset-(*first)->getFileEntry()->getOffset();
for(DiskWriterEntries::const_iterator i = first,
eoi = diskWriterEntries.end(); i != eoi; ++i) {
eoi = _diskWriterEntries.end(); i != eoi; ++i) {
size_t readLength = calculateLength(*i, fileOffset, rem);
openIfNot(*i, &DiskWriterEntry::openFile);
@ -449,20 +446,16 @@ ssize_t MultiDiskAdaptor::readData(unsigned char* data, size_t len, off_t offset
bool MultiDiskAdaptor::fileExists()
{
for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
fileEntries.begin(), eoi = fileEntries.end(); i != eoi; ++i) {
if((*i)->exists()) {
return true;
}
}
return false;
return std::find_if(getFileEntries().begin(), getFileEntries().end(),
mem_fun_sh(&FileEntry::exists)) !=
getFileEntries().end();
}
uint64_t MultiDiskAdaptor::size()
{
uint64_t size = 0;
for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
fileEntries.begin(), eoi = fileEntries.end(); i != eoi; ++i) {
getFileEntries().begin(), eoi = getFileEntries().end(); i != eoi; ++i) {
size += File((*i)->getPath()).size();
}
return size;
@ -470,23 +463,20 @@ uint64_t MultiDiskAdaptor::size()
FileAllocationIteratorHandle MultiDiskAdaptor::fileAllocationIterator()
{
return SharedHandle<FileAllocationIterator>(new MultiFileAllocationIterator(this));
return SharedHandle<FileAllocationIterator>
(new MultiFileAllocationIterator(this));
}
void MultiDiskAdaptor::enableDirectIO()
{
for(DiskWriterEntries::const_iterator itr = diskWriterEntries.begin(),
eoi = diskWriterEntries.end(); itr != eoi; ++itr) {
(*itr)->enableDirectIO();
}
std::for_each(_diskWriterEntries.begin(), _diskWriterEntries.end(),
mem_fun_sh(&DiskWriterEntry::enableDirectIO));
}
void MultiDiskAdaptor::disableDirectIO()
{
for(DiskWriterEntries::const_iterator itr = diskWriterEntries.begin(),
eoi = diskWriterEntries.end(); itr != eoi; ++itr) {
(*itr)->disableDirectIO();
}
std::for_each(_diskWriterEntries.begin(), _diskWriterEntries.end(),
mem_fun_sh(&DiskWriterEntry::disableDirectIO));
}
void MultiDiskAdaptor::enableReadOnly()
@ -502,7 +492,7 @@ void MultiDiskAdaptor::disableReadOnly()
void MultiDiskAdaptor::cutTrailingGarbage()
{
for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator i =
diskWriterEntries.begin(), eoi = diskWriterEntries.end();
_diskWriterEntries.begin(), eoi = _diskWriterEntries.end();
i != eoi; ++i) {
uint64_t length = (*i)->getFileEntry()->getLength();
if(File((*i)->getFilePath()).size() > length) {
@ -522,7 +512,7 @@ size_t MultiDiskAdaptor::utime(const Time& actime, const Time& modtime)
{
size_t numOK = 0;
for(std::vector<SharedHandle<FileEntry> >::const_iterator i =
fileEntries.begin(), eoi = fileEntries.end(); i != eoi; ++i) {
getFileEntries().begin(), eoi = getFileEntries().end(); i != eoi; ++i) {
if((*i)->isRequested()) {
File f((*i)->getPath());
if(f.isFile() && f.utime(actime, modtime)) {

25
src/MultiDiskAdaptor.h
View File

@ -45,16 +45,14 @@ class DiskWriter;
class DiskWriterEntry {
private:
SharedHandle<FileEntry> fileEntry;
SharedHandle<DiskWriter> diskWriter;
SharedHandle<FileEntry> _fileEntry;
SharedHandle<DiskWriter> _diskWriter;
bool _open;
bool _directIO;
bool _needsFileAllocation;
public:
DiskWriterEntry(const SharedHandle<FileEntry>& fileEntry);
~DiskWriterEntry();
const std::string& getFilePath() const;
void initAndOpenFile();
@ -76,14 +74,14 @@ public:
const SharedHandle<FileEntry>& getFileEntry() const
{
return fileEntry;
return _fileEntry;
}
void setDiskWriter(const SharedHandle<DiskWriter>& diskWriter);
const SharedHandle<DiskWriter>& getDiskWriter() const
{
return diskWriter;
return _diskWriter;
}
bool operator<(const DiskWriterEntry& entry) const;
@ -117,8 +115,8 @@ typedef std::vector<DiskWriterEntryHandle> DiskWriterEntries;
class MultiDiskAdaptor : public DiskAdaptor {
friend class MultiFileAllocationIterator;
private:
size_t pieceLength;
DiskWriterEntries diskWriterEntries;
size_t _pieceLength;
DiskWriterEntries _diskWriterEntries;
std::vector<SharedHandle<DiskWriterEntry> > _openedDiskWriterEntries;
@ -140,8 +138,6 @@ private:
public:
MultiDiskAdaptor();
virtual ~MultiDiskAdaptor();
virtual void initAndOpenFile();
virtual void openFile();
@ -171,12 +167,13 @@ public:
virtual bool isReadOnlyEnabled() const { return _readOnly; }
void setPieceLength(size_t pieceLength) {
this->pieceLength = pieceLength;
void setPieceLength(size_t pieceLength)
{
_pieceLength = pieceLength;
}
size_t getPieceLength() const {
return pieceLength;
return _pieceLength;
}
void allowDirectIO()
@ -193,7 +190,7 @@ public:
const std::vector<SharedHandle<DiskWriterEntry> >&
getDiskWriterEntries() const
{
return diskWriterEntries;
return _diskWriterEntries;
}
};

4
src/MultiFileAllocationIterator.cc
View File

@ -45,8 +45,8 @@ namespace aria2 {
MultiFileAllocationIterator::MultiFileAllocationIterator(MultiDiskAdaptor* diskAdaptor):
_diskAdaptor(diskAdaptor),
_entries(_diskAdaptor->diskWriterEntries.begin(),
_diskAdaptor->diskWriterEntries.end()),
_entries(_diskAdaptor->_diskWriterEntries.begin(),
_diskAdaptor->_diskWriterEntries.end()),
_offset(0)
{}

4
src/MultiFileAllocationIterator.h
View File

@ -50,7 +50,6 @@ private:
std::deque<SharedHandle<DiskWriterEntry> > _entries;
SharedHandle<FileAllocationIterator> _fileAllocationIterator;
off_t _offset;
public:
MultiFileAllocationIterator(MultiDiskAdaptor* diskAdaptor);
@ -64,7 +63,8 @@ public:
virtual uint64_t getTotalLength();
const std::deque<SharedHandle<DiskWriterEntry> >& getDiskWriterEntries() const;
const std::deque<SharedHandle<DiskWriterEntry> >&
getDiskWriterEntries() const;
};
typedef SharedHandle<MultiFileAllocationIterator> MultiFileAllocationIteratorHandle;

1
test/BtBitfieldMessageTest.cc
View File

@ -9,6 +9,7 @@
#include "Peer.h"
#include "MockPieceStorage.h"
#include "DlAbortEx.h"
#include "FileEntry.h"
namespace aria2 {

1
test/BtHaveAllMessageTest.cc
View File

@ -8,6 +8,7 @@
#include "Peer.h"
#include "MockPieceStorage.h"
#include "DlAbortEx.h"
#include "FileEntry.h"
namespace aria2 {

1
test/BtHaveMessageTest.cc
View File

@ -8,6 +8,7 @@
#include "Peer.h"
#include "MockPieceStorage.h"
#include "DlAbortEx.h"
#include "FileEntry.h"
namespace aria2 {