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

Use int64_t instead of off_t 

Some classes such as DiskAdaptor, DiskWriter, FileAllocationIterator
and ChecksumValidator are left unchanged.
pull/22/head
Tatsuhiro Tsujikawa 2012-06-25 23:35:24 +09:00
parent 4b03634f36
commit 1b874268a0
83 changed files with 334 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
src/BitfieldMan.cc
View File

@ -44,7 +44,7 @@ using namespace aria2::expr;
namespace aria2 {
BitfieldMan::BitfieldMan(int32_t blockLength, off_t totalLength)
BitfieldMan::BitfieldMan(int32_t blockLength, int64_t totalLength)
:blockLength_(blockLength),
totalLength_(totalLength),
bitfieldLength_(0),
@ -663,7 +663,7 @@ void BitfieldMan::ensureFilterBitfield()
}
}
void BitfieldMan::addFilter(off_t offset, off_t length) {
void BitfieldMan::addFilter(int64_t offset, int64_t length) {
ensureFilterBitfield();
if(length > 0) {
size_t startBlock = offset/blockLength_;
@ -675,7 +675,7 @@ void BitfieldMan::addFilter(off_t offset, off_t length) {
updateCache();
}
void BitfieldMan::removeFilter(off_t offset, off_t length) {
void BitfieldMan::removeFilter(int64_t offset, int64_t length) {
ensureFilterBitfield();
if(length > 0) {
size_t startBlock = offset/blockLength_;
@ -687,7 +687,7 @@ void BitfieldMan::removeFilter(off_t offset, off_t length) {
updateCache();
}
void BitfieldMan::addNotFilter(off_t offset, off_t length)
void BitfieldMan::addNotFilter(int64_t offset, int64_t length)
{
ensureFilterBitfield();
if(length > 0 && blocks_ > 0) {
@ -726,7 +726,7 @@ void BitfieldMan::clearFilter() {
updateCache();
}
off_t BitfieldMan::getFilteredTotalLengthNow() const {
int64_t BitfieldMan::getFilteredTotalLengthNow() const {
if(!filterBitfield_) {
return 0;
}
@ -735,13 +735,13 @@ off_t BitfieldMan::getFilteredTotalLengthNow() const {
return 0;
}
if(bitfield::test(filterBitfield_, blocks_, blocks_-1)) {
return ((off_t)filteredBlocks-1)*blockLength_+getLastBlockLength();
return ((int64_t)filteredBlocks-1)*blockLength_+getLastBlockLength();
} else {
return ((off_t)filteredBlocks)*blockLength_;
return ((int64_t)filteredBlocks)*blockLength_;
}
}
off_t BitfieldMan::getCompletedLength(bool useFilter) const {
int64_t BitfieldMan::getCompletedLength(bool useFilter) const {
unsigned char* temp;
if(useFilter) {
temp = new unsigned char[bitfieldLength_];
@ -755,15 +755,15 @@ off_t BitfieldMan::getCompletedLength(bool useFilter) const {
temp = bitfield_;
}
size_t completedBlocks = bitfield::countSetBit(temp, blocks_);
off_t completedLength = 0;
int64_t completedLength = 0;
if(completedBlocks == 0) {
completedLength = 0;
} else {
if(bitfield::test(temp, blocks_, blocks_-1)) {
completedLength =
((off_t)completedBlocks-1)*blockLength_+getLastBlockLength();
((int64_t)completedBlocks-1)*blockLength_+getLastBlockLength();
} else {
completedLength = ((off_t)completedBlocks)*blockLength_;
completedLength = ((int64_t)completedBlocks)*blockLength_;
}
}
if(useFilter) {
@ -772,11 +772,11 @@ off_t BitfieldMan::getCompletedLength(bool useFilter) const {
return completedLength;
}
off_t BitfieldMan::getCompletedLengthNow() const {
int64_t BitfieldMan::getCompletedLengthNow() const {
return getCompletedLength(false);
}
off_t BitfieldMan::getFilteredCompletedLengthNow() const {
int64_t BitfieldMan::getFilteredCompletedLengthNow() const {
return getCompletedLength(true);
}
@ -815,7 +815,7 @@ void BitfieldMan::setBitRange(size_t startIndex, size_t endIndex)
updateCache();
}
bool BitfieldMan::isBitSetOffsetRange(off_t offset, off_t length) const
bool BitfieldMan::isBitSetOffsetRange(int64_t offset, int64_t length) const
{
if(length <= 0) {
return false;
@ -836,11 +836,11 @@ bool BitfieldMan::isBitSetOffsetRange(off_t offset, off_t length) const
return true;
}
off_t BitfieldMan::getOffsetCompletedLength
(off_t offset,
off_t length) const
int64_t BitfieldMan::getOffsetCompletedLength
(int64_t offset,
int64_t length) const
{
off_t res = 0;
int64_t res = 0;
if(length == 0 || totalLength_ <= offset) {
return 0;
}
@ -869,12 +869,12 @@ off_t BitfieldMan::getOffsetCompletedLength
return res;
}
off_t BitfieldMan::getMissingUnusedLength(size_t startingIndex) const
int64_t BitfieldMan::getMissingUnusedLength(size_t startingIndex) const
{
if(blocks_ <= startingIndex) {
return 0;
}
off_t length = 0;
int64_t length = 0;
for(size_t i = startingIndex; i < blocks_; ++i) {
if(isBitSet(i) || isUseBitSet(i)) {
break;

38
src/BitfieldMan.h
View File

@ -46,7 +46,7 @@ namespace aria2 {
class BitfieldMan {
private:
int32_t blockLength_;
off_t totalLength_;
int64_t totalLength_;
size_t bitfieldLength_;
size_t blocks_;
bool filterEnabled_;
@ -57,9 +57,9 @@ private:
// for caching
size_t cachedNumMissingBlock_;
size_t cachedNumFilteredBlock_;
off_t cachedCompletedLength_;
off_t cachedFilteredCompletedLength_;
off_t cachedFilteredTotalLength_;
int64_t cachedCompletedLength_;
int64_t cachedFilteredCompletedLength_;
int64_t cachedFilteredTotalLength_;
bool setBitInternal(unsigned char* bitfield, size_t index, bool on);
bool setFilterBit(size_t index);
@ -67,7 +67,7 @@ private:
size_t getStartIndex(size_t index) const;
size_t getEndIndex(size_t index) const;
off_t getCompletedLength(bool useFilter) const;
int64_t getCompletedLength(bool useFilter) const;
// If filterBitfield_ is 0, allocate bitfieldLength_ bytes to it and
// set 0 to all bytes.
@ -84,7 +84,7 @@ public:
bool operator==(const Range& range) const;
};
public:
BitfieldMan(int32_t blockLength, off_t totalLength);
BitfieldMan(int32_t blockLength, int64_t totalLength);
BitfieldMan(const BitfieldMan& bitfieldMan);
~BitfieldMan();
@ -99,7 +99,7 @@ public:
int32_t getBlockLength(size_t index) const;
off_t getTotalLength() const { return totalLength_; }
int64_t getTotalLength() const { return totalLength_; }
// Returns true iff there is a bit index which is set in bitfield_,
// but not set in this object.
@ -238,10 +238,10 @@ public:
void clearAllUseBit();
void setAllUseBit();
void addFilter(off_t offset, off_t length);
void removeFilter(off_t offset, off_t length);
void addFilter(int64_t offset, int64_t length);
void removeFilter(int64_t offset, int64_t length);
// Add filter not in the range of [offset, offset+length) bytes
void addNotFilter(off_t offset, off_t length);
void addNotFilter(int64_t offset, int64_t length);
// Clears filter and disables filter
void clearFilter();
@ -254,29 +254,29 @@ public:
}
// affected by filter
off_t getFilteredTotalLength() const
int64_t getFilteredTotalLength() const
{
return cachedFilteredTotalLength_;
}
// affected by filter
off_t getFilteredTotalLengthNow() const;
int64_t getFilteredTotalLengthNow() const;
off_t getCompletedLength() const
int64_t getCompletedLength() const
{
return cachedCompletedLength_;
}
off_t getCompletedLengthNow() const;
int64_t getCompletedLengthNow() const;
// affected by filter
off_t getFilteredCompletedLength() const
int64_t getFilteredCompletedLength() const
{
return cachedFilteredCompletedLength_;
}
// affected by filter
off_t getFilteredCompletedLengthNow() const;
int64_t getFilteredCompletedLengthNow() const;
void updateCache();
@ -286,13 +286,13 @@ public:
void setBitRange(size_t startIndex, size_t endIndex);
bool isBitSetOffsetRange(off_t offset, off_t length) const;
bool isBitSetOffsetRange(int64_t offset, int64_t length) const;
// Returns completed length in bytes in range [offset,
// offset+length). This function will not affected by filter.
off_t getOffsetCompletedLength(off_t offset, off_t length) const;
int64_t getOffsetCompletedLength(int64_t offset, int64_t length) const;
off_t getMissingUnusedLength(size_t startingIndex) const;
int64_t getMissingUnusedLength(size_t startingIndex) const;
const unsigned char* getFilterBitfield() const
{

6
src/BtRuntime.h
View File

@ -42,7 +42,7 @@ namespace aria2 {
class BtRuntime {
private:
off_t uploadLengthAtStartup_;
int64_t uploadLengthAtStartup_;
bool halt_;
int connections_;
bool ready_;
@ -57,11 +57,11 @@ public:
~BtRuntime();
off_t getUploadLengthAtStartup() const {
int64_t getUploadLengthAtStartup() const {
return uploadLengthAtStartup_;
}
void setUploadLengthAtStartup(off_t length) {
void setUploadLengthAtStartup(int64_t length) {
uploadLengthAtStartup_ = length;
}

4
src/ChunkChecksum.cc
View File

@ -56,9 +56,9 @@ bool ChunkChecksum::validateChunk
return !digest.empty() && actualDigest == digest;
}
off_t ChunkChecksum::getEstimatedDataLength() const
int64_t ChunkChecksum::getEstimatedDataLength() const
{
return static_cast<off_t>(pieceLength_)*pieceHashes_.size();
return static_cast<int64_t>(pieceLength_)*pieceHashes_.size();
}
size_t ChunkChecksum::countPieceHash() const

2
src/ChunkChecksum.h
View File

@ -60,7 +60,7 @@ public:
bool validateChunk(const std::string& actualDigest,
size_t index) const;
off_t getEstimatedDataLength() const;
int64_t getEstimatedDataLength() const;
size_t countPieceHash() const;

14
src/DefaultPieceStorage.cc
View File

@ -513,28 +513,28 @@ bool DefaultPieceStorage::isPieceUsed(size_t index)
return bitfieldMan_->isUseBitSet(index);
}
off_t DefaultPieceStorage::getTotalLength()
int64_t DefaultPieceStorage::getTotalLength()
{
return bitfieldMan_->getTotalLength();
}
off_t DefaultPieceStorage::getFilteredTotalLength()
int64_t DefaultPieceStorage::getFilteredTotalLength()
{
return bitfieldMan_->getFilteredTotalLength();
}
off_t DefaultPieceStorage::getCompletedLength()
int64_t DefaultPieceStorage::getCompletedLength()
{
off_t completedLength =
int64_t completedLength =
bitfieldMan_->getCompletedLength()+getInFlightPieceCompletedLength();
off_t totalLength = getTotalLength();
int64_t totalLength = getTotalLength();
if(completedLength > totalLength) {
completedLength = totalLength;
}
return completedLength;
}
off_t DefaultPieceStorage::getFilteredCompletedLength()
int64_t DefaultPieceStorage::getFilteredCompletedLength()
{
return bitfieldMan_->getFilteredCompletedLength()+
getInFlightPieceCompletedLength();
@ -707,7 +707,7 @@ void DefaultPieceStorage::markAllPiecesDone()
bitfieldMan_->setAllBit();
}
void DefaultPieceStorage::markPiecesDone(off_t length)
void DefaultPieceStorage::markPiecesDone(int64_t length)
{
if(length == bitfieldMan_->getTotalLength()) {
bitfieldMan_->setAllBit();

10
src/DefaultPieceStorage.h
View File

@ -192,13 +192,13 @@ public:
virtual bool isPieceUsed(size_t index);
virtual off_t getTotalLength();
virtual int64_t getTotalLength();
virtual off_t getFilteredTotalLength();
virtual int64_t getFilteredTotalLength();
virtual off_t getCompletedLength();
virtual int64_t getCompletedLength();
virtual off_t getFilteredCompletedLength();
virtual int64_t getFilteredCompletedLength();
virtual void initStorage();
@ -251,7 +251,7 @@ public:
virtual void markAllPiecesDone();
virtual void markPiecesDone(off_t length);
virtual void markPiecesDone(int64_t length);
virtual void markPieceMissing(size_t index);

4
src/DownloadCommand.cc
View File

@ -146,7 +146,7 @@ bool DownloadCommand::executeInternal() {
size_t bufSize;
if(sinkFilterOnly_) {
if(segment->getLength() > 0) {
if(static_cast<off_t>(segment->getPosition()+segment->getLength()) <=
if(segment->getPosition()+segment->getLength() <=
getFileEntry()->getLastOffset()) {
bufSize =
std::min(static_cast<size_t>(segment->getLength()
@ -188,7 +188,7 @@ bool DownloadCommand::executeInternal() {
segmentPartComplete = true;
}
} else {
off_t loff = getFileEntry()->gtoloff(segment->getPositionToWrite());
int64_t loff = getFileEntry()->gtoloff(segment->getPositionToWrite());
if(getFileEntry()->getLength() > 0 && !sinkFilterOnly_ &&
((loff == getRequestEndOffset() && streamFilter_->finished())
|| loff < getRequestEndOffset()) &&

2
src/DownloadCommand.h
View File

@ -76,7 +76,7 @@ protected:
virtual bool prepareForNextSegment();
// This is file local offset
virtual off_t getRequestEndOffset() const = 0;
virtual int64_t getRequestEndOffset() const = 0;
public:
DownloadCommand(cuid_t cuid,
const SharedHandle<Request>& req,

6
src/DownloadContext.cc
View File

@ -57,7 +57,7 @@ DownloadContext::DownloadContext():
metalinkServerContacted_(false) {}
DownloadContext::DownloadContext(int32_t pieceLength,
off_t totalLength,
int64_t totalLength,
const std::string& path):
pieceLength_(pieceLength),
checksumVerified_(false),
@ -95,7 +95,7 @@ int64_t DownloadContext::calculateSessionTime() const
}
SharedHandle<FileEntry>
DownloadContext::findFileEntryByOffset(off_t offset) const
DownloadContext::findFileEntryByOffset(int64_t offset) const
{
if(fileEntries_.empty() ||
(offset > 0 && fileEntries_.back()->getLastOffset() <= offset)) {
@ -198,7 +198,7 @@ size_t DownloadContext::getNumPieces() const
}
}
off_t DownloadContext::getTotalLength() const
int64_t DownloadContext::getTotalLength() const
{
if(fileEntries_.empty()) {
return 0;

6
src/DownloadContext.h
View File

@ -93,7 +93,7 @@ public:
// Convenient constructor that creates single file download. path
// should be escaped with util::escapePath(...).
DownloadContext(int32_t pieceLength,
off_t totalLength,
int64_t totalLength,
const std::string& path = A2STR::NIL);
~DownloadContext();
@ -114,7 +114,7 @@ public:
pieceHashes_.assign(first, last);
}
off_t getTotalLength() const;
int64_t getTotalLength() const;
bool knowsTotalLength() const { return knowsTotalLength_; }
@ -222,7 +222,7 @@ public:
// Returns FileEntry at given offset. SharedHandle<FileEntry>() is
// returned if no such FileEntry is found.
SharedHandle<FileEntry> findFileEntryByOffset(off_t offset) const;
SharedHandle<FileEntry> findFileEntryByOffset(int64_t offset) const;
void releaseRuntimeResource();

6
src/DownloadResult.h
View File

@ -79,11 +79,11 @@ struct DownloadResult
SharedHandle<MetadataInfo> metadataInfo;
off_t totalLength;
int64_t totalLength;
off_t completedLength;
int64_t completedLength;
off_t uploadLength;
int64_t uploadLength;
std::string bitfield;

2
src/File.cc
View File

@ -103,7 +103,7 @@ bool File::remove() {
}
}
off_t File::size() {
int64_t File::size() {
a2_struct_stat fstat;
if(fillStat(fstat) < 0) {
return 0;

2
src/File.h
View File

@ -94,7 +94,7 @@ public:
*/
bool mkdirs();
off_t size();
int64_t size();
mode_t mode();

6
src/FileEntry.cc
View File

@ -68,8 +68,8 @@ bool FileEntry::RequestFaster::operator()
FileEntry::FileEntry
(const std::string& path,
off_t length,
off_t offset,
int64_t length,
int64_t offset,
const std::vector<std::string>& uris)
: path_(path),
uris_(uris.begin(), uris.end()),
@ -112,7 +112,7 @@ bool FileEntry::exists() const
return File(getPath()).exists();
}
off_t FileEntry::gtoloff(off_t goff) const
int64_t FileEntry::gtoloff(int64_t goff) const
{
assert(offset_ <= goff);
return goff-offset_;

18
src/FileEntry.h
View File

@ -66,8 +66,8 @@ private:
std::string path_;
std::deque<std::string> uris_;
std::deque<std::string> spentUris_;
off_t length_;
off_t offset_;
int64_t length_;
int64_t offset_;
bool requested_;
class RequestFaster {
@ -92,7 +92,7 @@ private:
public:
FileEntry();
FileEntry(const std::string& path, off_t length, off_t offset,
FileEntry(const std::string& path, int64_t length, int64_t offset,
const std::vector<std::string>& uris = std::vector<std::string>());
~FileEntry();
@ -107,15 +107,15 @@ public:
void setPath(const std::string& path);
off_t getLength() const { return length_; }
int64_t getLength() const { return length_; }
void setLength(off_t length) { length_ = length; }
void setLength(int64_t length) { length_ = length; }
off_t getOffset() const { return offset_; }
int64_t getOffset() const { return offset_; }
void setOffset(off_t offset) { offset_ = offset; }
void setOffset(int64_t offset) { offset_ = offset; }
off_t getLastOffset() { return offset_+length_; }
int64_t getLastOffset() { return offset_+length_; }
bool isRequested() const { return requested_; }
@ -209,7 +209,7 @@ public:
bool exists() const;
// Translate global offset goff to file local offset.
off_t gtoloff(off_t goff) const;
int64_t gtoloff(int64_t goff) const;
void removeURIWhoseHostnameIs(const std::string& hostname);

2
src/FtpDownloadCommand.cc
View File

@ -85,7 +85,7 @@ bool FtpDownloadCommand::prepareForNextSegment()
}
}
off_t FtpDownloadCommand::getRequestEndOffset() const
int64_t FtpDownloadCommand::getRequestEndOffset() const
{
return getFileEntry()->getLength();
}

2
src/FtpDownloadCommand.h
View File

@ -48,7 +48,7 @@ private:
SharedHandle<SocketCore> ctrlSocket_;
protected:
virtual bool prepareForNextSegment();
virtual off_t getRequestEndOffset() const;
virtual int64_t getRequestEndOffset() const;
public:
FtpDownloadCommand(cuid_t cuid,
const SharedHandle<Request>& req,

2
src/FtpNegotiationCommand.cc
View File

@ -367,7 +367,7 @@ bool FtpNegotiationCommand::sendSize() {
return false;
}
bool FtpNegotiationCommand::onFileSizeDetermined(off_t totalLength)
bool FtpNegotiationCommand::onFileSizeDetermined(int64_t totalLength)
{
getFileEntry()->setLength(totalLength);
if(getFileEntry()->getPath().empty()) {

2
src/FtpNegotiationCommand.h
View File

@ -137,7 +137,7 @@ private:
void poolConnection() const;
bool onFileSizeDetermined(off_t totalLength);
bool onFileSizeDetermined(int64_t totalLength);
void onDryRunFileFound();

4
src/GrowSegment.h
View File

@ -58,12 +58,12 @@ public:
return 0;
}
virtual off_t getPosition() const
virtual int64_t getPosition() const
{
return 0;
}
virtual off_t getPositionToWrite() const
virtual int64_t getPositionToWrite() const
{
return writtenLength_;
}

9
src/HttpDownloadCommand.cc
View File

@ -117,9 +117,8 @@ bool HttpDownloadCommand::prepareForNextSegment() {
!downloadFinished) {
const SharedHandle<Segment>& segment = getSegments().front();
off_t lastOffset =getFileEntry()->gtoloff
(std::min(static_cast<off_t>
(segment->getPosition()+segment->getLength()),
int64_t lastOffset =getFileEntry()->gtoloff
(std::min(segment->getPosition()+segment->getLength(),
getFileEntry()->getLastOffset()));
if(lastOffset ==
@ -131,9 +130,9 @@ bool HttpDownloadCommand::prepareForNextSegment() {
}
}
off_t HttpDownloadCommand::getRequestEndOffset() const
int64_t HttpDownloadCommand::getRequestEndOffset() const
{
off_t endByte = httpResponse_->getHttpHeader()->getRange()->getEndByte();
int64_t endByte = httpResponse_->getHttpHeader()->getRange()->getEndByte();
if(endByte > 0) {
return endByte+1;
} else {

2
src/HttpDownloadCommand.h
View File

@ -48,7 +48,7 @@ private:
SharedHandle<HttpConnection> httpConnection_;
protected:
virtual bool prepareForNextSegment();
virtual off_t getRequestEndOffset() const;
virtual int64_t getRequestEndOffset() const;
public:
HttpDownloadCommand(cuid_t cuid,
const SharedHandle<Request>& req,

10
src/HttpRequest.cc
View File

@ -75,7 +75,7 @@ void HttpRequest::setRequest(const SharedHandle<Request>& request)
request_ = request;
}
off_t HttpRequest::getStartByte() const
int64_t HttpRequest::getStartByte() const
{
if(!segment_) {
return 0;
@ -84,15 +84,15 @@ off_t HttpRequest::getStartByte() const
}
}
off_t HttpRequest::getEndByte() const
int64_t HttpRequest::getEndByte() const
{
if(!segment_ || !request_) {
return 0;
} else {
if(request_->isPipeliningEnabled()) {
off_t endByte =
int64_t endByte =
fileEntry_->gtoloff(segment_->getPosition()+segment_->getLength()-1);
return std::min(endByte, static_cast<off_t>(fileEntry_->getLength()-1));
return std::min(endByte, fileEntry_->getLength()-1);
} else {
return 0;
}
@ -367,7 +367,7 @@ const SharedHandle<AuthConfig>& HttpRequest::getAuthConfig() const
return authConfig_;
}
off_t HttpRequest::getEntityLength() const
int64_t HttpRequest::getEntityLength() const
{
assert(fileEntry_);
return fileEntry_->getLength();

10
src/HttpRequest.h
View File

@ -87,7 +87,7 @@ private:
bool acceptGzip_;
off_t endOffsetOverride_;
int64_t endOffsetOverride_;
std::string ifModSinceHeader_;
@ -105,7 +105,7 @@ public:
void setRequest(const SharedHandle<Request>& request);
off_t getEntityLength() const;
int64_t getEntityLength() const;
const std::string& getHost() const;
@ -140,9 +140,9 @@ public:
return request_;
}
off_t getStartByte() const;
int64_t getStartByte() const;
off_t getEndByte() const;
int64_t getEndByte() const;
/**
* Returns string representation of http request. It usually starts
@ -240,7 +240,7 @@ public:
return acceptGzip_;
}
void setEndOffsetOverride(off_t offset)
void setEndOffsetOverride(int64_t offset)
{
endOffsetOverride_ = offset;
}

13
src/HttpRequestCommand.cc
View File

@ -86,13 +86,13 @@ SharedHandle<HttpRequest>
createHttpRequest(const SharedHandle<Request>& req,
const SharedHandle<FileEntry>& fileEntry,
const SharedHandle<Segment>& segment,
off_t totalLength,
int64_t totalLength,
const SharedHandle<Option>& option,
const RequestGroup* rg,
const SharedHandle<CookieStorage>& cookieStorage,
const SharedHandle<AuthConfigFactory>& authConfigFactory,
const SharedHandle<Request>& proxyRequest,
off_t endOffset = 0)
int64_t endOffset = 0)
{
SharedHandle<HttpRequest> httpRequest(new HttpRequest());
httpRequest->setUserAgent(option->get(PREF_USER_AGENT));
@ -180,15 +180,14 @@ bool HttpRequestCommand::executeInternal() {
itr != eoi; ++itr) {
const SharedHandle<Segment>& segment = *itr;
if(!httpConnection_->isIssued(segment)) {
off_t endOffset = 0;
if(getRequestGroup()->getTotalLength() > 0 &&
getPieceStorage()) {
int64_t endOffset = 0;
if(getRequestGroup()->getTotalLength() > 0 && getPieceStorage()) {
size_t nextIndex =
getPieceStorage()->getNextUsedIndex(segment->getIndex());
endOffset = std::min
(static_cast<off_t>(getFileEntry()->getLength()),
(getFileEntry()->getLength(),
getFileEntry()->gtoloff
(static_cast<off_t>(segment->getSegmentLength())*nextIndex));
(static_cast<int64_t>(segment->getSegmentLength())*nextIndex));
}
SharedHandle<HttpRequest> httpRequest
(createHttpRequest(getRequest(),

4
src/HttpResponse.cc
View File

@ -227,7 +227,7 @@ SharedHandle<StreamFilter> HttpResponse::getContentEncodingStreamFilter() const
return filter;
}
off_t HttpResponse::getContentLength() const
int64_t HttpResponse::getContentLength() const
{
if(!httpHeader_) {
return 0;
@ -236,7 +236,7 @@ off_t HttpResponse::getContentLength() const
}
}
off_t HttpResponse::getEntityLength() const
int64_t HttpResponse::getEntityLength() const
{
if(!httpHeader_) {
return 0;

4
src/HttpResponse.h
View File

@ -96,9 +96,9 @@ public:
SharedHandle<StreamFilter> getContentEncodingStreamFilter() const;
off_t getContentLength() const;
int64_t getContentLength() const;
off_t getEntityLength() const;
int64_t getEntityLength() const;
// Returns type "/" subtype. The parameter is removed.
std::string getContentType() const;

4
src/HttpResponseCommand.cc
View File

@ -181,7 +181,7 @@ bool HttpResponseCommand::executeInternal()
int statusCode = httpResponse->getStatusCode();
if(statusCode == 304) {
off_t totalLength = httpResponse->getEntityLength();
int64_t totalLength = httpResponse->getEntityLength();
getFileEntry()->setLength(totalLength);
getRequestGroup()->initPieceStorage();
getPieceStorage()->markAllPiecesDone();
@ -246,7 +246,7 @@ bool HttpResponseCommand::executeInternal()
}
if(!getPieceStorage()) {
util::removeMetalinkContentTypes(getRequestGroup());
off_t totalLength = httpResponse->getEntityLength();
int64_t totalLength = httpResponse->getEntityLength();
getFileEntry()->setLength(totalLength);
if(getFileEntry()->getPath().empty()) {
getFileEntry()->setPath

4
src/HttpServer.h
View File

@ -60,7 +60,7 @@ private:
DownloadEngine* e_;
SharedHandle<HttpHeaderProcessor> headerProcessor_;
SharedHandle<HttpHeader> lastRequestHeader_;
off_t lastContentLength_;
int64_t lastContentLength_;
std::stringstream lastBody_;
bool keepAlive_;
bool gzip_;
@ -129,7 +129,7 @@ public:
void disableGZip() { gzip_ = false; }
off_t getContentLength() const { return lastContentLength_; }
int64_t getContentLength() const { return lastContentLength_; }
const SharedHandle<SocketRecvBuffer>& getSocketRecvBuffer() const
{

2
src/HttpSkipResponseCommand.cc
View File

@ -124,7 +124,7 @@ bool HttpSkipResponseCommand::executeInternal()
if(totalLength_ > 0) {
bufSize = std::min
(totalLength_-receivedBytes_,
static_cast<off_t>(getSocketRecvBuffer()->getBufferLength()));
static_cast<int64_t>(getSocketRecvBuffer()->getBufferLength()));
} else {
bufSize = getSocketRecvBuffer()->getBufferLength();
}

4
src/HttpSkipResponseCommand.h
View File

@ -53,9 +53,9 @@ private:
bool sinkFilterOnly_;
off_t totalLength_;
int64_t totalLength_;
off_t receivedBytes_;
int64_t receivedBytes_;
bool processResponse();

2
src/Metalink2RequestGroup.cc
View File

@ -293,7 +293,7 @@ Metalink2RequestGroup::createRequestGroup
// piece length is overridden by the one in torrent file.
dctx->setPieceLength(option->getAsInt(PREF_PIECE_LENGTH));
std::vector<SharedHandle<FileEntry> > fileEntries;
off_t offset = 0;
int64_t offset = 0;
for(std::vector<SharedHandle<MetalinkEntry> >::const_iterator i =
mes.begin(), eoi = mes.end(); i != eoi; ++i) {
A2_LOG_INFO(fmt("Metalink: Queueing %s for download as a member.",

2
src/MetalinkEntry.cc
View File

@ -101,7 +101,7 @@ const std::string& MetalinkEntry::getPath() const
return file->getPath();
}
off_t MetalinkEntry::getLength() const
int64_t MetalinkEntry::getLength() const
{
return file->getLength();
}

2
src/MetalinkEntry.h
View File

@ -79,7 +79,7 @@ public:
const std::string& getPath() const;
off_t getLength() const;
int64_t getLength() const;
const SharedHandle<FileEntry>& getFile() const
{

2
src/MetalinkParserController.cc
View File

@ -87,7 +87,7 @@ void MetalinkParserController::setFileNameOfEntry(const std::string& filename)
}
}
void MetalinkParserController::setFileLengthOfEntry(off_t length)
void MetalinkParserController::setFileLengthOfEntry(int64_t length)
{
if(!tEntry_) {
return;

2
src/MetalinkParserController.h
View File

@ -96,7 +96,7 @@ public:
void setFileNameOfEntry(const std::string& filename);
void setFileLengthOfEntry(off_t length);
void setFileLengthOfEntry(int64_t length);
void setVersionOfEntry(const std::string& version);

2
src/MetalinkParserStateMachine.cc
View File

@ -262,7 +262,7 @@ void MetalinkParserStateMachine::setFileNameOfEntry(const std::string& filename)
ctrl_->setFileNameOfEntry(filename);
}
void MetalinkParserStateMachine::setFileLengthOfEntry(off_t length)
void MetalinkParserStateMachine::setFileLengthOfEntry(int64_t length)
{
ctrl_->setFileLengthOfEntry(length);
}

2
src/MetalinkParserStateMachine.h
View File

@ -159,7 +159,7 @@ public:
void setFileNameOfEntry(const std::string& filename);
void setFileLengthOfEntry(off_t length);
void setFileLengthOfEntry(int64_t length);
void setVersionOfEntry(const std::string& version);

10
src/Peer.cc
View File

@ -73,7 +73,7 @@ void Peer::usedBy(cuid_t cuid)
cuid_ = cuid;
}
void Peer::allocateSessionResource(int32_t pieceLength, off_t totalLength)
void Peer::allocateSessionResource(int32_t pieceLength, int64_t totalLength)
{
delete res_;
res_ = new PeerSessionResource(pieceLength, totalLength);
@ -81,7 +81,7 @@ void Peer::allocateSessionResource(int32_t pieceLength, off_t totalLength)
updateSeeder();
}
void Peer::reconfigureSessionResource(int32_t pieceLength, off_t totalLength)
void Peer::reconfigureSessionResource(int32_t pieceLength, int64_t totalLength)
{
assert(res_);
res_->reconfigure(pieceLength, totalLength);
@ -228,13 +228,13 @@ int Peer::calculateDownloadSpeed()
return res_->getPeerStat().calculateDownloadSpeed();
}
off_t Peer::getSessionUploadLength() const
int64_t Peer::getSessionUploadLength() const
{
assert(res_);
return res_->uploadLength();
}
off_t Peer::getSessionDownloadLength() const
int64_t Peer::getSessionDownloadLength() const
{
assert(res_);
return res_->downloadLength();
@ -388,7 +388,7 @@ const Timer& Peer::getLastAmUnchoking() const
return res_->getLastAmUnchoking();
}
off_t Peer::getCompletedLength() const
int64_t Peer::getCompletedLength() const
{
assert(res_);
return res_->getCompletedLength();

10
src/Peer.h
View File

@ -160,9 +160,9 @@ public:
bool isGood() const;
void allocateSessionResource(int32_t pieceLength, off_t totalLength);
void allocateSessionResource(int32_t pieceLength, int64_t totalLength);
void reconfigureSessionResource(int32_t pieceLength, off_t totalLength);
void reconfigureSessionResource(int32_t pieceLength, int64_t totalLength);
void releaseSessionResource();
@ -234,12 +234,12 @@ public:
/**
* Returns the number of bytes uploaded to the remote host.
*/
off_t getSessionUploadLength() const;
int64_t getSessionUploadLength() const;
/**
* Returns the number of bytes downloaded from the remote host.
*/
off_t getSessionDownloadLength() const;
int64_t getSessionDownloadLength() const;
void setBitfield(const unsigned char* bitfield, size_t bitfieldLength);
@ -293,7 +293,7 @@ public:
const Timer& getLastAmUnchoking() const;
off_t getCompletedLength() const;
int64_t getCompletedLength() const;
bool isIncomingPeer() const
{

10
src/PeerSessionResource.cc
View File

@ -44,7 +44,7 @@
namespace aria2 {
PeerSessionResource::PeerSessionResource(int32_t pieceLength, off_t totalLength)
PeerSessionResource::PeerSessionResource(int32_t pieceLength, int64_t totalLength)
:
amChoking_(true),
amInterested_(false),
@ -225,7 +225,7 @@ void PeerSessionResource::dhtEnabled(bool b)
dhtEnabled_ = b;
}
off_t PeerSessionResource::uploadLength() const
int64_t PeerSessionResource::uploadLength() const
{
return peerStat_.getSessionUploadLength();
}
@ -235,7 +235,7 @@ void PeerSessionResource::updateUploadLength(int32_t bytes)
peerStat_.updateUploadLength(bytes);
}
off_t PeerSessionResource::downloadLength() const
int64_t PeerSessionResource::downloadLength() const
{
return peerStat_.getSessionDownloadLength();
}
@ -247,7 +247,7 @@ void PeerSessionResource::updateDownloadLength(int32_t bytes)
lastDownloadUpdate_ = global::wallclock();
}
off_t PeerSessionResource::getCompletedLength() const
int64_t PeerSessionResource::getCompletedLength() const
{
return bitfieldMan_->getCompletedLength();
}
@ -263,7 +263,7 @@ size_t PeerSessionResource::countOutstandingUpload() const
return dispatcher_->countOutstandingUpload();
}
void PeerSessionResource::reconfigure(int32_t pieceLength, off_t totalLenth)
void PeerSessionResource::reconfigure(int32_t pieceLength, int64_t totalLenth)
{
delete bitfieldMan_;
bitfieldMan_ = new BitfieldMan(pieceLength, totalLenth);

10
src/PeerSessionResource.h
View File

@ -83,7 +83,7 @@ private:
BtMessageDispatcher* dispatcher_;
public:
PeerSessionResource(int32_t pieceLength, off_t totalLength);
PeerSessionResource(int32_t pieceLength, int64_t totalLength);
~PeerSessionResource();
@ -155,7 +155,7 @@ public:
size_t getBitfieldLength() const;
void reconfigure(int32_t pieceLength, off_t totalLength);
void reconfigure(int32_t pieceLength, int64_t totalLength);
bool hasPiece(size_t index) const;
@ -210,11 +210,11 @@ public:
return peerStat_;
}
off_t uploadLength() const;
int64_t uploadLength() const;
void updateUploadLength(int32_t bytes);
off_t downloadLength() const;
int64_t downloadLength() const;
void updateDownloadLength(int32_t bytes);
@ -228,7 +228,7 @@ public:
return lastAmUnchoking_;
}
off_t getCompletedLength() const;
int64_t getCompletedLength() const;
void setBtMessageDispatcher(BtMessageDispatcher* dpt);

10
src/PieceStorage.h
View File

@ -179,13 +179,13 @@ public:
virtual bool isPieceUsed(size_t index) = 0;
virtual off_t getTotalLength() = 0;
virtual int64_t getTotalLength() = 0;
virtual off_t getFilteredTotalLength() = 0;
virtual int64_t getFilteredTotalLength() = 0;
virtual off_t getCompletedLength() = 0;
virtual int64_t getCompletedLength() = 0;
virtual off_t getFilteredCompletedLength() = 0;
virtual int64_t getFilteredCompletedLength() = 0;
virtual void setupFileFilter() = 0;
@ -258,7 +258,7 @@ public:
/**
* Sets all bits in bitfield(0 to length) to 1.
*/
virtual void markPiecesDone(off_t length) = 0;
virtual void markPiecesDone(int64_t length) = 0;
virtual void
addInFlightPiece(const std::vector<SharedHandle<Piece> >& pieces) = 0;

6
src/PiecedSegment.cc
View File

@ -61,12 +61,12 @@ size_t PiecedSegment::getIndex() const
return piece_->getIndex();
}
off_t PiecedSegment::getPosition() const
int64_t PiecedSegment::getPosition() const
{
return ((off_t)piece_->getIndex())*pieceLength_;
return ((int64_t)piece_->getIndex())*pieceLength_;
}
off_t PiecedSegment::getPositionToWrite() const
int64_t PiecedSegment::getPositionToWrite() const
{
return getPosition()+writtenLength_;
}

4
src/PiecedSegment.h
View File

@ -58,9 +58,9 @@ public:
virtual size_t getIndex() const;
virtual off_t getPosition() const;
virtual int64_t getPosition() const;
virtual off_t getPositionToWrite() const;
virtual int64_t getPositionToWrite() const;
virtual int32_t getLength() const;

4
src/Range.cc
View File

@ -38,7 +38,7 @@ namespace aria2 {
Range::Range():startByte_(0), endByte_(0), entityLength_(0) {}
Range::Range(off_t startByte, off_t endByte, off_t entityLength)
Range::Range(int64_t startByte, int64_t endByte, int64_t entityLength)
: startByte_(startByte), endByte_(endByte), entityLength_(entityLength)
{}
@ -72,7 +72,7 @@ bool Range::operator!=(const Range& range) const
return !(*this == range);
}
off_t Range::getContentLength() const
int64_t Range::getContentLength() const
{
if(endByte_ >= startByte_) {
return endByte_-startByte_+1;

16
src/Range.h
View File

@ -45,13 +45,13 @@ namespace aria2 {
class Range {
private:
off_t startByte_;
off_t endByte_;
off_t entityLength_;
int64_t startByte_;
int64_t endByte_;
int64_t entityLength_;
public:
Range();
Range(off_t startByte, off_t endByte, off_t entityLength);
Range(int64_t startByte, int64_t endByte, int64_t entityLength);
Range(const Range& c);
@ -63,22 +63,22 @@ public:
bool operator!=(const Range& range) const;
off_t getStartByte() const
int64_t getStartByte() const
{
return startByte_;
}
off_t getEndByte() const
int64_t getEndByte() const
{
return endByte_;
}
off_t getEntityLength() const
int64_t getEntityLength() const
{
return entityLength_;
}
off_t getContentLength() const;
int64_t getContentLength() const;
};
typedef SharedHandle<Range> RangeHandle;

16
src/RequestGroup.cc
View File

@ -386,7 +386,7 @@ void RequestGroup::createInitialCommand
}
removeDefunctControlFile(progressInfoFile);
{
off_t actualFileSize = pieceStorage_->getDiskAdaptor()->size();
int64_t actualFileSize = pieceStorage_->getDiskAdaptor()->size();
if(actualFileSize == downloadContext_->getTotalLength()) {
// First, make DiskAdaptor read-only mode to allow the
// program to seed file in read-only media.
@ -551,7 +551,7 @@ void RequestGroup::processCheckIntegrityEntry
const SharedHandle<CheckIntegrityEntry>& entry,
DownloadEngine* e)
{
off_t actualFileSize = pieceStorage_->getDiskAdaptor()->size();
int64_t actualFileSize = pieceStorage_->getDiskAdaptor()->size();
if(actualFileSize > downloadContext_->getTotalLength()) {
entry->cutTrailingGarbage();
}
@ -858,7 +858,7 @@ std::string RequestGroup::getFirstFilePath() const
}
}
off_t RequestGroup::getTotalLength() const
int64_t RequestGroup::getTotalLength() const
{
if(!pieceStorage_) {
return 0;
@ -871,7 +871,7 @@ off_t RequestGroup::getTotalLength() const
}
}
off_t RequestGroup::getCompletedLength() const
int64_t RequestGroup::getCompletedLength() const
{
if(!pieceStorage_) {
return 0;
@ -897,8 +897,8 @@ void RequestGroup::validateFilename(const std::string& expectedFilename,
}
}
void RequestGroup::validateTotalLength(off_t expectedTotalLength,
off_t actualTotalLength) const
void RequestGroup::validateTotalLength(int64_t expectedTotalLength,
int64_t actualTotalLength) const
{
if(expectedTotalLength <= 0) {
return;
@ -916,7 +916,7 @@ void RequestGroup::validateFilename(const std::string& actualFilename) const
validateFilename(downloadContext_->getFileEntries().front()->getBasename(), actualFilename);
}
void RequestGroup::validateTotalLength(off_t actualTotalLength) const
void RequestGroup::validateTotalLength(int64_t actualTotalLength) const
{
validateTotalLength(getTotalLength(), actualTotalLength);
}
@ -1199,7 +1199,7 @@ void RequestGroup::reportDownloadFinished()
#ifdef ENABLE_BITTORRENT
if(downloadContext_->hasAttribute(bittorrent::BITTORRENT)) {
TransferStat stat = calculateStat();
off_t completedLength = getCompletedLength();
int64_t completedLength = getCompletedLength();
double shareRatio = completedLength == 0 ? 0.0 :
1.0*stat.getAllTimeUploadLength()/completedLength;
SharedHandle<TorrentAttribute> attrs =

10
src/RequestGroup.h
View File

@ -230,9 +230,9 @@ public:
std::string getFirstFilePath() const;
off_t getTotalLength() const;
int64_t getTotalLength() const;
off_t getCompletedLength() const;
int64_t getCompletedLength() const;
/**
* Compares expected filename with specified actualFilename.
@ -241,10 +241,10 @@ public:
*/
void validateFilename(const std::string& actualFilename) const;
void validateTotalLength(off_t expectedTotalLength,
off_t actualTotalLength) const;
void validateTotalLength(int64_t expectedTotalLength,
int64_t actualTotalLength) const;
void validateTotalLength(off_t actualTotalLength) const;
void validateTotalLength(int64_t actualTotalLength) const;
void setNumConcurrentCommand(int num)
{

2
src/RequestGroupMan.cc
View File

@ -775,7 +775,7 @@ void RequestGroupMan::formatDownloadResultFull
if((*i)->getLength() == 0 || downloadResult->bitfield.empty()) {
o << " -|";
} else {
off_t completedLength =
int64_t completedLength =
bt.getOffsetCompletedLength((*i)->getOffset(), (*i)->getLength());
o << std::setw(3) << 100*completedLength/(*i)->getLength() << "|";
}

6
src/RpcMethodImpl.cc
View File

@ -585,7 +585,7 @@ void createFileEntry
entry->put(KEY_PATH, (*first)->getPath());
entry->put(KEY_SELECTED, (*first)->isRequested()?VLB_TRUE:VLB_FALSE);
entry->put(KEY_LENGTH, util::itos((*first)->getLength()));
off_t completedLength = bf->getOffsetCompletedLength
int64_t completedLength = bf->getOffsetCompletedLength
((*first)->getOffset(), (*first)->getLength());
entry->put(KEY_COMPLETED_LENGTH, util::itos(completedLength));
@ -602,7 +602,7 @@ template<typename InputIterator>
void createFileEntry
(const SharedHandle<List>& files,
InputIterator first, InputIterator last,
off_t totalLength,
int64_t totalLength,
int32_t pieceLength,
const std::string& bitfield)
{
@ -618,7 +618,7 @@ template<typename InputIterator>
void createFileEntry
(const SharedHandle<List>& files,
InputIterator first, InputIterator last,
off_t totalLength,
int64_t totalLength,
int32_t pieceLength,
const SharedHandle<PieceStorage>& ps)
{

4
src/Segment.h
View File

@ -54,9 +54,9 @@ public:
virtual size_t getIndex() const = 0;
virtual off_t getPosition() const = 0;
virtual int64_t getPosition() const = 0;
virtual off_t getPositionToWrite() const = 0;
virtual int64_t getPositionToWrite() const = 0;
virtual int32_t getLength() const = 0;

8
src/SegmentMan.cc
View File

@ -94,7 +94,7 @@ void SegmentMan::init()
// PieceStorage here?
}
off_t SegmentMan::getTotalLength() const
int64_t SegmentMan::getTotalLength() const
{
if(!pieceStorage_) {
return 0;
@ -340,7 +340,7 @@ bool SegmentMan::hasSegment(size_t index) const {
return pieceStorage_->hasPiece(index);
}
off_t SegmentMan::getDownloadLength() const {
int64_t SegmentMan::getDownloadLength() const {
if(!pieceStorage_) {
return 0;
} else {
@ -442,14 +442,14 @@ void SegmentMan::updateDownloadSpeedFor(const SharedHandle<PeerStat>& pstat)
namespace {
class PeerStatDownloadLengthOperator {
public:
off_t operator()(off_t total, const SharedHandle<PeerStat>& ps)
int64_t operator()(int64_t total, const SharedHandle<PeerStat>& ps)
{
return ps->getSessionDownloadLength()+total;
}
};
} // namespace
off_t SegmentMan::calculateSessionDownloadLength() const
int64_t SegmentMan::calculateSessionDownloadLength() const
{
return std::accumulate(fastestPeerStats_.begin(), fastestPeerStats_.end(),
0LL, PeerStatDownloadLengthOperator());

6
src/SegmentMan.h
View File

@ -124,7 +124,7 @@ public:
* If Transfer-Encoding is Chunked or Content-Length header is not provided,
* then this value is set to be 0.
*/
off_t getTotalLength() const;
int64_t getTotalLength() const;
/**
* Returs true when the download has finished.
@ -202,7 +202,7 @@ public:
/**
* Returns the length of bytes downloaded.
*/
off_t getDownloadLength() const;
int64_t getDownloadLength() const;
// If there is inactive PeerStat in peerStats_, it is replaced with
@ -238,7 +238,7 @@ public:
/**
* Returns the downloaded bytes in this session.
*/
off_t calculateSessionDownloadLength() const;
int64_t calculateSessionDownloadLength() const;
size_t countFreePieceFrom(size_t index) const;

2
src/UnknownLengthPieceStorage.cc
View File

@ -238,7 +238,7 @@ void UnknownLengthPieceStorage::markAllPiecesDone()
downloadFinished_ = true;
}
void UnknownLengthPieceStorage::markPiecesDone(off_t length)
void UnknownLengthPieceStorage::markPiecesDone(int64_t length)
{
// TODO not implemented yet
abort();

12
src/UnknownLengthPieceStorage.h
View File

@ -54,7 +54,7 @@ private:
SharedHandle<DiskWriterFactory> diskWriterFactory_;
off_t totalLength_;
int64_t totalLength_;
bool downloadFinished_;
@ -152,23 +152,23 @@ public:
virtual bool isPieceUsed(size_t index);
virtual off_t getTotalLength()
virtual int64_t getTotalLength()
{
return totalLength_;
}
virtual off_t getFilteredTotalLength()
virtual int64_t getFilteredTotalLength()
{
return totalLength_;
}
virtual off_t getCompletedLength()
virtual int64_t getCompletedLength()
{
// TODO we have to return actual completed length here?
return totalLength_;
}
virtual off_t getFilteredCompletedLength()
virtual int64_t getFilteredCompletedLength()
{
return getCompletedLength();
}
@ -259,7 +259,7 @@ public:
*/
virtual void markAllPiecesDone();
virtual void markPiecesDone(off_t length);
virtual void markPiecesDone(int64_t length);
virtual void markPieceMissing(size_t index);

2
src/bittorrent_helper.cc
View File

@ -234,7 +234,7 @@ void extractFileEntries
if(filesList) {
fileEntries.reserve(filesList->size());
int64_t length = 0;
off_t offset = 0;
int64_t offset = 0;
// multi-file mode
torrent->mode = MULTI;
for(List::ValueType::const_iterator itr = filesList->begin(),

8
src/util.cc
View File

@ -689,7 +689,7 @@ void computeHeadPieces
(std::vector<size_t>& indexes,
const std::vector<SharedHandle<FileEntry> >& fileEntries,
size_t pieceLength,
off_t head)
int64_t head)
{
if(head == 0) {
return;
@ -714,7 +714,7 @@ void computeTailPieces
(std::vector<size_t>& indexes,
const std::vector<SharedHandle<FileEntry> >& fileEntries,
size_t pieceLength,
off_t tail)
int64_t tail)
{
if(tail == 0) {
return;
@ -739,7 +739,7 @@ void parsePrioritizePieceRange
(std::vector<size_t>& result, const std::string& src,
const std::vector<SharedHandle<FileEntry> >& fileEntries,
size_t pieceLength,
off_t defaultSize)
int64_t defaultSize)
{
std::vector<size_t> indexes;
std::vector<Scip> parts;
@ -1179,7 +1179,7 @@ void convertBitfield(BitfieldMan* dest, const BitfieldMan* src)
{
size_t numBlock = dest->countBlock();
for(size_t index = 0; index < numBlock; ++index) {
if(src->isBitSetOffsetRange((off_t)index*dest->getBlockLength(),
if(src->isBitSetOffsetRange((int64_t)index*dest->getBlockLength(),
dest->getBlockLength())) {
dest->setBit(index);
}

2
src/util.h
View File

@ -293,7 +293,7 @@ void parsePrioritizePieceRange
(std::vector<size_t>& result, const std::string& src,
const std::vector<SharedHandle<FileEntry> >& fileEntries,
size_t pieceLength,
off_t defaultSize = 1048576 /* 1MiB */);
int64_t defaultSize = 1048576 /* 1MiB */);
// Converts ISO/IEC 8859-1 string src to utf-8.
std::string iso8859ToUtf8(const std::string& src);

54
test/BitfieldManTest.cc
View File

@ -221,7 +221,7 @@ void BitfieldManTest::testFilter()
for(size_t i = 0; i < A2_ARRAY_LEN(ans); ++i) {
CPPUNIT_ASSERT_EQUAL(ans[i], out[i]);
}
CPPUNIT_ASSERT_EQUAL((off_t)12ULL, btman.getFilteredTotalLength());
CPPUNIT_ASSERT_EQUAL((int64_t)12ULL, btman.getFilteredTotalLength());
// test offset=5, length=2
out.clear();
@ -235,13 +235,13 @@ void BitfieldManTest::testFilter()
CPPUNIT_ASSERT_EQUAL((size_t)3, out[1]);
btman.setBit(2);
btman.setBit(3);
CPPUNIT_ASSERT_EQUAL((off_t)4ULL, btman.getFilteredTotalLength());
CPPUNIT_ASSERT_EQUAL((int64_t)4ULL, btman.getFilteredTotalLength());
CPPUNIT_ASSERT(btman.isFilteredAllBitSet());
BitfieldMan btman2(2, 31);
btman2.addFilter(0, 31);
btman2.enableFilter();
CPPUNIT_ASSERT_EQUAL((off_t)31ULL, btman2.getFilteredTotalLength());
CPPUNIT_ASSERT_EQUAL((int64_t)31ULL, btman2.getFilteredTotalLength());
}
void BitfieldManTest::testAddFilter_zeroLength()
@ -453,27 +453,27 @@ void BitfieldManTest::testGetOffsetCompletedLength()
{
BitfieldMan bt(1024, 1024*20);
// 00000|00000|00000|00000
CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(0, 1024));
CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(0, 0));
CPPUNIT_ASSERT_EQUAL((int64_t)0, bt.getOffsetCompletedLength(0, 1024));
CPPUNIT_ASSERT_EQUAL((int64_t)0, bt.getOffsetCompletedLength(0, 0));
for(size_t i = 2; i <= 4; ++i) {
bt.setBit(i);
}
// 00111|00000|00000|00000
CPPUNIT_ASSERT_EQUAL((off_t)3072, bt.getOffsetCompletedLength(2048, 3072));
CPPUNIT_ASSERT_EQUAL((off_t)3071, bt.getOffsetCompletedLength(2047, 3072));
CPPUNIT_ASSERT_EQUAL((off_t)3071, bt.getOffsetCompletedLength(2049, 3072));
CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(2048, 0));
CPPUNIT_ASSERT_EQUAL((off_t)1, bt.getOffsetCompletedLength(2048, 1));
CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(2047, 1));
CPPUNIT_ASSERT_EQUAL((off_t)3072, bt.getOffsetCompletedLength(0, 1024*20));
CPPUNIT_ASSERT_EQUAL((off_t)3072,
CPPUNIT_ASSERT_EQUAL((int64_t)3072, bt.getOffsetCompletedLength(2048, 3072));
CPPUNIT_ASSERT_EQUAL((int64_t)3071, bt.getOffsetCompletedLength(2047, 3072));
CPPUNIT_ASSERT_EQUAL((int64_t)3071, bt.getOffsetCompletedLength(2049, 3072));
CPPUNIT_ASSERT_EQUAL((int64_t)0, bt.getOffsetCompletedLength(2048, 0));
CPPUNIT_ASSERT_EQUAL((int64_t)1, bt.getOffsetCompletedLength(2048, 1));
CPPUNIT_ASSERT_EQUAL((int64_t)0, bt.getOffsetCompletedLength(2047, 1));
CPPUNIT_ASSERT_EQUAL((int64_t)3072, bt.getOffsetCompletedLength(0, 1024*20));
CPPUNIT_ASSERT_EQUAL((int64_t)3072,
bt.getOffsetCompletedLength(0, 1024*20+10));
CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(1024*20, 1));
CPPUNIT_ASSERT_EQUAL((int64_t)0, bt.getOffsetCompletedLength(1024*20, 1));
}
void BitfieldManTest::testGetMissingUnusedLength()
{
off_t totalLength = 1024*10+10;
int64_t totalLength = 1024*10+10;
size_t blockLength = 1024;
BitfieldMan bf(blockLength, totalLength);
@ -482,30 +482,30 @@ void BitfieldManTest::testGetMissingUnusedLength()
CPPUNIT_ASSERT_EQUAL(totalLength, bf.getMissingUnusedLength(0));
// from index 10 and all blocks are unused and not acquired.
CPPUNIT_ASSERT_EQUAL((off_t)10ULL, bf.getMissingUnusedLength(10));
CPPUNIT_ASSERT_EQUAL((int64_t)10ULL, bf.getMissingUnusedLength(10));
// from index 11
CPPUNIT_ASSERT_EQUAL((off_t)0ULL, bf.getMissingUnusedLength(11));
CPPUNIT_ASSERT_EQUAL((int64_t)0ULL, bf.getMissingUnusedLength(11));
// from index 12
CPPUNIT_ASSERT_EQUAL((off_t)0ULL, bf.getMissingUnusedLength(12));
CPPUNIT_ASSERT_EQUAL((int64_t)0ULL, bf.getMissingUnusedLength(12));
// from index 0 and 5th block is used.
bf.setUseBit(5);
CPPUNIT_ASSERT_EQUAL((off_t)(5LL*blockLength), bf.getMissingUnusedLength(0));
CPPUNIT_ASSERT_EQUAL((int64_t)(5LL*blockLength), bf.getMissingUnusedLength(0));
// from index 0 and 4th block is acquired.
bf.setBit(4);
CPPUNIT_ASSERT_EQUAL((off_t)(4LL*blockLength), bf.getMissingUnusedLength(0));
CPPUNIT_ASSERT_EQUAL((int64_t)(4LL*blockLength), bf.getMissingUnusedLength(0));
// from index 1
CPPUNIT_ASSERT_EQUAL((off_t)(3LL*blockLength), bf.getMissingUnusedLength(1));
CPPUNIT_ASSERT_EQUAL((int64_t)(3LL*blockLength), bf.getMissingUnusedLength(1));
}
void BitfieldManTest::testSetBitRange()
{
size_t blockLength = 1024*1024;
off_t totalLength = 10*blockLength;
int64_t totalLength = 10*blockLength;
BitfieldMan bf(blockLength, totalLength);
@ -517,13 +517,13 @@ void BitfieldManTest::testSetBitRange()
for(size_t i = 5; i < 10; ++i) {
CPPUNIT_ASSERT(!bf.isBitSet(i));
}
CPPUNIT_ASSERT_EQUAL((off_t)(5LL*blockLength), bf.getCompletedLength());
CPPUNIT_ASSERT_EQUAL((int64_t)(5LL*blockLength), bf.getCompletedLength());
}
void BitfieldManTest::testGetAllMissingIndexes_noarg()
{
size_t blockLength = 16*1024;
off_t totalLength = 1024*1024;
int64_t totalLength = 1024*1024;
size_t nbits = (totalLength+blockLength-1)/blockLength;
BitfieldMan bf(blockLength, totalLength);
unsigned char misbitfield[8];
@ -542,7 +542,7 @@ void BitfieldManTest::testGetAllMissingIndexes_noarg()
void BitfieldManTest::testGetAllMissingIndexes_checkLastByte()
{
size_t blockLength = 16*1024;
off_t totalLength = blockLength*2;
int64_t totalLength = blockLength*2;
size_t nbits = (totalLength+blockLength-1)/blockLength;
BitfieldMan bf(blockLength, totalLength);
unsigned char misbitfield[1];
@ -555,7 +555,7 @@ void BitfieldManTest::testGetAllMissingIndexes_checkLastByte()
void BitfieldManTest::testGetAllMissingIndexes()
{
size_t blockLength = 16*1024;
off_t totalLength = 1024*1024;
int64_t totalLength = 1024*1024;
size_t nbits = (totalLength+blockLength-1)/blockLength;
BitfieldMan bf(blockLength, totalLength);
BitfieldMan peerBf(blockLength, totalLength);
@ -581,7 +581,7 @@ void BitfieldManTest::testGetAllMissingIndexes()
void BitfieldManTest::testGetAllMissingUnusedIndexes()
{
size_t blockLength = 16*1024;
off_t totalLength = 1024*1024;
int64_t totalLength = 1024*1024;
size_t nbits = (totalLength+blockLength-1)/blockLength;
BitfieldMan bf(blockLength, totalLength);
BitfieldMan peerBf(blockLength, totalLength);

4
test/BittorrentHelperTest.cc
View File

@ -205,14 +205,14 @@ void BittorrentHelperTest::testGetTotalLength() {
SharedHandle<DownloadContext> dctx(new DownloadContext());
load(A2_TEST_DIR"/test.torrent", dctx, option_);
CPPUNIT_ASSERT_EQUAL((off_t)384LL, dctx->getTotalLength());
CPPUNIT_ASSERT_EQUAL((int64_t)384LL, dctx->getTotalLength());
}
void BittorrentHelperTest::testGetTotalLengthSingle() {
SharedHandle<DownloadContext> dctx(new DownloadContext());
load(A2_TEST_DIR"/single.torrent", dctx, option_);
CPPUNIT_ASSERT_EQUAL((off_t)384LL, dctx->getTotalLength());
CPPUNIT_ASSERT_EQUAL((int64_t)384LL, dctx->getTotalLength());
}
void BittorrentHelperTest::testGetFileModeMulti() {

14
test/DefaultBtProgressInfoFileTest.cc
View File

@ -53,7 +53,7 @@ private:
SharedHandle<Option> option_;
SharedHandle<BitfieldMan> bitfield_;
public:
void initializeMembers(int32_t pieceLength, off_t totalLength)
void initializeMembers(int32_t pieceLength, int64_t totalLength)
{
option_.reset(new Option());
option_->put(PREF_DIR, A2_TEST_OUT_DIR);
@ -126,10 +126,10 @@ void DefaultBtProgressInfoFileTest::testLoad_compat()
// check the contents of objects
// total length
CPPUNIT_ASSERT_EQUAL((off_t)81920, dctx_->getTotalLength());
CPPUNIT_ASSERT_EQUAL((int64_t)81920, dctx_->getTotalLength());
// upload length
CPPUNIT_ASSERT_EQUAL((off_t)1024, btRuntime_->getUploadLengthAtStartup());
CPPUNIT_ASSERT_EQUAL((int64_t)1024, btRuntime_->getUploadLengthAtStartup());
// bitfield
CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
@ -175,10 +175,10 @@ void DefaultBtProgressInfoFileTest::testLoad()
// check the contents of objects
// total length
CPPUNIT_ASSERT_EQUAL((off_t)81920, dctx_->getTotalLength());
CPPUNIT_ASSERT_EQUAL((int64_t)81920, dctx_->getTotalLength());
// upload length
CPPUNIT_ASSERT_EQUAL((off_t)1024, btRuntime_->getUploadLengthAtStartup());
CPPUNIT_ASSERT_EQUAL((int64_t)1024, btRuntime_->getUploadLengthAtStartup());
// bitfield
CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
@ -343,7 +343,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_compat()
// check the contents of objects
// total length
CPPUNIT_ASSERT_EQUAL((off_t)81920, dctx->getTotalLength());
CPPUNIT_ASSERT_EQUAL((int64_t)81920, dctx->getTotalLength());
// bitfield
CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
@ -388,7 +388,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt()
// check the contents of objects
// total length
CPPUNIT_ASSERT_EQUAL((off_t)81920, dctx->getTotalLength());
CPPUNIT_ASSERT_EQUAL((int64_t)81920, dctx->getTotalLength());
// bitfield
CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),

24
test/DefaultPieceStorageTest.cc
View File

@ -80,7 +80,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DefaultPieceStorageTest);
void DefaultPieceStorageTest::testGetTotalLength() {
DefaultPieceStorage pss(dctx_, option_.get());
CPPUNIT_ASSERT_EQUAL((off_t)384LL, pss.getTotalLength());
CPPUNIT_ASSERT_EQUAL((int64_t)384LL, pss.getTotalLength());
}
void DefaultPieceStorageTest::testGetMissingPiece() {
@ -220,15 +220,15 @@ void DefaultPieceStorageTest::testCompletePiece() {
CPPUNIT_ASSERT_EQUAL(std::string("piece: index=0, length=128"),
piece->toString());
CPPUNIT_ASSERT_EQUAL((off_t)0LL, pss.getCompletedLength());
CPPUNIT_ASSERT_EQUAL((int64_t)0LL, pss.getCompletedLength());
pss.completePiece(piece);
CPPUNIT_ASSERT_EQUAL((off_t)128LL, pss.getCompletedLength());
CPPUNIT_ASSERT_EQUAL((int64_t)128LL, pss.getCompletedLength());
SharedHandle<Piece> incompletePiece = pss.getMissingPiece(peer, 1);
incompletePiece->completeBlock(0);
CPPUNIT_ASSERT_EQUAL((off_t)256LL, pss.getCompletedLength());
CPPUNIT_ASSERT_EQUAL((int64_t)256LL, pss.getCompletedLength());
}
void DefaultPieceStorageTest::testGetPiece() {
@ -264,7 +264,7 @@ void DefaultPieceStorageTest::testGetPieceCompletedPiece() {
void DefaultPieceStorageTest::testCancelPiece()
{
size_t pieceLength = 256*1024;
off_t totalLength = 32*pieceLength; // <-- make the number of piece greater than END_GAME_PIECE_NUM
int64_t totalLength = 32*pieceLength; // <-- make the number of piece greater than END_GAME_PIECE_NUM
std::deque<std::string> uris1;
uris1.push_back("http://localhost/src/file1.txt");
SharedHandle<FileEntry> file1(new FileEntry("src/file1.txt", totalLength, 0 /*, uris1*/));
@ -289,7 +289,7 @@ void DefaultPieceStorageTest::testCancelPiece()
void DefaultPieceStorageTest::testMarkPiecesDone()
{
size_t pieceLength = 256*1024;
off_t totalLength = 4*1024*1024;
int64_t totalLength = 4*1024*1024;
SharedHandle<DownloadContext> dctx
(new DownloadContext(pieceLength, totalLength));
@ -303,7 +303,7 @@ void DefaultPieceStorageTest::testMarkPiecesDone()
for(size_t i = 10; i < (totalLength+pieceLength-1)/pieceLength; ++i) {
CPPUNIT_ASSERT(!ps.hasPiece(i));
}
CPPUNIT_ASSERT_EQUAL((off_t)pieceLength*10+16*1024*2, ps.getCompletedLength());
CPPUNIT_ASSERT_EQUAL((int64_t)pieceLength*10+16*1024*2, ps.getCompletedLength());
ps.markPiecesDone(totalLength);
@ -312,7 +312,7 @@ void DefaultPieceStorageTest::testMarkPiecesDone()
}
ps.markPiecesDone(0);
CPPUNIT_ASSERT_EQUAL((off_t)0, ps.getCompletedLength());
CPPUNIT_ASSERT_EQUAL((int64_t)0, ps.getCompletedLength());
}
void DefaultPieceStorageTest::testGetCompletedLength()
@ -322,10 +322,10 @@ void DefaultPieceStorageTest::testGetCompletedLength()
DefaultPieceStorage ps(dctx, option_.get());
CPPUNIT_ASSERT_EQUAL((off_t)0, ps.getCompletedLength());
CPPUNIT_ASSERT_EQUAL((int64_t)0, ps.getCompletedLength());
ps.markPiecesDone(250*1024*1024);
CPPUNIT_ASSERT_EQUAL((off_t)250*1024*1024, ps.getCompletedLength());
CPPUNIT_ASSERT_EQUAL((int64_t)250*1024*1024, ps.getCompletedLength());
std::vector<SharedHandle<Piece> > inFlightPieces;
for(int i = 0; i < 2; ++i) {
@ -338,11 +338,11 @@ void DefaultPieceStorageTest::testGetCompletedLength()
}
ps.addInFlightPiece(inFlightPieces);
CPPUNIT_ASSERT_EQUAL((off_t)251*1024*1024, ps.getCompletedLength());
CPPUNIT_ASSERT_EQUAL((int64_t)251*1024*1024, ps.getCompletedLength());
ps.markPiecesDone(256*1024*1024);
CPPUNIT_ASSERT_EQUAL((off_t)256*1024*1024, ps.getCompletedLength());
CPPUNIT_ASSERT_EQUAL((int64_t)256*1024*1024, ps.getCompletedLength());
}
void DefaultPieceStorageTest::testGetNextUsedIndex()

2
test/DirectDiskAdaptorTest.cc
View File

@ -46,7 +46,7 @@ void DirectDiskAdaptorTest::testCutTrailingGarbage()
adaptor.cutTrailingGarbage();
CPPUNIT_ASSERT_EQUAL((off_t)entry->getLength(),
CPPUNIT_ASSERT_EQUAL((int64_t)entry->getLength(),
File(entry->getPath()).size());
}

4
test/FallocFileAllocationIteratorTest.cc
View File

@ -35,7 +35,7 @@ void FallocFileAllocationIteratorTest::testAllocate()
of.close();
File f(fn);
CPPUNIT_ASSERT_EQUAL((off_t)10, f.size());
CPPUNIT_ASSERT_EQUAL((int64_t)10, f.size());
DefaultDiskWriter writer(fn);
int64_t offset = 10;
@ -48,7 +48,7 @@ void FallocFileAllocationIteratorTest::testAllocate()
itr.allocateChunk();
CPPUNIT_ASSERT(itr.finished());
CPPUNIT_ASSERT_EQUAL((off_t)40960, f.size());
CPPUNIT_ASSERT_EQUAL((int64_t)40960, f.size());
#endif // !HAVE_FALLOCATE
}

4
test/FtpConnectionTest.cc
View File

@ -287,9 +287,9 @@ void FtpConnectionTest::testReceiveSizeResponse()
{
serverSocket_->writeData("213 4294967296\r\n");
waitRead(clientSocket_);
off_t size;
int64_t size;
CPPUNIT_ASSERT_EQUAL(213, ftp_->receiveSizeResponse(size));
CPPUNIT_ASSERT_EQUAL((off_t)4294967296LL, size);
CPPUNIT_ASSERT_EQUAL((int64_t)4294967296LL, size);
}
void FtpConnectionTest::testSendRetr()

4
test/GZipDecodingStreamFilterTest.cc
View File

@ -26,7 +26,7 @@ class GZipDecodingStreamFilterTest:public CppUnit::TestFixture {
class MockSegment2:public MockSegment {
private:
off_t positionToWrite_;
int64_t positionToWrite_;
public:
MockSegment2():positionToWrite_(0) {}
@ -35,7 +35,7 @@ class GZipDecodingStreamFilterTest:public CppUnit::TestFixture {
positionToWrite_ += bytes;
}
virtual off_t getPositionToWrite() const
virtual int64_t getPositionToWrite() const
{
return positionToWrite_;
}

2
test/GrowSegmentTest.cc
View File

@ -27,7 +27,7 @@ void GrowSegmentTest::testUpdateWrittenLength()
GrowSegment segment(SharedHandle<Piece>(new Piece()));
segment.updateWrittenLength(32*1024);
CPPUNIT_ASSERT_EQUAL((off_t)32*1024, segment.getPositionToWrite());
CPPUNIT_ASSERT_EQUAL((int64_t)32*1024, segment.getPositionToWrite());
CPPUNIT_ASSERT(!segment.complete());
CPPUNIT_ASSERT(segment.getPiece()->pieceComplete());
}

2
test/HandshakeExtensionMessageTest.cc
View File

@ -119,7 +119,7 @@ void HandshakeExtensionMessageTest::testDoReceivedAction()
CPPUNIT_ASSERT_EQUAL((uint8_t)2, peer->getExtensionMessageID("a2_dht"));
CPPUNIT_ASSERT(peer->isSeeder());
CPPUNIT_ASSERT_EQUAL((size_t)1024, attrs->metadataSize);
CPPUNIT_ASSERT_EQUAL((off_t)1024, dctx->getTotalLength());
CPPUNIT_ASSERT_EQUAL((int64_t)1024, dctx->getTotalLength());
CPPUNIT_ASSERT(dctx->knowsTotalLength());
// See Peer is not marked as seeder if !attrs->metadata.empty()

42
test/HttpHeaderTest.cc
View File

@ -34,9 +34,9 @@ void HttpHeaderTest::testGetRange()
SharedHandle<Range> range = httpHeader.getRange();
CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775800LL, range->getStartByte());
CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775801LL, range->getEndByte());
CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775807LL, range->getEntityLength());
CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775800LL, range->getStartByte());
CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775801LL, range->getEndByte());
CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775807LL, range->getEntityLength());
}
{
HttpHeader httpHeader;
@ -45,9 +45,9 @@ void HttpHeaderTest::testGetRange()
SharedHandle<Range> range = httpHeader.getRange();
CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775800LL, range->getStartByte());
CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775801LL, range->getEndByte());
CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775807LL, range->getEntityLength());
CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775800LL, range->getStartByte());
CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775801LL, range->getEndByte());
CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775807LL, range->getEntityLength());
}
{
HttpHeader httpHeader;
@ -55,9 +55,9 @@ void HttpHeaderTest::testGetRange()
SharedHandle<Range> range = httpHeader.getRange();
CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte());
CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte());
CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength());
CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getStartByte());
CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEndByte());
CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEntityLength());
}
{
HttpHeader httpHeader;
@ -65,9 +65,9 @@ void HttpHeaderTest::testGetRange()
SharedHandle<Range> range = httpHeader.getRange();
CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte());
CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte());
CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength());
CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getStartByte());
CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEndByte());
CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEntityLength());
}
{
HttpHeader httpHeader;
@ -75,9 +75,9 @@ void HttpHeaderTest::testGetRange()
SharedHandle<Range> range = httpHeader.getRange();
CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte());
CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte());
CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength());
CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getStartByte());
CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEndByte());
CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEntityLength());
}
{
HttpHeader httpHeader;
@ -85,9 +85,9 @@ void HttpHeaderTest::testGetRange()
SharedHandle<Range> range = httpHeader.getRange();
CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte());
CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte());
CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength());
CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getStartByte());
CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEndByte());
CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEntityLength());
}
{
HttpHeader httpHeader;
@ -95,9 +95,9 @@ void HttpHeaderTest::testGetRange()
SharedHandle<Range> range = httpHeader.getRange();
CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte());
CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte());
CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength());
CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getStartByte());
CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEndByte());
CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEntityLength());
}
{
HttpHeader httpHeader;

14
test/HttpRequestTest.cc
View File

@ -78,12 +78,12 @@ void HttpRequestTest::testGetStartByte()
SharedHandle<Segment> segment(new PiecedSegment(1024, p));
SharedHandle<FileEntry> fileEntry(new FileEntry("file", 1024*10, 0));
CPPUNIT_ASSERT_EQUAL((off_t)0LL, httpRequest.getStartByte());
CPPUNIT_ASSERT_EQUAL((int64_t)0LL, httpRequest.getStartByte());
httpRequest.setSegment(segment);
httpRequest.setFileEntry(fileEntry);
CPPUNIT_ASSERT_EQUAL((off_t)1024LL, httpRequest.getStartByte());
CPPUNIT_ASSERT_EQUAL((int64_t)1024LL, httpRequest.getStartByte());
}
void HttpRequestTest::testGetEndByte()
@ -97,11 +97,11 @@ void HttpRequestTest::testGetEndByte()
SharedHandle<Segment> segment(new PiecedSegment(segmentLength, piece));
SharedHandle<FileEntry> fileEntry(new FileEntry("file", segmentLength*10, 0));
CPPUNIT_ASSERT_EQUAL((off_t)0LL, httpRequest.getEndByte());
CPPUNIT_ASSERT_EQUAL((int64_t)0LL, httpRequest.getEndByte());
httpRequest.setSegment(segment);
CPPUNIT_ASSERT_EQUAL((off_t)0LL, httpRequest.getEndByte());
CPPUNIT_ASSERT_EQUAL((int64_t)0LL, httpRequest.getEndByte());
SharedHandle<Request> request(new Request());
request->supportsPersistentConnection(true);
@ -110,18 +110,18 @@ void HttpRequestTest::testGetEndByte()
httpRequest.setRequest(request);
httpRequest.setFileEntry(fileEntry);
CPPUNIT_ASSERT_EQUAL((off_t)(segmentLength*index+length-1),
CPPUNIT_ASSERT_EQUAL((int64_t)(segmentLength*index+length-1),
httpRequest.getEndByte());
// The end byte of FileEntry are placed inside segment
fileEntry->setLength(segmentLength+100);
CPPUNIT_ASSERT_EQUAL((off_t)(segmentLength*index+100-1),
CPPUNIT_ASSERT_EQUAL((int64_t)(segmentLength*index+100-1),
httpRequest.getEndByte());
request->setPipeliningHint(false);
CPPUNIT_ASSERT_EQUAL((off_t)0LL, httpRequest.getEndByte());
CPPUNIT_ASSERT_EQUAL((int64_t)0LL, httpRequest.getEndByte());
}
void HttpRequestTest::testCreateRequest()

8
test/HttpResponseTest.cc
View File

@ -101,7 +101,7 @@ void HttpResponseTest::testGetContentLength_null()
{
HttpResponse httpResponse;
CPPUNIT_ASSERT_EQUAL((off_t)0LL, httpResponse.getContentLength());
CPPUNIT_ASSERT_EQUAL((int64_t)0LL, httpResponse.getContentLength());
}
void HttpResponseTest::testGetContentLength_contentLength()
@ -113,7 +113,7 @@ void HttpResponseTest::testGetContentLength_contentLength()
httpResponse.setHttpHeader(httpHeader);
CPPUNIT_ASSERT_EQUAL((off_t)4294967296LL, httpResponse.getContentLength());
CPPUNIT_ASSERT_EQUAL((int64_t)4294967296LL, httpResponse.getContentLength());
}
void HttpResponseTest::testGetEntityLength()
@ -125,11 +125,11 @@ void HttpResponseTest::testGetEntityLength()
httpResponse.setHttpHeader(httpHeader);
CPPUNIT_ASSERT_EQUAL((off_t)4294967296LL, httpResponse.getEntityLength());
CPPUNIT_ASSERT_EQUAL((int64_t)4294967296LL, httpResponse.getEntityLength());
httpHeader->put("content-range", "bytes 1-4294967296/4294967297");
CPPUNIT_ASSERT_EQUAL((off_t)4294967297LL, httpResponse.getEntityLength());
CPPUNIT_ASSERT_EQUAL((int64_t)4294967297LL, httpResponse.getEntityLength());
}

2
test/Metalink2RequestGroupTest.cc
View File

@ -58,7 +58,7 @@ void Metalink2RequestGroupTest::testGenerate()
const SharedHandle<DownloadContext>& dctx = rg->getDownloadContext();
CPPUNIT_ASSERT(dctx);
CPPUNIT_ASSERT_EQUAL((off_t)0LL, dctx->getTotalLength());
CPPUNIT_ASSERT_EQUAL((int64_t)0LL, dctx->getTotalLength());
#ifdef ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), dctx->getHashType());
CPPUNIT_ASSERT_EQUAL

4
test/MetalinkParserControllerTest.cc
View File

@ -68,8 +68,8 @@ void MetalinkParserControllerTest::testEntryTransaction()
CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size());
SharedHandle<MetalinkEntry> e = m->getEntries().front();
CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), e->file->getPath());
CPPUNIT_ASSERT_EQUAL((off_t)(1024*1024LL), e->file->getLength());
CPPUNIT_ASSERT_EQUAL((off_t)0, e->file->getOffset());
CPPUNIT_ASSERT_EQUAL((int64_t)(1024*1024LL), e->file->getLength());
CPPUNIT_ASSERT_EQUAL((int64_t)0, e->file->getOffset());
CPPUNIT_ASSERT_EQUAL(std::string("1.0"), e->version);
CPPUNIT_ASSERT_EQUAL(std::string("ja_JP"), e->languages[0]);
CPPUNIT_ASSERT_EQUAL(std::string("Linux"), e->oses[0]);

14
test/MetalinkProcessorTest.cc
View File

@ -89,7 +89,7 @@ void MetalinkProcessorTest::testParseFileV4()
CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size());
e = m->getEntries()[0];
CPPUNIT_ASSERT_EQUAL(std::string("example.ext"), e->getPath());
CPPUNIT_ASSERT_EQUAL((off_t)786430LL, e->getLength());
CPPUNIT_ASSERT_EQUAL((int64_t)786430LL, e->getLength());
CPPUNIT_ASSERT_EQUAL(-1, e->maxConnections);
#ifdef ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT_EQUAL(std::string("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"),
@ -500,7 +500,7 @@ void MetalinkProcessorTest::testParseFile()
SharedHandle<MetalinkEntry> entry1 = *entryItr;
CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), entry1->getPath());
CPPUNIT_ASSERT_EQUAL((off_t)0LL, entry1->getLength());
CPPUNIT_ASSERT_EQUAL((int64_t)0LL, entry1->getLength());
CPPUNIT_ASSERT_EQUAL(std::string("0.5.2"), entry1->version);
CPPUNIT_ASSERT_EQUAL(std::string("en-US"), entry1->languages[0]);
CPPUNIT_ASSERT_EQUAL(std::string("Linux-x86"), entry1->oses[0]);
@ -550,7 +550,7 @@ void MetalinkProcessorTest::testParseFile()
SharedHandle<MetalinkEntry> entry2 = *entryItr;
CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.1.tar.bz2"), entry2->getPath());
CPPUNIT_ASSERT_EQUAL((off_t)345689LL, entry2->getLength());
CPPUNIT_ASSERT_EQUAL((int64_t)345689LL, entry2->getLength());
CPPUNIT_ASSERT_EQUAL(std::string("0.5.1"), entry2->version);
CPPUNIT_ASSERT_EQUAL(std::string("ja-JP"), entry2->languages[0]);
CPPUNIT_ASSERT_EQUAL(std::string("Linux-m68k"), entry2->oses[0]);
@ -697,7 +697,7 @@ void MetalinkProcessorTest::testBadSize()
m->getEntries().begin();
SharedHandle<MetalinkEntry> e = *entryItr;
CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), e->getPath());
CPPUNIT_ASSERT_EQUAL((off_t)0LL, e->getLength());
CPPUNIT_ASSERT_EQUAL((int64_t)0LL, e->getLength());
CPPUNIT_ASSERT_EQUAL(std::string("0.5.2"), e->version);
CPPUNIT_ASSERT_EQUAL(std::string("en-US"), e->languages[0]);
CPPUNIT_ASSERT_EQUAL(std::string("Linux-x86"), e->oses[0]);
@ -728,7 +728,7 @@ void MetalinkProcessorTest::testBadMaxConn()
std::vector<SharedHandle<MetalinkEntry> >::const_iterator entryItr =
m->getEntries().begin();
SharedHandle<MetalinkEntry> e = *entryItr;
CPPUNIT_ASSERT_EQUAL((off_t)43743838LL, e->getLength());
CPPUNIT_ASSERT_EQUAL((int64_t)43743838LL, e->getLength());
} catch(Exception& e) {
CPPUNIT_FAIL(e.stackTrace());
}
@ -1008,7 +1008,7 @@ void MetalinkProcessorTest::testLargeFileSize()
try {
SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
SharedHandle<MetalinkEntry> e = m->getEntries()[0];
CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775807LL, e->getLength());
CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775807LL, e->getLength());
} catch(Exception& e) {
CPPUNIT_FAIL(e.stackTrace());
}
@ -1032,7 +1032,7 @@ void MetalinkProcessorTest::testXmlPrefixV3()
SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw);
CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size());
SharedHandle<MetalinkEntry> e = m->getEntries()[0];
CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775807LL, e->getLength());
CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775807LL, e->getLength());
} catch(Exception& e) {
CPPUNIT_FAIL(e.stackTrace());
}

26
test/MockPieceStorage.h
View File

@ -13,10 +13,10 @@ namespace aria2 {
class MockPieceStorage : public PieceStorage {
private:
off_t totalLength;
off_t filteredTotalLength;
off_t completedLength;
off_t filteredCompletedLength;
int64_t totalLength;
int64_t filteredTotalLength;
int64_t completedLength;
int64_t filteredCompletedLength;
BitfieldMan* bitfieldMan;
bool selectiveDownloadingMode;
bool endGame;
@ -117,7 +117,7 @@ public:
virtual void markPieceMissing(size_t index) {}
virtual void markPiecesDone(off_t) {}
virtual void markPiecesDone(int64_t) {}
virtual SharedHandle<Piece> getPiece(size_t index) {
return SharedHandle<Piece>(new Piece());
@ -131,35 +131,35 @@ public:
return false;
}
virtual off_t getTotalLength() {
virtual int64_t getTotalLength() {
return totalLength;
}
void setTotalLength(off_t totalLength) {
void setTotalLength(int64_t totalLength) {
this->totalLength = totalLength;
}
virtual off_t getFilteredTotalLength() {
virtual int64_t getFilteredTotalLength() {
return filteredTotalLength;
}
void setFilteredTotalLength(off_t totalLength) {
void setFilteredTotalLength(int64_t totalLength) {
this->filteredTotalLength = totalLength;
}
virtual off_t getCompletedLength() {
virtual int64_t getCompletedLength() {
return completedLength;
}
void setCompletedLength(off_t completedLength) {
void setCompletedLength(int64_t completedLength) {
this->completedLength = completedLength;
}
virtual off_t getFilteredCompletedLength() {
virtual int64_t getFilteredCompletedLength() {
return filteredCompletedLength;
}
void setFilteredCompletedLength(off_t completedLength) {
void setFilteredCompletedLength(int64_t completedLength) {
this->filteredCompletedLength = completedLength;
}

4
test/MockSegment.h
View File

@ -19,12 +19,12 @@ public:
return 0;
}
virtual off_t getPosition() const
virtual int64_t getPosition() const
{
return 0;
}
virtual off_t getPositionToWrite() const
virtual int64_t getPositionToWrite() const
{
return 0;
}

4
test/MultiDiskAdaptorTest.cc
View File

@ -386,9 +386,9 @@ void MultiDiskAdaptorTest::testCutTrailingGarbage()
adaptor.cutTrailingGarbage();
CPPUNIT_ASSERT_EQUAL((off_t)256,
CPPUNIT_ASSERT_EQUAL((int64_t)256,
File(entries[0]->getPath()).size());
CPPUNIT_ASSERT_EQUAL((off_t)512,
CPPUNIT_ASSERT_EQUAL((int64_t)512,
File(entries[1]->getPath()).size());
}

8
test/MultiFileAllocationIteratorTest.cc
View File

@ -209,11 +209,11 @@ void MultiFileAllocationIteratorTest::testAllocate()
while(!itr->finished()) {
itr->allocateChunk();
}
CPPUNIT_ASSERT_EQUAL((off_t)length1, File(fileEntry1->getPath()).size());
CPPUNIT_ASSERT_EQUAL((off_t)length2, File(fileEntry2->getPath()).size());
CPPUNIT_ASSERT_EQUAL((off_t)length3, File(fileEntry3->getPath()).size());
CPPUNIT_ASSERT_EQUAL((int64_t)length1, File(fileEntry1->getPath()).size());
CPPUNIT_ASSERT_EQUAL((int64_t)length2, File(fileEntry2->getPath()).size());
CPPUNIT_ASSERT_EQUAL((int64_t)length3, File(fileEntry3->getPath()).size());
CPPUNIT_ASSERT(!File(fileEntry4->getPath()).isFile());
CPPUNIT_ASSERT_EQUAL((off_t)length5, File(fileEntry5->getPath()).size());
CPPUNIT_ASSERT_EQUAL((int64_t)length5, File(fileEntry5->getPath()).size());
CPPUNIT_ASSERT(!File(fileEntry6->getPath()).isFile());
} catch(Exception& e) {
CPPUNIT_FAIL(e.stackTrace());

8
test/PeerSessionResourceTest.cc
View File

@ -106,20 +106,20 @@ void PeerSessionResourceTest::testUpdateUploadLength()
{
PeerSessionResource res(1024, 1024*1024);
CPPUNIT_ASSERT_EQUAL((off_t)0LL, res.uploadLength());
CPPUNIT_ASSERT_EQUAL((int64_t)0LL, res.uploadLength());
res.updateUploadLength(100);
res.updateUploadLength(200);
CPPUNIT_ASSERT_EQUAL((off_t)300LL, res.uploadLength());
CPPUNIT_ASSERT_EQUAL((int64_t)300LL, res.uploadLength());
}
void PeerSessionResourceTest::testUpdateDownloadLength()
{
PeerSessionResource res(1024, 1024*1024);
CPPUNIT_ASSERT_EQUAL((off_t)0LL, res.downloadLength());
CPPUNIT_ASSERT_EQUAL((int64_t)0LL, res.downloadLength());
res.updateDownloadLength(100);
res.updateDownloadLength(200);
CPPUNIT_ASSERT_EQUAL((off_t)300LL, res.downloadLength());
CPPUNIT_ASSERT_EQUAL((int64_t)300LL, res.downloadLength());
}
void PeerSessionResourceTest::testExtendedMessageEnabled()

2
test/RequestGroupTest.cc
View File

@ -58,7 +58,7 @@ void RequestGroupTest::testCreateDownloadResult()
CPPUNIT_ASSERT_EQUAL(std::string("/tmp/myfile"),
result->fileEntries[0]->getPath());
CPPUNIT_ASSERT_EQUAL((off_t)1024*1024,
CPPUNIT_ASSERT_EQUAL((int64_t)1024*1024,
result->fileEntries.back()->getLastOffset());
CPPUNIT_ASSERT_EQUAL((uint64_t)0, result->sessionDownloadLength);
CPPUNIT_ASSERT_EQUAL((int64_t)0, result->sessionTime);

4
test/SingleFileAllocationIteratorTest.cc
View File

@ -32,7 +32,7 @@ void SingleFileAllocationIteratorTest::testAllocate()
of.close();
File x(fn);
CPPUNIT_ASSERT_EQUAL((off_t)10, x.size());
CPPUNIT_ASSERT_EQUAL((int64_t)10, x.size());
DefaultDiskWriter writer(fn);
off_t offset = 10;
@ -47,7 +47,7 @@ void SingleFileAllocationIteratorTest::testAllocate()
itr.allocateChunk();
}
File f(fn);
CPPUNIT_ASSERT_EQUAL((off_t)40960, f.size());
CPPUNIT_ASSERT_EQUAL((int64_t)40960, f.size());
}
} // namespace aria2