2008-03-08 Tatsuhiro Tsujikawa <tujikawa at rednoah dot com>

	Type clarification: size_t for length or size, uint64_t for file
	length, off_t for file offset.

	* src/PiecedSegment.cc
	* src/GrowSegment.h
	* src/DefaultBtRequestFactory.h
	* src/DefaultBtProgressInfoFile.cc
	* src/UnknownLengthPieceStorage.h
	* src/DefaultPieceStorage.cc
	* src/UnknownLengthPieceStorage.cc
	* src/DefaultBtInteractive.cc
	* src/GrowSegment.cc
	* src/BitfieldMan.h
	* src/DownloadCommand.cc
	* src/BtRequestFactory.h
	* src/PiecedSegment.h
	* src/DefaultPieceStorage.h
	* src/Piece.cc
	* src/DefaultBtRequestFactory.cc
	* src/PieceStorage.h
	* src/Segment.h
	* src/Piece.h
	* src/BitfieldMan.cc
	* src/Util.cc
	* test/DefaultBtProgressInfoFileTest.cc
	* test/DefaultPieceStorageTest.cc
	* test/MockPieceStorage.h
	* test/BtRequestMessageTest.cc
	* test/DefaultBtMessageDispatcherTest.cc
	* test/BitfieldManTest.cc
	* test/GrowSegmentTest.cc
	* test/PieceTest.cc
	* test/SegmentTest.cc
	* test/SegmentManTest.cc
	* test/DefaultBtRequestFactoryTest.cc
	* test/MockBtRequestFactory.h

ChangeLog

@@ -1,3 +1,42 @@
+2008-03-08  Tatsuhiro Tsujikawa  <tujikawa at rednoah dot com>
+
+	Type clarification: size_t for length or size, uint64_t for file
+	length, off_t for file offset.
+
+	* src/PiecedSegment.cc
+	* src/GrowSegment.h
+	* src/DefaultBtRequestFactory.h
+	* src/DefaultBtProgressInfoFile.cc
+	* src/UnknownLengthPieceStorage.h
+	* src/DefaultPieceStorage.cc
+	* src/UnknownLengthPieceStorage.cc
+	* src/DefaultBtInteractive.cc
+	* src/GrowSegment.cc
+	* src/BitfieldMan.h
+	* src/DownloadCommand.cc
+	* src/BtRequestFactory.h
+	* src/PiecedSegment.h
+	* src/DefaultPieceStorage.h
+	* src/Piece.cc
+	* src/DefaultBtRequestFactory.cc
+	* src/PieceStorage.h
+	* src/Segment.h
+	* src/Piece.h
+	* src/BitfieldMan.cc
+	* src/Util.cc
+	* test/DefaultBtProgressInfoFileTest.cc
+	* test/DefaultPieceStorageTest.cc
+	* test/MockPieceStorage.h
+	* test/BtRequestMessageTest.cc
+	* test/DefaultBtMessageDispatcherTest.cc
+	* test/BitfieldManTest.cc
+	* test/GrowSegmentTest.cc
+	* test/PieceTest.cc
+	* test/SegmentTest.cc
+	* test/SegmentManTest.cc
+	* test/DefaultBtRequestFactoryTest.cc
+	* test/MockBtRequestFactory.h
+
 2008-03-08  Tatsuhiro Tsujikawa  <tujikawa at rednoah dot com>
 
 	Fixed compilation error with --disable-nls

src/BitfieldMan.cc

@@ -40,7 +40,7 @@
 
 namespace aria2 {
 
-BitfieldMan::BitfieldMan(int32_t blockLength, int64_t totalLength)
+BitfieldMan::BitfieldMan(size_t blockLength, uint64_t totalLength)
   :blockLength(blockLength),
    totalLength(totalLength),
    bitfield(0),
@@ -138,42 +138,45 @@ BitfieldMan::~BitfieldMan() {
   delete [] filterBitfield;
 }
 
-int32_t BitfieldMan::getBlockLength() const
+size_t BitfieldMan::getBlockLength() const
 {
   return blockLength;
 }
 
-int32_t BitfieldMan::getLastBlockLength() const
+size_t BitfieldMan::getLastBlockLength() const
 {
   return totalLength-blockLength*(blocks-1);
 }
 
-int32_t BitfieldMan::getBlockLength(int32_t index) const
+size_t BitfieldMan::getBlockLength(size_t index) const
 {
   if(index == blocks-1) {
     return getLastBlockLength();
-  } else if(0 <= index && index < blocks-1) {
+  } else if(index < blocks-1) {
     return getBlockLength();
   } else {
     return 0;
   }
 }
 
-int32_t BitfieldMan::countSetBit(const unsigned char* bitfield, int32_t len) const {
-  int32_t count = 0;
-  int32_t size = sizeof(int32_t);
-  for(int32_t i = 0; i < len/size; ++i) {
-    count += Util::countBit(*(uint32_t*)&bitfield[i*size]);
+size_t BitfieldMan::countSetBit(const unsigned char* bitfield, size_t len) const {
+  size_t count = 0;
+  size_t size = sizeof(uint32_t);
+  size_t to = len/size;
+  for(size_t i = 0; i < to; ++i) {
+    count += Util::countBit(*reinterpret_cast<const uint32_t*>(&bitfield[i*size]));
   }
-  for(int32_t i = len-len%size; i < len; i++) {
-    count += Util::countBit((uint32_t)bitfield[i]);
+  for(size_t i = len-len%size; i < len; i++) {
+    count += Util::countBit(static_cast<uint32_t>(bitfield[i]));
   }
   return count;
 }
 
-int32_t BitfieldMan::getNthBitIndex(const unsigned char bitfield, int32_t nth) const {
-  int32_t index = -1;
-  for(int bs = 7; bs >= 0; bs--) {
+size_t
+BitfieldMan::getNthBitIndex(const unsigned char bitfield, size_t nth) const
+{
+  size_t index = 0;
+  for(size_t bs = 7; bs >= 0; bs--) {
     unsigned char mask = 1 << bs;
     if(bitfield & mask) {
       nth--;
@@ -187,27 +190,22 @@ int32_t BitfieldMan::getNthBitIndex(const unsigned char bitfield, int32_t nth) c
 }
 
 template<typename Array>
-int32_t
-BitfieldMan::getMissingIndexRandomly(const Array& bitfield,
-				     int32_t bitfieldLength) const
+bool BitfieldMan::getMissingIndexRandomly(size_t& index,
+					  const Array& bitfield,
+					  size_t bitfieldLength) const
 {
-  /*
-  int32_t byte = (int32_t)(((double)bitfieldLength)*
-			   randomizer->getRandomNumber()/
-			   (randomizer->getMaxRandomNumber()+1.0));
-  */
-  int32_t byte = randomizer->getRandomNumber(bitfieldLength);
+  size_t byte = randomizer->getRandomNumber(bitfieldLength);
 
   unsigned char lastMask = 0;
   // the number of bytes in the last byte of bitfield
-  int32_t lastByteLength = totalLength%(blockLength*8);
+  size_t lastByteLength = totalLength%(blockLength*8);
   // the number of block in the last byte of bitfield
-  int32_t lastBlockCount = DIV_FLOOR(lastByteLength, blockLength);
-  for(int32_t i = 0; i < lastBlockCount; ++i) {
+  size_t lastBlockCount = DIV_FLOOR(lastByteLength, blockLength);
+  for(size_t i = 0; i < lastBlockCount; ++i) {
     lastMask >>= 1;
     lastMask |= 0x80;
   }
-  for(int32_t i = 0; i < bitfieldLength; ++i) {
+  for(size_t i = 0; i < bitfieldLength; ++i) {
     unsigned char mask;
     if(byte == bitfieldLength-1) {
       mask = lastMask;
@@ -215,23 +213,23 @@ BitfieldMan::getMissingIndexRandomly(const Array& bitfield,
       mask = 0xff;
     }
     if(bitfield[byte]&mask) {
-      int32_t index = byte*8+getNthBitIndex(bitfield[byte], 1);
-      return index;
+      index = byte*8+getNthBitIndex(bitfield[byte], 1);
+      return true;
     }
     byte++;
     if(byte == bitfieldLength) {
       byte = 0;
     }
   }
-  return -1;
+  return false;
 }
 
-bool BitfieldMan::hasMissingPiece(const unsigned char* peerBitfield, int32_t length) const {
+bool BitfieldMan::hasMissingPiece(const unsigned char* peerBitfield, size_t length) const {
   if(bitfieldLength != length) {
     return false;
   }
   bool retval = false;
-  for(int32_t i = 0; i < bitfieldLength; ++i) {
+  for(size_t i = 0; i < bitfieldLength; ++i) {
     unsigned char temp = peerBitfield[i] & ~bitfield[i];
     if(filterEnabled) {
       temp &= filterBitfield[i];
@@ -244,20 +242,20 @@ bool BitfieldMan::hasMissingPiece(const unsigned char* peerBitfield, int32_t len
   return retval;
 }
 
-int32_t BitfieldMan::getMissingIndex(const unsigned char* peerBitfield, int32_t length) const {
+bool BitfieldMan::getMissingIndex(size_t& index, const unsigned char* peerBitfield, size_t length) const {
   if(bitfieldLength != length) {
-    return -1;
+    return false;
   }
   array_fun<unsigned char> bf = array_and(array_negate(bitfield), peerBitfield);
   if(filterEnabled) {
     bf = array_and(bf, filterBitfield);
   }
-  return getMissingIndexRandomly(bf, bitfieldLength);
+  return getMissingIndexRandomly(index, bf, bitfieldLength);
 }
 
-int32_t BitfieldMan::getMissingUnusedIndex(const unsigned char* peerBitfield, int32_t length) const {
+bool BitfieldMan::getMissingUnusedIndex(size_t& index, const unsigned char* peerBitfield, size_t length) const {
   if(bitfieldLength != length) {
-    return -1;
+    return false;
   }
   array_fun<unsigned char> bf = array_and(array_and(array_negate(bitfield),
 						    array_negate(useBitfield)),
@@ -265,72 +263,75 @@ int32_t BitfieldMan::getMissingUnusedIndex(const unsigned char* peerBitfield, in
   if(filterEnabled) {
     bf = array_and(bf, filterBitfield);
   }
-  return getMissingIndexRandomly(bf, bitfieldLength);
+  return getMissingIndexRandomly(index, bf, bitfieldLength);
 }
 
 template<typename Array>
-int32_t BitfieldMan::getFirstMissingIndex(const Array& bitfield, int32_t bitfieldLength) const
+bool BitfieldMan::getFirstMissingIndex(size_t& index, const Array& bitfield, size_t bitfieldLength) const
 {
-  for(int32_t i = 0; i < bitfieldLength; ++i) {
-    int32_t base = i*8;
-    for(int32_t bi = 0; bi < 8 && base+bi < blocks; ++bi) {
+  for(size_t i = 0; i < bitfieldLength; ++i) {
+    size_t base = i*8;
+    for(size_t bi = 0; bi < 8 && base+bi < blocks; ++bi) {
       unsigned char mask = 128 >> bi;
       if(bitfield[i] & mask) {
-	return base+bi;
+	index = base+bi;
+	return true;
       }
     }
   }
-  return -1;
+  return false;
 }
 
-int32_t BitfieldMan::getFirstMissingUnusedIndex() const {
+bool BitfieldMan::getFirstMissingUnusedIndex(size_t& index) const
+{
   array_fun<unsigned char> bf = array_and(array_negate(bitfield),
 					  array_negate(useBitfield));
   if(filterEnabled) {
     bf = array_and(bf, filterBitfield);
   }
-  return getFirstMissingIndex(bf, bitfieldLength);
+  return getFirstMissingIndex(index, bf, bitfieldLength);
 }
 
-int32_t BitfieldMan::getFirstMissingIndex() const
+bool BitfieldMan::getFirstMissingIndex(size_t& index) const
 {
   array_fun<unsigned char> bf = array_negate(bitfield);
   if(filterEnabled) {
     bf = array_and(bf, filterBitfield);
   }
-  return getFirstMissingIndex(bf, bitfieldLength);
+  return getFirstMissingIndex(index, bf, bitfieldLength);
 }
 
-int32_t BitfieldMan::getMissingIndex() const {
+bool BitfieldMan::getMissingIndex(size_t& index) const {
   array_fun<unsigned char> bf = array_negate(bitfield);
   if(filterEnabled) {
     bf = array_and(bf, filterBitfield);
   }
-  return getMissingIndexRandomly(bf, bitfieldLength);
+  return getMissingIndexRandomly(index, bf, bitfieldLength);
 }
 
-int32_t BitfieldMan::getMissingUnusedIndex() const {
+bool BitfieldMan::getMissingUnusedIndex(size_t& index) const
+{
   array_fun<unsigned char> bf = array_and(array_negate(bitfield),
 					  array_negate(useBitfield));
   if(filterEnabled) {
     bf = array_and(bf, filterBitfield);
   }
-  return getMissingIndexRandomly(bf, bitfieldLength);
+  return getMissingIndexRandomly(index, bf, bitfieldLength);
 }
 
 // [startIndex, endIndex)
 class Range {
 public:
-  int32_t startIndex;
-  int32_t endIndex;
-  Range(int32_t startIndex = 0, int32_t endIndex = 0):startIndex(startIndex),
-						      endIndex(endIndex) {}
+  size_t startIndex;
+  size_t endIndex;
+  Range(size_t startIndex = 0, size_t endIndex = 0):startIndex(startIndex),
+						    endIndex(endIndex) {}
   
-  int32_t getSize() const {
+  size_t getSize() const {
     return endIndex-startIndex;
   }
 
-  int32_t getMidIndex() const {
+  size_t getMidIndex() const {
     return (endIndex-startIndex)/2+startIndex;
   }
 
@@ -339,59 +340,63 @@ public:
   }
 };
 
-int32_t BitfieldMan::getStartIndex(int32_t index) const {
+size_t BitfieldMan::getStartIndex(size_t index) const {
   while(index < blocks && (isUseBitSet(index) || isBitSet(index))) {
     index++;
   }
-  if((int32_t)blocks <= index) {
-    return -1;
+  if(blocks <= index) {
+    return blocks;
   } else {
     return index;
   }
 }
 
-int32_t BitfieldMan::getEndIndex(int32_t index) const {
+size_t BitfieldMan::getEndIndex(size_t index) const {
   while(index < blocks && (!isUseBitSet(index) && !isBitSet(index))) {
     index++;
   }
   return index;
 }
 
-int32_t BitfieldMan::getSparseMissingUnusedIndex() const {
+bool BitfieldMan::getSparseMissingUnusedIndex(size_t& index) const {
   Range maxRange;
-  int32_t index = 0;
   Range currentRange;
-  while(index < blocks) {
-    currentRange.startIndex = getStartIndex(index);
-    if(currentRange.startIndex == -1) {
-      break;
-    }
-    currentRange.endIndex = getEndIndex(currentRange.startIndex);
-    if(maxRange < currentRange) {
-      maxRange = currentRange;
+  {
+    size_t nextIndex = 0;
+    while(nextIndex < blocks) {
+      currentRange.startIndex = getStartIndex(nextIndex);
+      if(currentRange.startIndex == blocks) {
+	break;
+      }
+      currentRange.endIndex = getEndIndex(currentRange.startIndex);
+      if(maxRange < currentRange) {
+	maxRange = currentRange;
+      }
+      nextIndex = currentRange.endIndex;
     }
-    index = currentRange.endIndex;
   }
   if(maxRange.getSize()) {
     if(maxRange.startIndex == 0) {
-      return 0;
+      index = 0;
     } else if(isUseBitSet(maxRange.startIndex-1)) {
-      return maxRange.getMidIndex();      
+      index = maxRange.getMidIndex();
     } else {
-      return maxRange.startIndex;
+      index = maxRange.startIndex;
     }
+    return true;
   } else {
-    return -1;
+    return false;
   }
 }
 
 template<typename Array>
-std::deque<int32_t> BitfieldMan::getAllMissingIndexes(const Array& bitfield, int32_t bitfieldLength) const
+std::deque<size_t>
+BitfieldMan::getAllMissingIndexes(const Array& bitfield, size_t bitfieldLength) const
 {
-  std::deque<int32_t> missingIndexes;
-  for(int32_t i = 0; i < bitfieldLength; ++i) {
-    int32_t base = i*8;
-    for(int32_t bi = 0; bi < 8 && base+bi < blocks; ++bi) {
+  std::deque<size_t> missingIndexes;
+  for(size_t i = 0; i < bitfieldLength; ++i) {
+    size_t base = i*8;
+    for(size_t bi = 0; bi < 8 && base+bi < blocks; ++bi) {
       unsigned char mask = 128 >> bi;
       if(bitfield[i] & mask) {
 	missingIndexes.push_back(base+bi);
@@ -401,7 +406,7 @@ std::deque<int32_t> BitfieldMan::getAllMissingIndexes(const Array& bitfield, int
   return missingIndexes;
 }
 
-std::deque<int32_t> BitfieldMan::getAllMissingIndexes() const {
+std::deque<size_t> BitfieldMan::getAllMissingIndexes() const {
   array_fun<unsigned char> bf = array_negate(bitfield);
   if(filterEnabled) {
     bf = array_and(bf, filterBitfield);
@@ -409,9 +414,9 @@ std::deque<int32_t> BitfieldMan::getAllMissingIndexes() const {
   return getAllMissingIndexes(bf, bitfieldLength);
 }
 
-std::deque<int32_t> BitfieldMan::getAllMissingIndexes(const unsigned char* peerBitfield, int32_t peerBitfieldLength) const {
+std::deque<size_t> BitfieldMan::getAllMissingIndexes(const unsigned char* peerBitfield, size_t peerBitfieldLength) const {
   if(bitfieldLength != peerBitfieldLength) {
-    return std::deque<int32_t>();
+    return std::deque<size_t>();
   }
   array_fun<unsigned char> bf = array_and(array_negate(bitfield),
 					  peerBitfield);
@@ -421,17 +426,17 @@ std::deque<int32_t> BitfieldMan::getAllMissingIndexes(const unsigned char* peerB
   return getAllMissingIndexes(bf, bitfieldLength);
 }
 
-int32_t BitfieldMan::countMissingBlock() const {
+size_t BitfieldMan::countMissingBlock() const {
   return cachedNumMissingBlock;
 }
 
-int32_t BitfieldMan::countMissingBlockNow() const {
+size_t BitfieldMan::countMissingBlockNow() const {
   if(filterEnabled) {
     unsigned char* temp = new unsigned char[bitfieldLength];
-    for(int32_t i = 0; i < bitfieldLength; ++i) {
+    for(size_t i = 0; i < bitfieldLength; ++i) {
       temp[i] = bitfield[i]&filterBitfield[i];
     }
-    int32_t count =  countSetBit(filterBitfield, bitfieldLength)-
+    size_t count =  countSetBit(filterBitfield, bitfieldLength)-
       countSetBit(temp, bitfieldLength);
     delete [] temp;
     return count;
@@ -440,15 +445,15 @@ int32_t BitfieldMan::countMissingBlockNow() const {
   }
 }
 
-int32_t BitfieldMan::countFilteredBlock() const {
+size_t BitfieldMan::countFilteredBlock() const {
   return cachedNumFilteredBlock;
 }
 
-int32_t BitfieldMan::countBlock() const {
+size_t BitfieldMan::countBlock() const {
   return blocks;
 }
 
-int32_t BitfieldMan::countFilteredBlockNow() const {
+size_t BitfieldMan::countFilteredBlockNow() const {
   if(filterEnabled) {
     return countSetBit(filterBitfield, bitfieldLength);
   } else {
@@ -456,12 +461,12 @@ int32_t BitfieldMan::countFilteredBlockNow() const {
   }
 }
 
-int32_t BitfieldMan::getMaxIndex() const
+size_t BitfieldMan::getMaxIndex() const
 {
   return blocks-1;
 }
 
-bool BitfieldMan::setBitInternal(unsigned char* bitfield, int32_t index, bool on) {
+bool BitfieldMan::setBitInternal(unsigned char* bitfield, size_t index, bool on) {
   if(blocks <= index) { return false; }
   unsigned char mask = 128 >> index%8;
   if(on) {
@@ -472,21 +477,21 @@ bool BitfieldMan::setBitInternal(unsigned char* bitfield, int32_t index, bool on
   return true;
 }
 
-bool BitfieldMan::setUseBit(int32_t index) {
+bool BitfieldMan::setUseBit(size_t index) {
   return setBitInternal(useBitfield, index, true);
 }
 
-bool BitfieldMan::unsetUseBit(int32_t index) {
+bool BitfieldMan::unsetUseBit(size_t index) {
   return setBitInternal(useBitfield, index, false);
 }
 
-bool BitfieldMan::setBit(int32_t index) {
+bool BitfieldMan::setBit(size_t index) {
   bool b = setBitInternal(bitfield, index, true);
   updateCache();
   return b;
 }
 
-bool BitfieldMan::unsetBit(int32_t index) {
+bool BitfieldMan::unsetBit(size_t index) {
   bool b = setBitInternal(bitfield, index, false);
   updateCache();
   return b;
@@ -494,7 +499,7 @@ bool BitfieldMan::unsetBit(int32_t index) {
 
 bool BitfieldMan::isFilteredAllBitSet() const {
   if(filterEnabled) {
-    for(int32_t i = 0; i < bitfieldLength; ++i) {
+    for(size_t i = 0; i < bitfieldLength; ++i) {
       if((bitfield[i]&filterBitfield[i]) != filterBitfield[i]) {
 	return false;
       }
@@ -509,7 +514,7 @@ bool BitfieldMan::isAllBitSet() const {
   if(bitfieldLength == 0) {
     return true;
   }
-  for(int32_t i = 0; i < bitfieldLength-1; ++i) {
+  for(size_t i = 0; i < bitfieldLength-1; ++i) {
     if(bitfield[i] != 0xff) {
       return false;
     }
@@ -521,21 +526,21 @@ bool BitfieldMan::isAllBitSet() const {
   return true;
 }
 
-bool BitfieldMan::isBitSetInternal(const unsigned char* bitfield, int32_t index) const {
+bool BitfieldMan::isBitSetInternal(const unsigned char* bitfield, size_t index) const {
   if(index < 0 || blocks <= index) { return false; }
   unsigned char mask = 128 >> index%8;
   return (bitfield[index/8] & mask) != 0;
 }
 
-bool BitfieldMan::isBitSet(int32_t index) const {
+bool BitfieldMan::isBitSet(size_t index) const {
   return isBitSetInternal(bitfield, index);
 }
 
-bool BitfieldMan::isUseBitSet(int32_t index) const {
+bool BitfieldMan::isUseBitSet(size_t index) const {
   return isBitSetInternal(useBitfield, index);
 }
 
-void BitfieldMan::setBitfield(const unsigned char* bitfield, int32_t bitfieldLength) {
+void BitfieldMan::setBitfield(const unsigned char* bitfield, size_t bitfieldLength) {
   if(this->bitfieldLength != bitfieldLength) {
     return;
   }
@@ -549,7 +554,7 @@ const unsigned char* BitfieldMan::getBitfield() const
   return bitfield;
 }
 
-int32_t BitfieldMan::getBitfieldLength() const
+size_t BitfieldMan::getBitfieldLength() const
 {
   return bitfieldLength;
 }
@@ -560,7 +565,7 @@ void BitfieldMan::clearAllBit() {
 }
 
 void BitfieldMan::setAllBit() {
-  for(int32_t i = 0; i < blocks; ++i) {
+  for(size_t i = 0; i < blocks; ++i) {
     setBitInternal(bitfield, i, true);
   }
   updateCache();
@@ -572,23 +577,23 @@ void BitfieldMan::clearAllUseBit() {
 }
 
 void BitfieldMan::setAllUseBit() {
-  for(int32_t i = 0; i < blocks; ++i) {
+  for(size_t i = 0; i < blocks; ++i) {
     setBitInternal(useBitfield, i, true);
   }
 }
 
-bool BitfieldMan::setFilterBit(int32_t index) {
+bool BitfieldMan::setFilterBit(size_t index) {
   return setBitInternal(filterBitfield, index, true);
 }
 
-void BitfieldMan::addFilter(int64_t offset, int64_t length) {
+void BitfieldMan::addFilter(uint64_t offset, uint64_t length) {
   if(!filterBitfield) {
     filterBitfield = new unsigned char[bitfieldLength];
     memset(filterBitfield, 0, bitfieldLength);
   }
-  int32_t startBlock = offset/blockLength;
-  int32_t endBlock = (offset+length-1)/blockLength;
-  for(int i = startBlock; i <= endBlock && i < blocks; i++) {
+  size_t startBlock = offset/blockLength;
+  size_t endBlock = (offset+length-1)/blockLength;
+  for(size_t i = startBlock; i <= endBlock && i < blocks; i++) {
     setFilterBit(i);
   }
   updateCache();
@@ -617,29 +622,29 @@ bool BitfieldMan::isFilterEnabled() const {
   return filterEnabled;
 }
 
-int64_t BitfieldMan::getFilteredTotalLength() const {
+uint64_t BitfieldMan::getFilteredTotalLength() const {
   return cachedFilteredTotalLength;
 }
 
-int64_t BitfieldMan::getFilteredTotalLengthNow() const {
+uint64_t BitfieldMan::getFilteredTotalLengthNow() const {
   if(!filterBitfield) {
     return 0;
   }
-  int32_t filteredBlocks = countSetBit(filterBitfield, bitfieldLength);
+  size_t filteredBlocks = countSetBit(filterBitfield, bitfieldLength);
   if(filteredBlocks == 0) {
     return 0;
   }
   if(isBitSetInternal(filterBitfield, blocks-1)) {
-    return ((int64_t)filteredBlocks-1)*blockLength+getLastBlockLength();
+    return ((uint64_t)filteredBlocks-1)*blockLength+getLastBlockLength();
   } else {
-    return ((int64_t)filteredBlocks)*blockLength;
+    return ((uint64_t)filteredBlocks)*blockLength;
   }
 }
 
-int64_t BitfieldMan::getCompletedLength(bool useFilter) const {
+uint64_t BitfieldMan::getCompletedLength(bool useFilter) const {
   unsigned char* temp = new unsigned char[bitfieldLength];
   if(useFilter) {
-    for(int32_t i = 0; i < bitfieldLength; ++i) {
+    for(size_t i = 0; i < bitfieldLength; ++i) {
       temp[i] = bitfield[i];
       if(filterEnabled) {
 	temp[i] &= filterBitfield[i];
@@ -648,34 +653,34 @@ int64_t BitfieldMan::getCompletedLength(bool useFilter) const {
   } else {
     memcpy(temp, bitfield, bitfieldLength);
   }
-  int32_t completedBlocks = countSetBit(temp, bitfieldLength);
-  int64_t completedLength = 0;
+  size_t completedBlocks = countSetBit(temp, bitfieldLength);
+  uint64_t completedLength = 0;
   if(completedBlocks == 0) {
     completedLength = 0;
   } else {
     if(isBitSetInternal(temp, blocks-1)) {
-      completedLength = ((int64_t)completedBlocks-1)*blockLength+getLastBlockLength();
+      completedLength = ((uint64_t)completedBlocks-1)*blockLength+getLastBlockLength();
     } else {
-      completedLength = ((int64_t)completedBlocks)*blockLength;
+      completedLength = ((uint64_t)completedBlocks)*blockLength;
     }
   }
   delete [] temp;
   return completedLength;
 }
 
-int64_t BitfieldMan::getCompletedLength() const {
+uint64_t BitfieldMan::getCompletedLength() const {
   return cachedCompletedLength;
 }
 
-int64_t BitfieldMan::getCompletedLengthNow() const {
+uint64_t BitfieldMan::getCompletedLengthNow() const {
   return getCompletedLength(false);
 }
 
-int64_t BitfieldMan::getFilteredCompletedLength() const {
+uint64_t BitfieldMan::getFilteredCompletedLength() const {
   return cachedFilteredComletedLength;
 }
 
-int64_t BitfieldMan::getFilteredCompletedLengthNow() const {
+uint64_t BitfieldMan::getFilteredCompletedLengthNow() const {
   return getCompletedLength(true);
 }
 
@@ -688,9 +693,9 @@ void BitfieldMan::updateCache()
   cachedFilteredComletedLength = getFilteredCompletedLengthNow();
 }
 
-bool BitfieldMan::isBitRangeSet(int32_t startIndex, int32_t endIndex) const
+bool BitfieldMan::isBitRangeSet(size_t startIndex, size_t endIndex) const
 {
-  for(int32_t i =  startIndex; i <= endIndex; ++i) {
+  for(size_t i =  startIndex; i <= endIndex; ++i) {
     if(!isBitSet(i)) {
       return false;
     }
@@ -698,23 +703,23 @@ bool BitfieldMan::isBitRangeSet(int32_t startIndex, int32_t endIndex) const
   return true;
 }
 
-void BitfieldMan::unsetBitRange(int32_t startIndex, int32_t endIndex)
+void BitfieldMan::unsetBitRange(size_t startIndex, size_t endIndex)
 {
-  for(int32_t i = startIndex; i <= endIndex; ++i) {
+  for(size_t i = startIndex; i <= endIndex; ++i) {
     unsetBit(i);
   }
   updateCache();
 }
 
-void BitfieldMan::setBitRange(int32_t startIndex, int32_t endIndex)
+void BitfieldMan::setBitRange(size_t startIndex, size_t endIndex)
 {
-  for(int32_t i = startIndex; i <= endIndex; ++i) {
+  for(size_t i = startIndex; i <= endIndex; ++i) {
     setBit(i);
   }
   updateCache();
 }
 
-bool BitfieldMan::isBitSetOffsetRange(int64_t offset, int64_t length) const
+bool BitfieldMan::isBitSetOffsetRange(uint64_t offset, uint64_t length) const
 {
   if(length <= 0) {
     return false;
@@ -725,9 +730,9 @@ bool BitfieldMan::isBitSetOffsetRange(int64_t offset, int64_t length) const
   if(totalLength < offset+length) {
     length = totalLength-offset;
   }
-  int32_t startBlock = offset/blockLength;
-  int32_t endBlock = (offset+length-1)/blockLength;
-  for(int32_t i = startBlock; i <= endBlock; i++) {
+  size_t startBlock = offset/blockLength;
+  size_t endBlock = (offset+length-1)/blockLength;
+  for(size_t i = startBlock; i <= endBlock; i++) {
     if(!isBitSet(i)) {
       return false;
     }
@@ -735,13 +740,13 @@ bool BitfieldMan::isBitSetOffsetRange(int64_t offset, int64_t length) const
   return true;
 }
 
-int64_t BitfieldMan::getMissingUnusedLength(int32_t startingIndex) const
+uint64_t BitfieldMan::getMissingUnusedLength(size_t startingIndex) const
 {
   if(startingIndex < 0 || blocks <= startingIndex) {
     return 0;
   }
-  int64_t length = 0;
-  for(int32_t i = startingIndex; i < blocks; ++i) {
+  uint64_t length = 0;
+  for(size_t i = startingIndex; i < blocks; ++i) {
     if(isBitSet(i) || isUseBitSet(i)) {
       break;
     }

src/BitfieldMan.h

@@ -45,121 +45,120 @@ class Randomizer;
 
 class BitfieldMan {
 private:
-  int32_t blockLength;
-  int64_t totalLength;
+  size_t blockLength;
+  uint64_t totalLength;
   unsigned char* bitfield;
   unsigned char* useBitfield;
   unsigned char* filterBitfield;
-  int32_t bitfieldLength;
-  int32_t blocks;
+  size_t bitfieldLength;
+  size_t blocks;
   bool filterEnabled;
   SharedHandle<Randomizer> randomizer;
 
   // for caching
-  int32_t cachedNumMissingBlock;
-  int32_t cachedNumFilteredBlock;
-  int64_t cachedCompletedLength;
-  int64_t cachedFilteredComletedLength;
-  int64_t cachedFilteredTotalLength;
+  size_t cachedNumMissingBlock;
+  size_t cachedNumFilteredBlock;
+  uint64_t cachedCompletedLength;
+  uint64_t cachedFilteredComletedLength;
+  uint64_t cachedFilteredTotalLength;
 
-  int32_t countSetBit(const unsigned char* bitfield, int32_t len) const;
-  int32_t getNthBitIndex(const unsigned char bit, int32_t nth) const;
-  int32_t getMissingIndexRandomly(const unsigned char* bitfield, int32_t len) const;
+  size_t countSetBit(const unsigned char* bitfield, size_t len) const;
+  size_t getNthBitIndex(const unsigned char bit, size_t nth) const;
+  bool getMissingIndexRandomly(size_t& index, const unsigned char* bitfield, size_t len) const;
 
   template<typename Array>
-  int32_t
-  getMissingIndexRandomly(const Array& bitfield,
-			  int32_t bitfieldLength) const;
+  bool getMissingIndexRandomly(size_t& index, const Array& bitfield,
+			       size_t bitfieldLength) const;
   template<typename Array>
-  int32_t getFirstMissingIndex(const Array& bitfield, int32_t bitfieldLength) const;
+  bool getFirstMissingIndex(size_t& index, const Array& bitfield, size_t bitfieldLength) const;
 
   template<typename Array>
-  std::deque<int32_t> getAllMissingIndexes(const Array& bitfield, int32_t bitfieldLength) const;
+  std::deque<size_t> getAllMissingIndexes(const Array& bitfield, size_t bitfieldLength) const;
 
-  bool isBitSetInternal(const unsigned char* bitfield, int32_t index) const;
-  bool setBitInternal(unsigned char* bitfield, int32_t index, bool on);
-  bool setFilterBit(int32_t index);
+  bool isBitSetInternal(const unsigned char* bitfield, size_t index) const;
+  bool setBitInternal(unsigned char* bitfield, size_t index, bool on);
+  bool setFilterBit(size_t index);
 
-  int32_t getStartIndex(int32_t index) const;
-  int32_t getEndIndex(int32_t index) const;
+  size_t getStartIndex(size_t index) const;
+  size_t getEndIndex(size_t index) const;
 
-  int64_t getCompletedLength(bool useFilter) const;
+  uint64_t getCompletedLength(bool useFilter) const;
 public:
-  BitfieldMan(int32_t blockLength, int64_t totalLength);
+  BitfieldMan(size_t blockLength, uint64_t totalLength);
   BitfieldMan(const BitfieldMan& bitfieldMan);
   ~BitfieldMan();
 
   BitfieldMan& operator=(const BitfieldMan& bitfieldMan);
 
-  int32_t getBlockLength() const;
+  size_t getBlockLength() const;
 
-  int32_t getLastBlockLength() const;
+  size_t getLastBlockLength() const;
 
-  int32_t getBlockLength(int32_t index) const;
+  size_t getBlockLength(size_t index) const;
 
-  int64_t getTotalLength() const { return totalLength; }
+  uint64_t getTotalLength() const { return totalLength; }
 
   /**
    * affected by filter
    */
-  bool hasMissingPiece(const unsigned char* bitfield, int32_t len) const;
+  bool hasMissingPiece(const unsigned char* bitfield, size_t len) const;
   /**
    * affected by filter
    */
-  int32_t getMissingIndex(const unsigned char* bitfield, int32_t len) const;
+  bool getMissingIndex(size_t& index, const unsigned char* bitfield, size_t len) const;
   /**
    * affected by filter
    */
-  int32_t getMissingIndex() const;
+  bool getMissingIndex(size_t& index) const;
   /**
    * affected by filter
    */
-  int32_t getFirstMissingUnusedIndex(const unsigned char* bitfield, int32_t len) const;
+  bool getFirstMissingUnusedIndex(size_t& index, const unsigned char* bitfield, size_t len) const;
   /**
    * affected by filter
    */
-  int32_t getFirstMissingUnusedIndex() const;
+  bool getFirstMissingUnusedIndex(size_t& index) const;
   /**
    * affected by filter
    */
-  int32_t getFirstMissingIndex() const;
+  bool getFirstMissingIndex(size_t& index) const;
   /**
    * affected by filter
    */
-  int32_t getMissingUnusedIndex(const unsigned char* bitfield, int32_t len) const;
+  bool getMissingUnusedIndex(size_t& index, const unsigned char* bitfield, size_t len) const;
   /**
    * affected by filter
    */
-  int32_t getMissingUnusedIndex() const;
+  bool getMissingUnusedIndex(size_t& index) const;
   /**
    * affected by filter
    */
-  int32_t getSparseMissingUnusedIndex() const;
+  bool getSparseMissingUnusedIndex(size_t& index) const;
   /**
    * affected by filter
    */
-  std::deque<int32_t> getAllMissingIndexes() const;
+  std::deque<size_t> getAllMissingIndexes() const;
   /**
    * affected by filter
    */
-  std::deque<int32_t> getAllMissingIndexes(const unsigned char* bitfield, int32_t len) const;
+  std::deque<size_t> getAllMissingIndexes(const unsigned char* bitfield, size_t len) const;
   /**
    * affected by filter
    */
-  int32_t countMissingBlock() const;
+  size_t countMissingBlock() const;
   /**
    * affected by filter
    */
-  int32_t countMissingBlockNow() const;
+  size_t countMissingBlockNow() const;
 
-  bool setUseBit(int32_t index);
-  bool unsetUseBit(int32_t index);
+  bool setUseBit(size_t index);
+  bool unsetUseBit(size_t index);
 
-  bool setBit(int32_t index);
-  bool unsetBit(int32_t index);
+  bool setBit(size_t index);
+  bool unsetBit(size_t index);
 
-  bool isBitSet(int32_t index) const;
-  bool isUseBitSet(int32_t index) const;
+  bool isBitSet(size_t index) const;
+  bool isUseBitSet(size_t index) const;
 
   /**
    * affected by filter
@@ -170,22 +169,22 @@ public:
 
   const unsigned char* getBitfield() const;
 
-  int32_t getBitfieldLength() const;
+  size_t getBitfieldLength() const;
 
   /**
    * affected by filter
    */
-  int32_t countFilteredBlock() const;
+  size_t countFilteredBlock() const;
 
-  int32_t countBlock() const;
+  size_t countBlock() const;
   /**
    * affected by filter
    */
-  int32_t countFilteredBlockNow() const;
+  size_t countFilteredBlockNow() const;
 
-  int32_t getMaxIndex() const;
+  size_t getMaxIndex() const;
 
-  void setBitfield(const unsigned char* bitfield, int32_t bitfieldLength);
+  void setBitfield(const unsigned char* bitfield, size_t bitfieldLength);
 
   void clearAllBit();
   void setAllBit();
@@ -193,7 +192,7 @@ public:
   void clearAllUseBit();
   void setAllUseBit();
 
-  void addFilter(int64_t offset, int64_t length);
+  void addFilter(uint64_t offset, uint64_t length);
   /**
    * Clears filter and disables filter
    */
@@ -205,24 +204,24 @@ public:
   /**
    * affected by filter
    */
-  int64_t getFilteredTotalLength() const;
+  uint64_t getFilteredTotalLength() const;
   /**
    * affected by filter
    */
-  int64_t getFilteredTotalLengthNow() const;
+  uint64_t getFilteredTotalLengthNow() const;
 
-  int64_t getCompletedLength() const;
+  uint64_t getCompletedLength() const;
 
-  int64_t getCompletedLengthNow() const;
+  uint64_t getCompletedLengthNow() const;
 
   /**
    * affected by filter
    */
-  int64_t getFilteredCompletedLength() const;
+  uint64_t getFilteredCompletedLength() const;
   /**
    * affected by filter
    */
-  int64_t getFilteredCompletedLengthNow() const;
+  uint64_t getFilteredCompletedLengthNow() const;
 
   void setRandomizer(const SharedHandle<Randomizer>& randomizer);
 
@@ -230,15 +229,15 @@ public:
 
   void updateCache();
 
-  bool isBitRangeSet(int32_t startIndex, int32_t endIndex) const;
+  bool isBitRangeSet(size_t startIndex, size_t endIndex) const;
 
-  void unsetBitRange(int32_t startIndex, int32_t endIndex);
+  void unsetBitRange(size_t startIndex, size_t endIndex);
 
-  void setBitRange(int32_t startIndex, int32_t endIndex);
+  void setBitRange(size_t startIndex, size_t endIndex);
 
-  bool isBitSetOffsetRange(int64_t offset, int64_t length) const;
+  bool isBitSetOffsetRange(uint64_t offset, uint64_t length) const;
 
-  int64_t getMissingUnusedLength(int32_t startingIndex) const;
+  uint64_t getMissingUnusedLength(size_t startingIndex) const;
 
 };
 

src/BtRequestFactory.h

@@ -66,14 +66,14 @@ public:
    * The number of objects returned is capped by max.
    */
   virtual std::deque<SharedHandle<BtMessage> >
-  createRequestMessages(int32_t max) = 0;
+  createRequestMessages(size_t max) = 0;
 
   /**
    * Use this method in end game mode.
    *
    */
   virtual std::deque<SharedHandle<BtMessage> >
-  createRequestMessagesOnEndGame(int32_t max) = 0;
+  createRequestMessagesOnEndGame(size_t max) = 0;
 };
 
 typedef SharedHandle<BtRequestFactory> BtRequestFactoryHandle;

src/DefaultBtInteractive.cc

@@ -199,7 +199,7 @@ void DefaultBtInteractive::decideChoking() {
 }
 
 void DefaultBtInteractive::checkHave() {
-  std::deque<int32_t> indexes =
+  std::deque<size_t> indexes =
     pieceStorage->getAdvertisedPieceIndexes(cuid, haveCheckPoint);
   haveCheckPoint.reset();
   if(indexes.size() >= 20) {
@@ -209,7 +209,7 @@ void DefaultBtInteractive::checkHave() {
       dispatcher->addMessageToQueue(messageFactory->createBitfieldMessage());
     }
   } else {
-    for(std::deque<int32_t>::iterator itr = indexes.begin(); itr != indexes.end(); itr++) {
+    for(std::deque<size_t>::iterator itr = indexes.begin(); itr != indexes.end(); itr++) {
       dispatcher->addMessageToQueue(messageFactory->createHaveMessage(*itr));
     }
   }

src/DefaultBtProgressInfoFile.cc

@@ -233,26 +233,26 @@ void DefaultBtProgressInfoFile::load()
       delete [] savedBitfield;
       savedBitfield = 0;
 
-      int32_t numInFlightPiece;
+      uint32_t numInFlightPiece;
       in.read(reinterpret_cast<char*>(&numInFlightPiece), sizeof(numInFlightPiece));
       
       Pieces inFlightPieces;
       while(numInFlightPiece--) {
-	int32_t index;
+	uint32_t index;
 	in.read(reinterpret_cast<char*>(&index), sizeof(index));
-	if(!(0 <= index && index < _dctx->getNumPieces())) {
-	  throw new DlAbortEx("piece index out of range: %d", index);
+	if(!(index < _dctx->getNumPieces())) {
+	  throw new DlAbortEx("piece index out of range: %u", index);
 	}
-	int32_t length;
+	uint32_t length;
 	in.read(reinterpret_cast<char*>(&length), sizeof(length));
-	if(!(0 < length && length <=_dctx->getPieceLength())) {
-	  throw new DlAbortEx("piece length out of range: %d", length);
+	if(!(length <=_dctx->getPieceLength())) {
+	  throw new DlAbortEx("piece length out of range: %u", length);
 	}
 	PieceHandle piece = new Piece(index, length);
-	int32_t bitfieldLength;
+	uint32_t bitfieldLength;
 	in.read(reinterpret_cast<char*>(&bitfieldLength), sizeof(bitfieldLength));
 	if(piece->getBitfieldLength() != bitfieldLength) {
-	  throw new DlAbortEx("piece bitfield length mismatch. expected: %d actual: %d",
+	  throw new DlAbortEx("piece bitfield length mismatch. expected: %u actual: %u",
 			      piece->getBitfieldLength(), bitfieldLength);
 	}
 	savedBitfield = new unsigned char[bitfieldLength];
@@ -265,7 +265,7 @@ void DefaultBtProgressInfoFile::load()
       }
       _pieceStorage->addInFlightPiece(inFlightPieces);
     } else {
-      int32_t numInFlightPiece;
+      uint32_t numInFlightPiece;
       in.read(reinterpret_cast<char*>(&numInFlightPiece), sizeof(numInFlightPiece));
       BitfieldMan src(pieceLength, totalLength);
       src.setBitfield(savedBitfield, bitfieldLength);

src/DefaultBtRequestFactory.cc

@@ -109,31 +109,32 @@ void DefaultBtRequestFactory::removeAllTargetPiece() {
   pieces.clear();
 }
 
-BtMessages DefaultBtRequestFactory::createRequestMessages(int32_t max) {
+BtMessages DefaultBtRequestFactory::createRequestMessages(size_t max)
+{
   BtMessages requests;
   for(Pieces::iterator itr = pieces.begin();
-      itr != pieces.end() && requests.size() < (size_t)max; itr++) {
+      itr != pieces.end() && requests.size() < max; itr++) {
     PieceHandle& piece = *itr;
-    int32_t blockIndex;
-    while(requests.size() < (size_t)max &&
-	  (blockIndex = piece->getMissingUnusedBlockIndex()) != -1) {
+    size_t blockIndex;
+    while(requests.size() < max &&
+	  piece->getMissingUnusedBlockIndex(blockIndex)) {
       requests.push_back(messageFactory->createRequestMessage(piece, blockIndex));
     }
   }
   return requests;
 }
 
-BtMessages DefaultBtRequestFactory::createRequestMessagesOnEndGame(int32_t max) {
+BtMessages DefaultBtRequestFactory::createRequestMessagesOnEndGame(size_t max)
+{
   BtMessages requests;
   for(Pieces::iterator itr = pieces.begin();
-      itr != pieces.end() && requests.size() < (size_t)max; itr++) {
+      itr != pieces.end() && requests.size() < max; itr++) {
     PieceHandle& piece = *itr;
-    std::deque<int32_t> missingBlockIndexes = piece->getAllMissingBlockIndexes();
+    std::deque<size_t> missingBlockIndexes = piece->getAllMissingBlockIndexes();
     random_shuffle(missingBlockIndexes.begin(), missingBlockIndexes.end());
-    for(std::deque<int32_t>::const_iterator bitr = missingBlockIndexes.begin();
-	bitr != missingBlockIndexes.end() && requests.size() < (size_t)max;
-	bitr++) {
-      int32_t blockIndex = *bitr;
+    for(std::deque<size_t>::const_iterator bitr = missingBlockIndexes.begin();
+	bitr != missingBlockIndexes.end() && requests.size() < max; bitr++) {
+      size_t blockIndex = *bitr;
       if(!dispatcher->isOutstandingRequest(piece->getIndex(),
 					   blockIndex)) {
 	requests.push_back(messageFactory->createRequestMessage(piece, blockIndex));

src/DefaultBtRequestFactory.h

@@ -75,10 +75,10 @@ public:
   virtual void doChokedAction();
 
   virtual std::deque<SharedHandle<BtMessage> >
-  createRequestMessages(int32_t max);
+  createRequestMessages(size_t max);
 
   virtual std::deque<SharedHandle<BtMessage> >
-  createRequestMessagesOnEndGame(int32_t max);
+  createRequestMessagesOnEndGame(size_t max);
 
   std::deque<SharedHandle<Piece> >& getTargetPieces();
 

src/DefaultPieceStorage.cc

@@ -86,24 +86,19 @@ bool DefaultPieceStorage::isEndGame()
   return bitfieldMan->countMissingBlock() <= endGamePieceNum;
 }
 
-int32_t DefaultPieceStorage::getMissingPieceIndex(const PeerHandle& peer)
+bool DefaultPieceStorage::getMissingPieceIndex(size_t& index, const PeerHandle& peer)
 {
-  int32_t index = -1;
   if(isEndGame()) {
-    index = bitfieldMan->getMissingIndex(peer->getBitfield(),
-					 peer->getBitfieldLength());
+    return bitfieldMan->getMissingIndex(index, peer->getBitfield(),
+					peer->getBitfieldLength());
   } else {
-    index = bitfieldMan->getMissingUnusedIndex(peer->getBitfield(),
-					       peer->getBitfieldLength());
+    return bitfieldMan->getMissingUnusedIndex(index, peer->getBitfield(),
+					      peer->getBitfieldLength());
   }
-  return index;
 }
 
-PieceHandle DefaultPieceStorage::checkOutPiece(int32_t index)
+PieceHandle DefaultPieceStorage::checkOutPiece(size_t index)
 {
-  if(index == -1) {
-    return 0;
-  }
   bitfieldMan->setUseBit(index);
 
   PieceHandle piece = findUsedPiece(index);
@@ -120,7 +115,7 @@ PieceHandle DefaultPieceStorage::checkOutPiece(int32_t index)
  * Newly instantiated piece is not added to usedPieces.
  * Because it is waste of memory and there is no chance to use them later.
  */
-PieceHandle DefaultPieceStorage::getPiece(int32_t index)
+PieceHandle DefaultPieceStorage::getPiece(size_t index)
 {
   if(0 <= index && index <= bitfieldMan->getMaxIndex()) {
     PieceHandle piece = findUsedPiece(index);
@@ -143,16 +138,16 @@ void DefaultPieceStorage::addUsedPiece(const PieceHandle& piece)
 
 class FindPiece {
 private:
-  int32_t index;
+  size_t index;
 public:
-  FindPiece(int32_t index):index(index) {}
+  FindPiece(size_t index):index(index) {}
 
   bool operator()(const PieceHandle& piece) {
     return piece->getIndex() == index;
   }
 };
 
-PieceHandle DefaultPieceStorage::findUsedPiece(int32_t index) const
+PieceHandle DefaultPieceStorage::findUsedPiece(size_t index) const
 {
   Pieces::const_iterator itr = std::find_if(usedPieces.begin(),
 					    usedPieces.end(),
@@ -166,13 +161,17 @@ PieceHandle DefaultPieceStorage::findUsedPiece(int32_t index) const
 
 PieceHandle DefaultPieceStorage::getMissingPiece(const PeerHandle& peer)
 {
-  int32_t index = getMissingPieceIndex(peer);
-  return checkOutPiece(index);
+  size_t index;
+  if(getMissingPieceIndex(index, peer)) {
+    return checkOutPiece(index);
+  } else {
+    return 0;
+  }
 }
 
-int32_t DefaultPieceStorage::getMissingFastPieceIndex(const PeerHandle& peer)
+bool DefaultPieceStorage::getMissingFastPieceIndex(size_t& index,
+						   const PeerHandle& peer)
 {
-  int32_t index = -1;
   if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) {
     BitfieldMan tempBitfield(bitfieldMan->getBlockLength(),
 			     bitfieldMan->getTotalLength());
@@ -183,28 +182,38 @@ int32_t DefaultPieceStorage::getMissingFastPieceIndex(const PeerHandle& peer)
       }
     }
     if(isEndGame()) {
-      index = bitfieldMan->getMissingIndex(tempBitfield.getBitfield(),
-					   tempBitfield.getBitfieldLength());
+      return bitfieldMan->getMissingIndex(index, tempBitfield.getBitfield(),
+					  tempBitfield.getBitfieldLength());
     } else {
-      index = bitfieldMan->getMissingUnusedIndex(tempBitfield.getBitfield(),
-						 tempBitfield.getBitfieldLength());
+      return bitfieldMan->getMissingUnusedIndex(index,
+						tempBitfield.getBitfield(),
+						tempBitfield.getBitfieldLength());
     }
   }
-  return index;
+  return false;
 }
 
 PieceHandle DefaultPieceStorage::getMissingFastPiece(const PeerHandle& peer)
 {
-  int32_t index = getMissingFastPieceIndex(peer);
-  return checkOutPiece(index);
+  size_t index;
+  if(getMissingFastPieceIndex(index, peer)) {
+    return checkOutPiece(index);
+  } else {
+    return 0;
+  }
 }
 
 PieceHandle DefaultPieceStorage::getMissingPiece()
 {
-  return checkOutPiece(bitfieldMan->getSparseMissingUnusedIndex());
+  size_t index;
+  if(bitfieldMan->getSparseMissingUnusedIndex(index)) {
+    return checkOutPiece(index);
+  } else {
+    return 0;
+  }
 }
 
-PieceHandle DefaultPieceStorage::getMissingPiece(int32_t index)
+PieceHandle DefaultPieceStorage::getMissingPiece(size_t index)
 {
   if(hasPiece(index) || isPieceUsed(index)) {
     return 0;
@@ -224,15 +233,15 @@ void DefaultPieceStorage::deleteUsedPiece(const PieceHandle& piece)
   }
 }
 
-void DefaultPieceStorage::reduceUsedPieces(int32_t delMax)
+void DefaultPieceStorage::reduceUsedPieces(size_t delMax)
 {
-  int32_t toDelete = usedPieces.size()-delMax;
-  if(toDelete <= 0) {
+  if(usedPieces.size() <= delMax) {
     return;
   }
-  int32_t fillRate = 10;
+  size_t toDelete = usedPieces.size()-delMax;
+  int fillRate = 10;
   while(fillRate < 50) {
-    int32_t deleted = deleteUsedPiecesByFillRate(fillRate, toDelete);
+    size_t deleted = deleteUsedPiecesByFillRate(fillRate, toDelete);
     if(deleted == 0) {
       break;
     }
@@ -241,10 +250,10 @@ void DefaultPieceStorage::reduceUsedPieces(int32_t delMax)
   }
 }
 
-int32_t DefaultPieceStorage::deleteUsedPiecesByFillRate(int32_t fillRate,
-							int32_t toDelete)
+size_t DefaultPieceStorage::deleteUsedPiecesByFillRate(int fillRate,
+						       size_t toDelete)
 {
-  int32_t deleted = 0;
+  size_t deleted = 0;
   for(Pieces::iterator itr = usedPieces.begin();
       itr != usedPieces.end() && deleted < toDelete;) {
     PieceHandle& piece = *itr;
@@ -315,39 +324,39 @@ void DefaultPieceStorage::cancelPiece(const PieceHandle& piece)
   }
 }
 
-bool DefaultPieceStorage::hasPiece(int32_t index)
+bool DefaultPieceStorage::hasPiece(size_t index)
 {
   return bitfieldMan->isBitSet(index);
 }
 
-bool DefaultPieceStorage::isPieceUsed(int32_t index)
+bool DefaultPieceStorage::isPieceUsed(size_t index)
 {
   return bitfieldMan->isUseBitSet(index);
 }
 
-int64_t DefaultPieceStorage::getTotalLength()
+uint64_t DefaultPieceStorage::getTotalLength()
 {
   return bitfieldMan->getTotalLength();
 }
 
-int64_t DefaultPieceStorage::getFilteredTotalLength()
+uint64_t DefaultPieceStorage::getFilteredTotalLength()
 {
   return bitfieldMan->getFilteredTotalLength();
 }
 
-int64_t DefaultPieceStorage::getCompletedLength()
+uint64_t DefaultPieceStorage::getCompletedLength()
 {
   return bitfieldMan->getCompletedLength()+getInFlightPieceCompletedLength();
 }
 
-int64_t DefaultPieceStorage::getFilteredCompletedLength()
+uint64_t DefaultPieceStorage::getFilteredCompletedLength()
 {
   return bitfieldMan->getFilteredCompletedLength()+getInFlightPieceCompletedLength();
 }
 
-int32_t DefaultPieceStorage::getInFlightPieceCompletedLength() const
+size_t DefaultPieceStorage::getInFlightPieceCompletedLength() const
 {
-  return std::accumulate(usedPieces.begin(), usedPieces.end(), 0, adopt2nd(std::plus<int32_t>(), mem_fun_sh(&Piece::getCompletedLength)));
+  return std::accumulate(usedPieces.begin(), usedPieces.end(), 0, adopt2nd(std::plus<size_t>(), mem_fun_sh(&Piece::getCompletedLength)));
 }
 
 // not unittested
@@ -444,12 +453,12 @@ void DefaultPieceStorage::initStorage()
 }
 
 void DefaultPieceStorage::setBitfield(const unsigned char* bitfield,
-				      int32_t bitfieldLength)
+				      size_t bitfieldLength)
 {
   bitfieldMan->setBitfield(bitfield, bitfieldLength);
 }
   
-int32_t DefaultPieceStorage::getBitfieldLength()
+size_t DefaultPieceStorage::getBitfieldLength()
 {
   return bitfieldMan->getBitfieldLength();
 }
@@ -463,21 +472,22 @@ DiskAdaptorHandle DefaultPieceStorage::getDiskAdaptor() {
   return diskAdaptor;
 }
 
-int32_t DefaultPieceStorage::getPieceLength(int32_t index)
+size_t DefaultPieceStorage::getPieceLength(size_t index)
 {
   return bitfieldMan->getBlockLength(index);
 }
 
-void DefaultPieceStorage::advertisePiece(int32_t cuid, int32_t index)
+void DefaultPieceStorage::advertisePiece(int32_t cuid, size_t index)
 {
   HaveEntry entry(cuid, index);
   haves.push_front(entry);
 }
 
-std::deque<int32_t> DefaultPieceStorage::getAdvertisedPieceIndexes(int32_t myCuid,
-							const Time& lastCheckTime)
+std::deque<size_t>
+DefaultPieceStorage::getAdvertisedPieceIndexes(int32_t myCuid,
+					       const Time& lastCheckTime)
 {
-  std::deque<int32_t> indexes;
+  std::deque<size_t> indexes;
   for(Haves::const_iterator itr = haves.begin(); itr != haves.end(); itr++) {
     const Haves::value_type& have = *itr;
     if(have.getCuid() == myCuid) {
@@ -494,9 +504,9 @@ std::deque<int32_t> DefaultPieceStorage::getAdvertisedPieceIndexes(int32_t myCui
 class FindElapsedHave
 {
 private:
-  int32_t elapsed;
+  time_t elapsed;
 public:
-  FindElapsedHave(int32_t elapsed):elapsed(elapsed) {}
+  FindElapsedHave(time_t elapsed):elapsed(elapsed) {}
 
   bool operator()(const HaveEntry& have) {
     if(have.getRegisteredTime().elapsed(elapsed)) {
@@ -507,7 +517,7 @@ public:
   }
 };
   
-void DefaultPieceStorage::removeAdvertisedPiece(int32_t elapsed)
+void DefaultPieceStorage::removeAdvertisedPiece(time_t elapsed)
 {
   Haves::iterator itr =
     std::find_if(haves.begin(), haves.end(), FindElapsedHave(elapsed));
@@ -522,19 +532,19 @@ void DefaultPieceStorage::markAllPiecesDone()
   bitfieldMan->setAllBit();
 }
 
-void DefaultPieceStorage::markPiecesDone(int64_t length)
+void DefaultPieceStorage::markPiecesDone(uint64_t length)
 {
   if(length == bitfieldMan->getTotalLength()) {
     bitfieldMan->setAllBit();
   } else {
-    int32_t numPiece = length/bitfieldMan->getBlockLength();
+    size_t numPiece = length/bitfieldMan->getBlockLength();
     if(numPiece > 0) {
       bitfieldMan->setBitRange(0, numPiece-1);
     }
-    int32_t r = (length%bitfieldMan->getBlockLength())/Piece::BLOCK_LENGTH;
+    size_t r = (length%bitfieldMan->getBlockLength())/Piece::BLOCK_LENGTH;
     if(r > 0) {
       PieceHandle p = new Piece(numPiece, bitfieldMan->getBlockLength(numPiece));
-      for(int32_t i = 0; i < r; ++i) {
+      for(size_t i = 0; i < r; ++i) {
 	p->completeBlock(i);
       }
       addUsedPiece(p);
@@ -542,7 +552,7 @@ void DefaultPieceStorage::markPiecesDone(int64_t length)
   }
 }
 
-void DefaultPieceStorage::markPieceMissing(int32_t index)
+void DefaultPieceStorage::markPieceMissing(size_t index)
 {
   bitfieldMan->unsetBit(index);
 }
@@ -552,7 +562,7 @@ void DefaultPieceStorage::addInFlightPiece(const Pieces& pieces)
   std::copy(pieces.begin(), pieces.end(), std::back_inserter(usedPieces));
 }
 
-int32_t DefaultPieceStorage::countInFlightPiece()
+size_t DefaultPieceStorage::countInFlightPiece()
 {
   return usedPieces.size();
 }

src/DefaultPieceStorage.h

@@ -51,10 +51,10 @@ class FileEntry;
 class HaveEntry {
 private:
   int32_t cuid;
-  int32_t index;
+  size_t index;
   Time registeredTime;
 public:
-  HaveEntry(int32_t cuid, int32_t index):
+  HaveEntry(int32_t cuid, size_t index):
     cuid(cuid),
     index(index) {}
 
@@ -74,20 +74,20 @@ private:
   SharedHandle<DiskAdaptor> diskAdaptor;
   SharedHandle<DiskWriterFactory> _diskWriterFactory;
   std::deque<SharedHandle<Piece> > usedPieces;
-  int32_t endGamePieceNum;
+  size_t endGamePieceNum;
   Logger* logger;
   const Option* option;
   Haves haves;
-
-  int32_t getMissingPieceIndex(const SharedHandle<Peer>& peer);
-  int32_t getMissingFastPieceIndex(const SharedHandle<Peer>& peer);
-  SharedHandle<Piece> checkOutPiece(int32_t index);
-  int32_t deleteUsedPiecesByFillRate(int32_t fillRate, int32_t toDelete);
-  void reduceUsedPieces(int32_t delMax);
+  
+  bool getMissingPieceIndex(size_t& index, const SharedHandle<Peer>& peer);
+  bool getMissingFastPieceIndex(size_t& index, const SharedHandle<Peer>& peer);
+  SharedHandle<Piece> checkOutPiece(size_t index);
+  size_t deleteUsedPiecesByFillRate(int fillRate, size_t toDelete);
+  void reduceUsedPieces(size_t delMax);
   void deleteUsedPiece(const SharedHandle<Piece>& piece);
-  SharedHandle<Piece> findUsedPiece(int32_t index) const;
+  SharedHandle<Piece> findUsedPiece(size_t index) const;
 
-  int32_t getInFlightPieceCompletedLength() const;
+  size_t getInFlightPieceCompletedLength() const;
 
 public:
   DefaultPieceStorage(const SharedHandle<DownloadContext>& downloadContext, const Option* option);
@@ -101,25 +101,25 @@ public:
 
   virtual SharedHandle<Piece> getMissingPiece();
 
-  virtual SharedHandle<Piece> getMissingPiece(int32_t index);
+  virtual SharedHandle<Piece> getMissingPiece(size_t index);
 
-  virtual SharedHandle<Piece> getPiece(int32_t index);
+  virtual SharedHandle<Piece> getPiece(size_t index);
 
   virtual void completePiece(const SharedHandle<Piece>& piece);
 
   virtual void cancelPiece(const SharedHandle<Piece>& piece);
 
-  virtual bool hasPiece(int32_t index);
+  virtual bool hasPiece(size_t index);
 
-  virtual bool isPieceUsed(int32_t index);
+  virtual bool isPieceUsed(size_t index);
 
-  virtual int64_t getTotalLength();
+  virtual uint64_t getTotalLength();
 
-  virtual int64_t getFilteredTotalLength();
+  virtual uint64_t getFilteredTotalLength();
 
-  virtual int64_t getCompletedLength();
+  virtual uint64_t getCompletedLength();
 
-  virtual int64_t getFilteredCompletedLength();
+  virtual uint64_t getFilteredCompletedLength();
 
   virtual void initStorage();
 
@@ -134,17 +134,17 @@ public:
   virtual bool allDownloadFinished();
 
   virtual void setBitfield(const unsigned char* bitfield,
-			   int32_t bitfieldLength);
+			   size_t bitfieldLength);
   
-  virtual int32_t getBitfieldLength();
+  virtual size_t getBitfieldLength();
 
   virtual const unsigned char* getBitfield();
 
-  void setEndGamePieceNum(int32_t num) {
+  void setEndGamePieceNum(size_t num) {
     endGamePieceNum = num;
   }
 
-  int32_t getEndGamePieceNum() const {
+  size_t getEndGamePieceNum() const {
     return endGamePieceNum;
   }
 
@@ -156,24 +156,24 @@ public:
   
   virtual SharedHandle<DiskAdaptor> getDiskAdaptor();
 
-  virtual int32_t getPieceLength(int32_t index);
+  virtual size_t getPieceLength(size_t index);
 
-  virtual void advertisePiece(int32_t cuid, int32_t index);
+  virtual void advertisePiece(int32_t cuid, size_t index);
 
-  virtual std::deque<int32_t> getAdvertisedPieceIndexes(int32_t myCuid,
-							const Time& lastCheckTime);
+  virtual std::deque<size_t>
+  getAdvertisedPieceIndexes(int32_t myCuid, const Time& lastCheckTime);
 
-  virtual void removeAdvertisedPiece(int32_t elapsed);
+  virtual void removeAdvertisedPiece(time_t elapsed);
 
   virtual void markAllPiecesDone();
 
-  virtual void markPiecesDone(int64_t length);
+  virtual void markPiecesDone(uint64_t length);
 
-  virtual void markPieceMissing(int32_t index);
+  virtual void markPieceMissing(size_t index);
 
   virtual void addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces);
 
-  virtual int32_t countInFlightPiece();
+  virtual size_t countInFlightPiece();
 
   virtual std::deque<SharedHandle<Piece> > getInFlightPieces();
 

src/DownloadCommand.cc

@@ -109,7 +109,7 @@ bool DownloadCommand::executeInternal() {
   setReadCheckSocket(socket);
   SegmentHandle segment = _segments.front();
 
-  int32_t BUFSIZE = 16*1024;
+  size_t BUFSIZE = 16*1024;
   unsigned char buf[BUFSIZE];
   int32_t bufSize;
   if(segment->getLength() > 0 && segment->getLength()-segment->getWrittenLength() < BUFSIZE) {

src/GrowSegment.cc

@@ -42,7 +42,7 @@ GrowSegment::GrowSegment(const PieceHandle& piece):
 
 GrowSegment::~GrowSegment() {}
 
-void GrowSegment::updateWrittenLength(int32_t bytes)
+void GrowSegment::updateWrittenLength(size_t bytes)
 {
   _writtenLength += bytes;
   _piece->reconfigure(_writtenLength);

src/GrowSegment.h

@@ -42,7 +42,7 @@ namespace aria2 {
 class GrowSegment:public Segment {
 private:
   SharedHandle<Piece> _piece;
-  int32_t _writtenLength;
+  size_t _writtenLength;
 public:
   GrowSegment(const SharedHandle<Piece>& piece);
 
@@ -53,42 +53,42 @@ public:
     return false;
   }
 
-  virtual int32_t getIndex() const
+  virtual size_t getIndex() const
   {
     return 0;
   }
 
-  virtual int64_t getPosition() const
+  virtual off_t getPosition() const
   {
     return 0;
   }
   
-  virtual int64_t getPositionToWrite() const
+  virtual off_t getPositionToWrite() const
   {
     return _writtenLength;
   }
 
-  virtual int32_t getLength() const
+  virtual size_t getLength() const
   {
     return 0;
   }
 
-  virtual int32_t getSegmentLength() const
+  virtual size_t getSegmentLength() const
   {
     return 0;
   }
 
-  virtual int32_t getWrittenLength() const
+  virtual size_t getWrittenLength() const
   {
     return _writtenLength;
   }
 
-  virtual int32_t getOverflowLength() const
+  virtual size_t getOverflowLength() const
   {
     return 0;
   }
 
-  virtual void updateWrittenLength(int32_t bytes);
+  virtual void updateWrittenLength(size_t bytes);
 
   virtual void clear();
 

src/Piece.cc

@@ -41,7 +41,7 @@ namespace aria2 {
 
 Piece::Piece():index(0), length(0), _blockLength(BLOCK_LENGTH), bitfield(0) {}
 
-Piece::Piece(int32_t index, int32_t length, int32_t blockLength):index(index), length(length), _blockLength(blockLength) {
+Piece::Piece(size_t index, size_t length, size_t blockLength):index(index), length(length), _blockLength(blockLength) {
   bitfield =
     BitfieldManFactory::getFactoryInstance()->createBitfieldMan(_blockLength, length);
 }
@@ -82,7 +82,7 @@ bool Piece::operator==(const Piece& piece) const
   return index == piece.index;
 }
 
-void Piece::completeBlock(int32_t blockIndex) {
+void Piece::completeBlock(size_t blockIndex) {
   bitfield->setBit(blockIndex);
   bitfield->unsetUseBit(blockIndex);
 }
@@ -100,17 +100,17 @@ bool Piece::pieceComplete() const {
   return bitfield->isAllBitSet();
 }
 
-int32_t Piece::countBlock() const
+size_t Piece::countBlock() const
 {
   return bitfield->countBlock();
 }
 
-int32_t Piece::getBlockLength(int32_t index) const
+size_t Piece::getBlockLength(size_t index) const
 {
   return bitfield->getBlockLength(index);
 }
 
-int32_t Piece::getBlockLength() const
+size_t Piece::getBlockLength() const
 {
   return bitfield->getBlockLength();
 }
@@ -120,54 +120,56 @@ const unsigned char* Piece::getBitfield() const
   return bitfield->getBitfield();
 }
 
-int32_t Piece::getBitfieldLength() const
+size_t Piece::getBitfieldLength() const
 {
   return bitfield->getBitfieldLength();
 }
 
-bool Piece::isBlockUsed(int32_t index) const
+bool Piece::isBlockUsed(size_t index) const
 {
   return bitfield->isUseBitSet(index);
 }
 
-void Piece::cancelBlock(int32_t blockIndex) {
+void Piece::cancelBlock(size_t blockIndex) {
   bitfield->unsetUseBit(blockIndex);
 }
 
-int32_t Piece::countCompleteBlock() const
+size_t Piece::countCompleteBlock() const
 {
   return bitfield->countBlock()-bitfield->countMissingBlock();
 }
 
-bool Piece::hasBlock(int32_t blockIndex) const
+bool Piece::hasBlock(size_t blockIndex) const
 {
   return bitfield->isBitSet(blockIndex);
 }
 
-int32_t Piece::getMissingUnusedBlockIndex() const {
-  int32_t blockIndex = bitfield->getFirstMissingUnusedIndex();
-  if(blockIndex == -1) {
-    return blockIndex;
+bool Piece::getMissingUnusedBlockIndex(size_t& index) const
+{
+  if(bitfield->getFirstMissingUnusedIndex(index)) {
+    bitfield->setUseBit(index);
+    return true;
+  } else {
+    return false;
   }
-  bitfield->setUseBit(blockIndex);
-  return blockIndex;
 }
 
-int32_t Piece::getMissingBlockIndex() const {
-  int32_t blockIndex = bitfield->getMissingIndex();
-  if(blockIndex == -1) {
-    return blockIndex;
+bool Piece::getMissingBlockIndex(size_t& index) const
+{
+  if(bitfield->getMissingIndex(index)) {
+    bitfield->setUseBit(index);
+    return true;
+  } else {
+    return false;
   }
-  bitfield->setUseBit(blockIndex);
-  return blockIndex;
 }
 
-int32_t Piece::getFirstMissingBlockIndexWithoutLock() const
+bool Piece::getFirstMissingBlockIndexWithoutLock(size_t& index) const
 {
-  return bitfield->getFirstMissingIndex();
+  return bitfield->getFirstMissingIndex(index);
 }
 
-std::deque<int32_t> Piece::getAllMissingBlockIndexes() const {
+std::deque<size_t> Piece::getAllMissingBlockIndexes() const {
   return bitfield->getAllMissingIndexes();
 }
 
@@ -175,7 +177,7 @@ std::string Piece::toString() const {
   return "piece: index="+Util::itos(index)+", length="+Util::itos(length);
 }
 
-void Piece::reconfigure(int32_t length)
+void Piece::reconfigure(size_t length)
 {
   delete bitfield;
   this->length = length;
@@ -183,12 +185,12 @@ void Piece::reconfigure(int32_t length)
     BitfieldManFactory::getFactoryInstance()->createBitfieldMan(_blockLength, length);
 }
 
-void Piece::setBitfield(const unsigned char* bitfield, int32_t len)
+void Piece::setBitfield(const unsigned char* bitfield, size_t len)
 {
   this->bitfield->setBitfield(bitfield, len);
 }
 
-int32_t Piece::getCompletedLength()
+size_t Piece::getCompletedLength()
 {
   return bitfield->getCompletedLength();
 }

src/Piece.h

@@ -47,17 +47,17 @@ class BitfieldMan;
 
 class Piece {
 private:
-  int32_t index;
-  int32_t length;
-  int32_t _blockLength;
+  size_t index;
+  size_t length;
+  size_t _blockLength;
   BitfieldMan* bitfield;
 public:
 
-  static const int32_t BLOCK_LENGTH  = 16*1024;
+  static const size_t BLOCK_LENGTH  = 16*1024;
 
   Piece();
 
-  Piece(int32_t index, int32_t length, int32_t blockLength = BLOCK_LENGTH);
+  Piece(size_t index, size_t length, size_t blockLength = BLOCK_LENGTH);
 
   Piece(const Piece& piece);
 
@@ -67,16 +67,16 @@ public:
   
   bool operator==(const Piece& piece) const;
 
-  int32_t getMissingUnusedBlockIndex() const;
-  int32_t getMissingBlockIndex() const;
-  int32_t getFirstMissingBlockIndexWithoutLock() const;
-  std::deque<int32_t> getAllMissingBlockIndexes() const;
-  void completeBlock(int32_t blockIndex);
-  void cancelBlock(int32_t blockIndex);
+  bool getMissingUnusedBlockIndex(size_t& index) const;
+  bool getMissingBlockIndex(size_t& index) const;
+  bool getFirstMissingBlockIndexWithoutLock(size_t& index) const;
+  std::deque<size_t> getAllMissingBlockIndexes() const;
+  void completeBlock(size_t blockIndex);
+  void cancelBlock(size_t blockIndex);
 
-  int32_t countCompleteBlock() const;
+  size_t countCompleteBlock() const;
 
-  bool hasBlock(int32_t blockIndex) const;
+  bool hasBlock(size_t blockIndex) const;
 
   /**
    * Returns true if all blocks of this piece have been downloaded, otherwise
@@ -84,40 +84,40 @@ public:
    */
   bool pieceComplete() const;
 
-  int32_t countBlock() const;
+  size_t countBlock() const;
 
-  int32_t getBlockLength(int32_t index) const;
+  size_t getBlockLength(size_t index) const;
 
-  int32_t getBlockLength() const;
+  size_t getBlockLength() const;
 
-  int32_t getIndex() const { return index; }
+  size_t getIndex() const { return index; }
 
-  void setIndex(int32_t index) { this->index = index; }
+  void setIndex(size_t index) { this->index = index; }
 
-  int32_t getLength() const { return length; }
+  size_t getLength() const { return length; }
 
-  void setLength(int32_t index) { this->length = length; }
+  void setLength(size_t index) { this->length = length; }
 
   const unsigned char* getBitfield() const;
 
-  void setBitfield(const unsigned char* bitfield, int32_t len);
+  void setBitfield(const unsigned char* bitfield, size_t len);
 
-  int32_t getBitfieldLength() const;
+  size_t getBitfieldLength() const;
 
   void clearAllBlock();
   void setAllBlock();
 
   std::string toString() const;
 
-  bool isBlockUsed(int32_t index) const;
+  bool isBlockUsed(size_t index) const;
 
   // Calculates completed length
-  int32_t getCompletedLength();
+  size_t getCompletedLength();
 
   /**
    * Loses current bitfield state.
    */
-  void reconfigure(int32_t length);
+  void reconfigure(size_t length);
 };
 
 typedef SharedHandle<Piece> PieceHandle;

src/PieceStorage.h

@@ -88,18 +88,18 @@ public:
    * then returns 0.
    * Also returns 0 if any of missing piece is not available.
    */
-  virtual SharedHandle<Piece> getMissingPiece(int32_t index) = 0;
+  virtual SharedHandle<Piece> getMissingPiece(size_t index) = 0;
 
   /**
    * Returns the piece denoted by index.
    * No status of the piece is changed in this method.
    */
-  virtual SharedHandle<Piece> getPiece(int32_t index) = 0;
+  virtual SharedHandle<Piece> getPiece(size_t index) = 0;
 
   /**
    * Marks the piece whose index is index as missing.
    */
-  virtual void markPieceMissing(int32_t index) = 0;
+  virtual void markPieceMissing(size_t index) = 0;
 
   /**
    * Tells that the download of the specfied piece completes.
@@ -115,17 +115,17 @@ public:
    * Returns true if the specified piece is already downloaded.
    * Otherwise returns false.
    */
-  virtual bool hasPiece(int32_t index) = 0;
+  virtual bool hasPiece(size_t index) = 0;
 
-  virtual bool isPieceUsed(int32_t index) = 0;
+  virtual bool isPieceUsed(size_t index) = 0;
 
-  virtual int64_t getTotalLength() = 0;
+  virtual uint64_t getTotalLength() = 0;
 
-  virtual int64_t getFilteredTotalLength() = 0;
+  virtual uint64_t getFilteredTotalLength() = 0;
 
-  virtual int64_t getCompletedLength() = 0;
+  virtual uint64_t getCompletedLength() = 0;
 
-  virtual int64_t getFilteredCompletedLength() = 0;
+  virtual uint64_t getFilteredCompletedLength() = 0;
   
   virtual void setFileFilter(const std::deque<std::string>& filePaths) = 0;
 
@@ -155,9 +155,9 @@ public:
   virtual const unsigned char* getBitfield() = 0;
 
   virtual void setBitfield(const unsigned char* bitfield,
-			   int32_t bitfieldLength) = 0;
+			   size_t bitfieldLength) = 0;
   
-  virtual int32_t getBitfieldLength() = 0;
+  virtual size_t getBitfieldLength() = 0;
 
   virtual bool isSelectiveDownloadingMode() = 0;
 
@@ -167,26 +167,26 @@ public:
 
   virtual SharedHandle<DiskAdaptor> getDiskAdaptor() = 0;
   
-  virtual int32_t getPieceLength(int32_t index) = 0;
+  virtual size_t getPieceLength(size_t index) = 0;
 
   /**
    * Adds piece index to advertise to other commands. They send have message
    * based on this information.
    */
-  virtual void advertisePiece(int32_t cuid, int32_t index) = 0;
+  virtual void advertisePiece(int32_t cuid, size_t index) = 0;
 
   /**
    * Returns piece index which is not advertised by the caller command and
    * newer than lastCheckTime.
    */
-  virtual std::deque<int32_t>
+  virtual std::deque<size_t>
   getAdvertisedPieceIndexes(int32_t myCuid, const Time& lastCheckTime) = 0;
 
   /**
    * Removes have entry if specified seconds have elapsed since its
    * registration.
    */
-  virtual void removeAdvertisedPiece(int32_t elapsed) = 0;
+  virtual void removeAdvertisedPiece(time_t elapsed) = 0;
 
   /**
    * Sets all bits in bitfield to 1.
@@ -196,12 +196,12 @@ public:
   /**
    * Sets all bits in bitfield(0 to length) to 1.
    */
-  virtual void markPiecesDone(int64_t length) = 0;
+  virtual void markPiecesDone(uint64_t length) = 0;
 
   virtual void
   addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces) = 0;
 
-  virtual int32_t countInFlightPiece() = 0;
+  virtual size_t countInFlightPiece() = 0;
 
   virtual std::deque<SharedHandle<Piece> > getInFlightPieces() = 0;
 };

src/PiecedSegment.cc

@@ -34,12 +34,18 @@
 /* copyright --> */
 #include "PiecedSegment.h"
 #include "Piece.h"
+#include <cassert>
 
 namespace aria2 {
 
-PiecedSegment::PiecedSegment(int32_t pieceLength, const PieceHandle& piece):
-  _pieceLength(pieceLength), _overflowLength(0), _piece(piece),
-  _writtenLength(_piece->getFirstMissingBlockIndexWithoutLock()*_piece->getBlockLength()) {}
+PiecedSegment::PiecedSegment(size_t pieceLength, const PieceHandle& piece):
+  _pieceLength(pieceLength), _overflowLength(0), _piece(piece)
+{
+  size_t index;
+  bool t = _piece->getFirstMissingBlockIndexWithoutLock(index);
+  assert(t);
+  _writtenLength = index*_piece->getBlockLength();
+}
 
 PiecedSegment::~PiecedSegment() {}
 
@@ -48,34 +54,34 @@ bool PiecedSegment::complete() const
   return _piece->pieceComplete();
 }
 
-int32_t PiecedSegment::getIndex() const
+size_t PiecedSegment::getIndex() const
 {
   return _piece->getIndex();
 }
 
-int64_t PiecedSegment::getPosition() const
+off_t PiecedSegment::getPosition() const
 {
-  return ((int64_t)_piece->getIndex())*_pieceLength;
+  return ((off_t)_piece->getIndex())*_pieceLength;
 }
 
-int64_t PiecedSegment::getPositionToWrite() const
+off_t PiecedSegment::getPositionToWrite() const
 {
   return getPosition()+_writtenLength;
 }
 
-int32_t PiecedSegment::getLength() const
+size_t PiecedSegment::getLength() const
 {
   return _piece->getLength();
 }
 
-void PiecedSegment::updateWrittenLength(int32_t bytes)
+void PiecedSegment::updateWrittenLength(size_t bytes)
 {
-  int32_t newWrittenLength = _writtenLength+bytes;
+  size_t newWrittenLength = _writtenLength+bytes;
   if(newWrittenLength > _piece->getLength()) {
     _overflowLength = newWrittenLength-_piece->getLength();
     newWrittenLength = _piece->getLength();
   }
-  for(int32_t i = _writtenLength/_piece->getBlockLength(); i < newWrittenLength/_piece->getBlockLength(); ++i) {
+  for(size_t i = _writtenLength/_piece->getBlockLength(); i < newWrittenLength/_piece->getBlockLength(); ++i) {
     _piece->completeBlock(i);
   }
   if(newWrittenLength == _piece->getLength()) {

src/PiecedSegment.h

@@ -45,42 +45,42 @@ private:
    * Piece class has length property but it is a actual length of piece.
    * The last piece likely have shorter length than the other length.
    */
-  int32_t _pieceLength;
-  int32_t _overflowLength;
+  size_t _pieceLength;
+  size_t _overflowLength;
   SharedHandle<Piece> _piece;
-  int32_t _writtenLength;
+  size_t _writtenLength;
 
 public:
-  PiecedSegment(int32_t pieceLength, const SharedHandle<Piece>& piece);
+  PiecedSegment(size_t pieceLength, const SharedHandle<Piece>& piece);
 
   virtual ~PiecedSegment();
 
   virtual bool complete() const;
 
-  virtual int32_t getIndex() const;
+  virtual size_t getIndex() const;
 
-  virtual int64_t getPosition() const;
+  virtual off_t getPosition() const;
 
-  virtual int64_t getPositionToWrite() const;
+  virtual off_t getPositionToWrite() const;
 
-  virtual int32_t getLength() const;
+  virtual size_t getLength() const;
 
-  virtual int32_t getSegmentLength() const
+  virtual size_t getSegmentLength() const
   {
     return _pieceLength;
   }
 
-  virtual int32_t getWrittenLength() const
+  virtual size_t getWrittenLength() const
   {
     return _writtenLength;
   }
 
-  virtual int32_t getOverflowLength() const
+  virtual size_t getOverflowLength() const
   {
     return _overflowLength;
   }
 
-  virtual void updateWrittenLength(int32_t bytes);
+  virtual void updateWrittenLength(size_t bytes);
 
   virtual void clear();
 

src/Segment.h

@@ -50,21 +50,21 @@ public:
 
   virtual bool complete() const = 0;
 
-  virtual int32_t getIndex() const = 0;
+  virtual size_t getIndex() const = 0;
 
-  virtual int64_t getPosition() const = 0;
+  virtual off_t getPosition() const = 0;
   
-  virtual int64_t getPositionToWrite() const = 0;
+  virtual off_t getPositionToWrite() const = 0;
 
-  virtual int32_t getLength() const = 0;
+  virtual size_t getLength() const = 0;
 
-  virtual int32_t getSegmentLength() const = 0;
+  virtual size_t getSegmentLength() const = 0;
 
-  virtual int32_t getWrittenLength() const = 0;
+  virtual size_t getWrittenLength() const = 0;
 
-  virtual int32_t getOverflowLength() const = 0;
+  virtual size_t getOverflowLength() const = 0;
 
-  virtual void updateWrittenLength(int32_t bytes) = 0;
+  virtual void updateWrittenLength(size_t bytes) = 0;
 
   virtual void clear() = 0;
 

src/UnknownLengthPieceStorage.cc

@@ -83,7 +83,7 @@ PieceHandle UnknownLengthPieceStorage::getMissingPiece()
   }
 }
 
-PieceHandle UnknownLengthPieceStorage::getMissingPiece(int32_t index)
+PieceHandle UnknownLengthPieceStorage::getMissingPiece(size_t index)
 {
   if(index == 0) {
     return getMissingPiece();
@@ -92,7 +92,7 @@ PieceHandle UnknownLengthPieceStorage::getMissingPiece(int32_t index)
   }
 }
 
-PieceHandle UnknownLengthPieceStorage::getPiece(int32_t index)
+PieceHandle UnknownLengthPieceStorage::getPiece(size_t index)
 {
   if(index == 0) {
     if(_piece.isNull()) {
@@ -122,7 +122,7 @@ void UnknownLengthPieceStorage::cancelPiece(const PieceHandle& piece)
   }
 }
 
-bool UnknownLengthPieceStorage::hasPiece(int32_t index)
+bool UnknownLengthPieceStorage::hasPiece(size_t index)
 {
   if(index == 0 && _downloadFinished) {
     return true;
@@ -131,7 +131,7 @@ bool UnknownLengthPieceStorage::hasPiece(int32_t index)
   }
 }
 
-bool UnknownLengthPieceStorage::isPieceUsed(int32_t index)
+bool UnknownLengthPieceStorage::isPieceUsed(size_t index)
 {
   if(index == 0 && !_piece.isNull()) {
     return true;
@@ -145,7 +145,7 @@ DiskAdaptorHandle UnknownLengthPieceStorage::getDiskAdaptor()
   return _diskAdaptor;
 }
 
-int32_t UnknownLengthPieceStorage::getPieceLength(int32_t index)
+size_t UnknownLengthPieceStorage::getPieceLength(size_t index)
 {
   if(index == 0) {
     return _totalLength;

src/UnknownLengthPieceStorage.h

@@ -54,7 +54,7 @@ private:
 
   SharedHandle<DiskWriterFactory> _diskWriterFactory;
 
-  int64_t _totalLength;
+  uint64_t _totalLength;
 
   bool _downloadFinished;
 
@@ -106,13 +106,13 @@ public:
    * then returns 0.
    * Also returns 0 if any of missing piece is not available.
    */
-  virtual SharedHandle<Piece> getMissingPiece(int32_t index);
+  virtual SharedHandle<Piece> getMissingPiece(size_t index);
 
   /**
    * Returns the piece denoted by index.
    * No status of the piece is changed in this method.
    */
-  virtual SharedHandle<Piece> getPiece(int32_t index);
+  virtual SharedHandle<Piece> getPiece(size_t index);
 
   /**
    * Tells that the download of the specfied piece completes.
@@ -128,27 +128,27 @@ public:
    * Returns true if the specified piece is already downloaded.
    * Otherwise returns false.
    */
-  virtual bool hasPiece(int32_t index);
+  virtual bool hasPiece(size_t index);
 
-  virtual bool isPieceUsed(int32_t index);
+  virtual bool isPieceUsed(size_t index);
 
-  virtual int64_t getTotalLength()
+  virtual uint64_t getTotalLength()
   {
     return _totalLength;
   }
 
-  virtual int64_t getFilteredTotalLength()
+  virtual uint64_t getFilteredTotalLength()
   {
     return _totalLength;
   }
 
-  virtual int64_t getCompletedLength()
+  virtual uint64_t getCompletedLength()
   {
     // TODO we have to return actual completed length here?
     return _totalLength;
   }
 
-  virtual int64_t getFilteredCompletedLength()
+  virtual uint64_t getFilteredCompletedLength()
   {
     return getCompletedLength();
   }
@@ -190,9 +190,9 @@ public:
   }
 
   virtual void setBitfield(const unsigned char* bitfield,
-			   int32_t bitfieldLength) {}
+			   size_t bitfieldLength) {}
   
-  virtual int32_t getBitfieldLength()
+  virtual size_t getBitfieldLength()
   {
     return 0;
   }
@@ -211,42 +211,42 @@ public:
 
   virtual SharedHandle<DiskAdaptor> getDiskAdaptor();
   
-  virtual int32_t getPieceLength(int32_t index);
+  virtual size_t getPieceLength(size_t index);
 
   /**
    * Adds piece index to advertise to other commands. They send have message
    * based on this information.
    */
-  virtual void advertisePiece(int32_t cuid, int32_t index) {}
+  virtual void advertisePiece(int32_t cuid, size_t index) {}
 
   /**
    * Returns piece index which is not advertised by the caller command and
    * newer than lastCheckTime.
    */
-  virtual std::deque<int32_t>
+  virtual std::deque<size_t>
   getAdvertisedPieceIndexes(int32_t myCuid, const Time& lastCheckTime)
   {
-    return std::deque<int32_t>();
+    return std::deque<size_t>();
   }
 
   /**
    * Removes have entry if specified seconds have elapsed since its
    * registration.
    */
-  virtual void removeAdvertisedPiece(int32_t elapsed) {}
+  virtual void removeAdvertisedPiece(time_t elapsed) {}
 
   /**
    * Sets all bits in bitfield to 1.
    */
   virtual void markAllPiecesDone();
 
-  virtual void markPiecesDone(int64_t length)
+  virtual void markPiecesDone(uint64_t length)
   {
     // TODO not implemented yet
     abort();
   }
 
-  virtual void markPieceMissing(int32_t index)
+  virtual void markPieceMissing(size_t index)
   {
     // TODO not implemented yet
     abort();
@@ -258,7 +258,7 @@ public:
    */
   virtual void addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces) {}
 
-  virtual int32_t countInFlightPiece()
+  virtual size_t countInFlightPiece()
   {
     return 0;
   }

src/Util.cc

@@ -762,8 +762,9 @@ void Util::mkdirs(const std::string& dirpath)
 
 void Util::convertBitfield(BitfieldMan* dest, const BitfieldMan* src)
 {
-  for(int32_t index = 0; index < dest->countBlock(); ++index) {
-    if(src->isBitSetOffsetRange((int64_t)index*dest->getBlockLength(),
+  size_t numBlock = dest->countBlock();
+  for(size_t index = 0; index < numBlock; ++index) {
+    if(src->isBitSetOffsetRange((uint64_t)index*dest->getBlockLength(),
 				dest->getBlockLength())) {
       dest->setBit(index);
     }

test/BitfieldManTest.cc

@@ -63,38 +63,64 @@ CPPUNIT_TEST_SUITE_REGISTRATION( BitfieldManTest );
 
 void BitfieldManTest::testGetBlockSize() {
   BitfieldMan bt1(1024, 1024*10);
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, bt1.getBlockLength(9));
+  CPPUNIT_ASSERT_EQUAL((size_t)1024, bt1.getBlockLength(9));
 
   BitfieldMan bt2(1024, 1024*10+1);
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, bt2.getBlockLength(9));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, bt2.getBlockLength(10));
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, bt2.getBlockLength(11));
+  CPPUNIT_ASSERT_EQUAL((size_t)1024, bt2.getBlockLength(9));
+  CPPUNIT_ASSERT_EQUAL((size_t)1, bt2.getBlockLength(10));
+  CPPUNIT_ASSERT_EQUAL((size_t)0, bt2.getBlockLength(11));
 }
 
 void BitfieldManTest::testGetFirstMissingUnusedIndex()
 {
   {
     BitfieldMan bt1(1024, 1024*10);
-    
-    CPPUNIT_ASSERT_EQUAL(0, bt1.getFirstMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)0, index);
+    }
     bt1.setUseBit(0);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.unsetUseBit(0);
     bt1.setBit(0);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setAllBit();
-    CPPUNIT_ASSERT_EQUAL(-1, bt1.getFirstMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(!bt1.getFirstMissingUnusedIndex(index));
+    }
   }
   {
     BitfieldMan bt1(1024, 1024*10);
 
     bt1.addFilter(1024, 1024*10);
     bt1.enableFilter();
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setUseBit(1);
-    CPPUNIT_ASSERT_EQUAL(2, bt1.getFirstMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)2, index);
+    }
     bt1.setBit(2);
-    CPPUNIT_ASSERT_EQUAL(3, bt1.getFirstMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)3, index);
+    }
   }
 }
 
@@ -102,26 +128,52 @@ void BitfieldManTest::testGetFirstMissingIndex()
 {
   {
     BitfieldMan bt1(1024, 1024*10);
-    
-    CPPUNIT_ASSERT_EQUAL(0, bt1.getFirstMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)0, index);
+    }
     bt1.setUseBit(0);
-    CPPUNIT_ASSERT_EQUAL(0, bt1.getFirstMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)0, index);
+    }
     bt1.unsetUseBit(0);
     bt1.setBit(0);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setAllBit();
-    CPPUNIT_ASSERT_EQUAL(-1, bt1.getFirstMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(!bt1.getFirstMissingIndex(index));
+    }
   }
   {
     BitfieldMan bt1(1024, 1024*10);
 
     bt1.addFilter(1024, 1024*10);
     bt1.enableFilter();
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setUseBit(1);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getFirstMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setBit(1);
-    CPPUNIT_ASSERT_EQUAL(2, bt1.getFirstMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getFirstMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)2, index);
+    }
   }
 }
 
@@ -130,15 +182,29 @@ void BitfieldManTest::testGetMissingUnusedIndex_noarg()
   {
     BitfieldMan bt1(1024, 1024*10);
     bt1.setRandomizer(fixedNumberRandomizer);
-    
-    CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)0, index);
+    }
     bt1.setUseBit(0);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.unsetUseBit(0);
     bt1.setBit(0);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setAllBit();
-    CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index));
+    }
   }
   {
     BitfieldMan bt1(1024, 1024*10);
@@ -146,11 +212,23 @@ void BitfieldManTest::testGetMissingUnusedIndex_noarg()
 
     bt1.addFilter(1024, 1024*10);
     bt1.enableFilter();
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setUseBit(1);
-    CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)2, index);
+    }
     bt1.setBit(2);
-    CPPUNIT_ASSERT_EQUAL(3, bt1.getMissingUnusedIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)3, index);
+    }
   }
 }
 
@@ -159,15 +237,29 @@ void BitfieldManTest::testGetMissingIndex_noarg()
   {
     BitfieldMan bt1(1024, 1024*10);
     bt1.setRandomizer(fixedNumberRandomizer);
-
-    CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)0, index);
+    }
     bt1.setUseBit(0);
-    CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)0, index);
+    }
     bt1.unsetUseBit(0);
     bt1.setBit(0);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setAllBit();
-    CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(!bt1.getMissingIndex(index));
+    }
   }
   {
     BitfieldMan bt1(1024, 1024*10);
@@ -175,11 +267,23 @@ void BitfieldManTest::testGetMissingIndex_noarg()
 
     bt1.addFilter(1024, 1024*10);
     bt1.enableFilter();
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setUseBit(1);
-    CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    }
     bt1.setBit(1);
-    CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingIndex());
+    {
+      size_t index;
+      CPPUNIT_ASSERT(bt1.getMissingIndex(index));
+      CPPUNIT_ASSERT_EQUAL((size_t)2, index);
+    }
   }
 }
 
@@ -189,12 +293,12 @@ void BitfieldManTest::testIsAllBitSet() {
   bt1.setBit(1);
   CPPUNIT_ASSERT(!bt1.isAllBitSet());
   
-  for(int i = 0; i < 8; i++) {
+  for(size_t i = 0; i < 8; i++) {
     CPPUNIT_ASSERT(bt1.setBit(i));
   }
   CPPUNIT_ASSERT(!bt1.isAllBitSet());
 
-  for(int32_t i = 0; i < bt1.countBlock(); i++) {
+  for(size_t i = 0; i < bt1.countBlock(); i++) {
     CPPUNIT_ASSERT(bt1.setBit(i));
   }
   CPPUNIT_ASSERT(bt1.isAllBitSet());
@@ -213,29 +317,27 @@ void BitfieldManTest::testFilter() {
   unsigned char peerBt[2];
   memset(peerBt, 0xff, sizeof(peerBt));
 
-  int index;
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
-  btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(2, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  size_t index;
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(3, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  CPPUNIT_ASSERT_EQUAL((size_t)2, index);
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(4, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  CPPUNIT_ASSERT_EQUAL((size_t)3, index);
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(5, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  CPPUNIT_ASSERT_EQUAL((size_t)4, index);
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(6, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  CPPUNIT_ASSERT_EQUAL((size_t)5, index);
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(7, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  CPPUNIT_ASSERT_EQUAL((size_t)6, index);
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(-1, index);
-  CPPUNIT_ASSERT_EQUAL((int64_t)12, btman.getFilteredTotalLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)7, index);
+  CPPUNIT_ASSERT(!btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
+  CPPUNIT_ASSERT_EQUAL(12ULL, btman.getFilteredTotalLength());
 
   // test offset=5, length=2
   btman.clearAllBit();
@@ -243,24 +345,22 @@ void BitfieldManTest::testFilter() {
   btman.clearFilter();
   btman.addFilter(5, 2);
   btman.enableFilter();
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
   btman.setBit(index);
-  CPPUNIT_ASSERT_EQUAL(2, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
+  CPPUNIT_ASSERT_EQUAL((size_t)2, index);
+  CPPUNIT_ASSERT(btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
   btman.setUseBit(index);
   btman.setBit(index);
-  CPPUNIT_ASSERT_EQUAL(3, index);
-  index = btman.getMissingUnusedIndex(peerBt, sizeof(peerBt));
-  btman.setUseBit(index);
-  CPPUNIT_ASSERT_EQUAL(-1, index);
-  CPPUNIT_ASSERT_EQUAL((int64_t)4, btman.getFilteredTotalLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)3, index);
+  CPPUNIT_ASSERT(!btman.getMissingUnusedIndex(index, peerBt, sizeof(peerBt)));
+  CPPUNIT_ASSERT_EQUAL(4ULL, btman.getFilteredTotalLength());
   CPPUNIT_ASSERT(btman.isFilteredAllBitSet());
 
   BitfieldMan btman2(2, 31);
   btman2.addFilter(0, 31);
   btman2.enableFilter();
-  CPPUNIT_ASSERT_EQUAL((int64_t)31, btman2.getFilteredTotalLength());
+  CPPUNIT_ASSERT_EQUAL(31ULL, btman2.getFilteredTotalLength());
 
 }
 
@@ -278,11 +378,14 @@ void BitfieldManTest::testGetMissingIndex() {
     0xff, 0xff, 0xff, 0xff,
     0xff, 0xff, 0xff, 0xff,
   };
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, bt1.getMissingIndex(bitArray, 32));
+  size_t index;
+  CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray, 32));
+  CPPUNIT_ASSERT_EQUAL((size_t)0, index);
 
   bt1.addFilter(1024, 1024*256);
   bt1.enableFilter();
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, bt1.getMissingIndex(bitArray, 32));
+  CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray, 32));
+  CPPUNIT_ASSERT_EQUAL((size_t)1, index);
   bt1.disableFilter();
 
   unsigned char bitArray2[] = {
@@ -296,7 +399,8 @@ void BitfieldManTest::testGetMissingIndex() {
     0xff, 0xff, 0xff, 0xff,
   };
 
-  CPPUNIT_ASSERT_EQUAL((int32_t)4, bt1.getMissingIndex(bitArray2, 32));
+  CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray2, 32));
+  CPPUNIT_ASSERT_EQUAL((size_t)4, index);
 
   unsigned char bitArray3[] = {
     0x00, 0xff, 0xff, 0xff,
@@ -309,7 +413,8 @@ void BitfieldManTest::testGetMissingIndex() {
     0xff, 0xff, 0xff, 0xff,
   };
 
-  CPPUNIT_ASSERT_EQUAL((int32_t)8, bt1.getMissingIndex(bitArray3, 32));
+  CPPUNIT_ASSERT(bt1.getMissingIndex(index, bitArray3, 32));
+  CPPUNIT_ASSERT_EQUAL((size_t)8, index);
 
   unsigned char bitArray4[] = {
     0x00, 0x00, 0x00, 0x00,
@@ -322,71 +427,91 @@ void BitfieldManTest::testGetMissingIndex() {
     0x00, 0x00, 0x00, 0x00,
   };
 
-  CPPUNIT_ASSERT_EQUAL((int32_t)-1, bt1.getMissingIndex(bitArray4, 32));
+  CPPUNIT_ASSERT(!bt1.getMissingIndex(index, bitArray4, 32));
 
 }
 
 void BitfieldManTest::testGetSparceMissingUnusedIndex() {
   BitfieldMan bitfield(1024*1024, 10*1024*1024);
 
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, bitfield.getSparseMissingUnusedIndex());
+  size_t index;
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)0, index);
   bitfield.setUseBit(0);
-  CPPUNIT_ASSERT_EQUAL((int32_t)5, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)5, index);
   bitfield.setUseBit(5);
-  CPPUNIT_ASSERT_EQUAL((int32_t)3, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)3, index);
   bitfield.setUseBit(3);
-  CPPUNIT_ASSERT_EQUAL((int32_t)8, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)8, index);
   bitfield.setUseBit(8);
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)2, index);
   bitfield.setUseBit(2);
-  CPPUNIT_ASSERT_EQUAL((int32_t)7, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)7, index);
   bitfield.setUseBit(7);
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)1, index);
   bitfield.setUseBit(1);
-  CPPUNIT_ASSERT_EQUAL((int32_t)4, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)4, index);
   bitfield.setUseBit(4);
-  CPPUNIT_ASSERT_EQUAL((int32_t)6, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)6, index);
   bitfield.setUseBit(6);
-  CPPUNIT_ASSERT_EQUAL((int32_t)9, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)9, index);
   bitfield.setUseBit(9);
-  CPPUNIT_ASSERT_EQUAL((int32_t)-1, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(!bitfield.getSparseMissingUnusedIndex(index));
 }
 
 void BitfieldManTest::testGetSparceMissingUnusedIndex_setBit() {
   BitfieldMan bitfield(1024*1024, 10*1024*1024);
-
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, bitfield.getSparseMissingUnusedIndex());
+  size_t index;
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)0, index);
   bitfield.setBit(0);
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)1, index);
   bitfield.setBit(1);
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)2, index);
   bitfield.setBit(2);
-  CPPUNIT_ASSERT_EQUAL((int32_t)3, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)3, index);
   bitfield.setBit(3);
-  CPPUNIT_ASSERT_EQUAL((int32_t)4, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)4, index);
   bitfield.setBit(4);
-  CPPUNIT_ASSERT_EQUAL((int32_t)5, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)5, index);
   bitfield.setBit(5);
-  CPPUNIT_ASSERT_EQUAL((int32_t)6, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)6, index);
   bitfield.setBit(6);
-  CPPUNIT_ASSERT_EQUAL((int32_t)7, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)7, index);
   bitfield.setBit(7);
-  CPPUNIT_ASSERT_EQUAL((int32_t)8, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)8, index);
   bitfield.setBit(8);
-  CPPUNIT_ASSERT_EQUAL((int32_t)9, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(bitfield.getSparseMissingUnusedIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)9, index);
   bitfield.setBit(9);
-  CPPUNIT_ASSERT_EQUAL((int32_t)-1, bitfield.getSparseMissingUnusedIndex());
+  CPPUNIT_ASSERT(!bitfield.getSparseMissingUnusedIndex(index));
 }
 
 void BitfieldManTest::testIsBitSetOffsetRange()
 {
-  int64_t totalLength = (int64_t)4*1024*1024*1024;
+  int64_t totalLength = 4ULL*1024*1024*1024;
   int32_t pieceLength = 4*1024*1024;
   BitfieldMan bitfield(pieceLength, totalLength);
   bitfield.setAllBit();
 
   CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(0, 0));
-  CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(0, -1));
   CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(totalLength, 100));
   CPPUNIT_ASSERT(!bitfield.isBitSetOffsetRange(totalLength+1, 100));
 
@@ -412,91 +537,91 @@ void BitfieldManTest::testIsBitSetOffsetRange()
 
 void BitfieldManTest::testGetMissingUnusedLength()
 {
-  int64_t totalLength = 1024*10+10;
-  int32_t blockLength = 1024;
+  uint64_t totalLength = 1024*10+10;
+  size_t blockLength = 1024;
 
   BitfieldMan bf(blockLength, totalLength);
 
   // from index 0 and all blocks are unused and not acquired.
-  CPPUNIT_ASSERT_EQUAL((int64_t)totalLength, bf.getMissingUnusedLength(0));
+  CPPUNIT_ASSERT_EQUAL(totalLength, bf.getMissingUnusedLength(0));
 
   // from index 10 and all blocks are unused and not acquired.
-  CPPUNIT_ASSERT_EQUAL((int64_t)10, bf.getMissingUnusedLength(10));
+  CPPUNIT_ASSERT_EQUAL(10ULL, bf.getMissingUnusedLength(10));
 
   // from index -1
-  CPPUNIT_ASSERT_EQUAL((int64_t)0, bf.getMissingUnusedLength(-1));
+  CPPUNIT_ASSERT_EQUAL(0ULL, bf.getMissingUnusedLength(-1));
 
   // from index 11
-  CPPUNIT_ASSERT_EQUAL((int64_t)0, bf.getMissingUnusedLength(11));
+  CPPUNIT_ASSERT_EQUAL(0ULL, bf.getMissingUnusedLength(11));
 
   // from index 12
-  CPPUNIT_ASSERT_EQUAL((int64_t)0, bf.getMissingUnusedLength(12));
+  CPPUNIT_ASSERT_EQUAL(0ULL, bf.getMissingUnusedLength(12));
 
   // from index 0 and 5th block is used.
   bf.setUseBit(5);
-  CPPUNIT_ASSERT_EQUAL((int64_t)5*blockLength, bf.getMissingUnusedLength(0));
+  CPPUNIT_ASSERT_EQUAL(5ULL*blockLength, bf.getMissingUnusedLength(0));
 
   // from index 0 and 4th block is acquired.
   bf.setBit(4);
-  CPPUNIT_ASSERT_EQUAL((int64_t)4*blockLength, bf.getMissingUnusedLength(0));
+  CPPUNIT_ASSERT_EQUAL(4ULL*blockLength, bf.getMissingUnusedLength(0));
 
   // from index 1
-  CPPUNIT_ASSERT_EQUAL((int64_t)3*blockLength, bf.getMissingUnusedLength(1));
+  CPPUNIT_ASSERT_EQUAL(3ULL*blockLength, bf.getMissingUnusedLength(1));
 }
 
 void BitfieldManTest::testSetBitRange()
 {
-  int32_t blockLength = 1024*1024;
-  int64_t totalLength = 10*blockLength;
+  size_t blockLength = 1024*1024;
+  uint64_t totalLength = 10*blockLength;
 
   BitfieldMan bf(blockLength, totalLength);
 
   bf.setBitRange(0, 4);
 
-  for(int32_t i = 0; i < 5; ++i) {
+  for(size_t i = 0; i < 5; ++i) {
     CPPUNIT_ASSERT(bf.isBitSet(i));
   }
-  for(int32_t i = 5; i < 10; ++i) {
+  for(size_t i = 5; i < 10; ++i) {
     CPPUNIT_ASSERT(!bf.isBitSet(i));
   }
-  CPPUNIT_ASSERT_EQUAL(int64_t(5*blockLength), bf.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL(5ULL*blockLength, bf.getCompletedLength());
 }
 
 void BitfieldManTest::testGetAllMissingIndexes_noarg()
 {
-  int32_t blockLength = 16*1024;
-  int64_t totalLength = 1024*1024;
+  size_t blockLength = 16*1024;
+  uint64_t totalLength = 1024*1024;
   BitfieldMan bf(blockLength, totalLength);
 
   CPPUNIT_ASSERT_EQUAL((size_t)64, bf.getAllMissingIndexes().size());
-  for(int32_t i = 0; i < 63; ++i) {
+  for(size_t i = 0; i < 63; ++i) {
     bf.setBit(i);
   }
   CPPUNIT_ASSERT_EQUAL((size_t)1, bf.getAllMissingIndexes().size());
-  CPPUNIT_ASSERT_EQUAL(63, bf.getAllMissingIndexes().front());
+  CPPUNIT_ASSERT_EQUAL((size_t)63, bf.getAllMissingIndexes().front());
 }
 
 void BitfieldManTest::testGetAllMissingIndexes()
 {
-  int32_t blockLength = 16*1024;
-  int64_t totalLength = 1024*1024;
+  size_t blockLength = 16*1024;
+  uint64_t totalLength = 1024*1024;
   BitfieldMan bf(blockLength, totalLength);
   BitfieldMan peerBf(blockLength, totalLength);
   peerBf.setAllBit();
 
   CPPUNIT_ASSERT_EQUAL((size_t)64, bf.getAllMissingIndexes(peerBf.getBitfield(),
 							   peerBf.getBitfieldLength()).size());
-  for(int32_t i = 0; i < 62; ++i) {
+  for(size_t i = 0; i < 62; ++i) {
     bf.setBit(i);
   }
   peerBf.unsetBit(62);
 
   {
-    std::deque<int32_t> indexes = bf.getAllMissingIndexes(peerBf.getBitfield(),
-							  peerBf.getBitfieldLength());
+    std::deque<size_t> indexes = bf.getAllMissingIndexes(peerBf.getBitfield(),
+							 peerBf.getBitfieldLength());
     
     CPPUNIT_ASSERT_EQUAL((size_t)1, indexes.size());
-    CPPUNIT_ASSERT_EQUAL(63, indexes.front());
+    CPPUNIT_ASSERT_EQUAL((size_t)63, indexes.front());
   }
 }
 
@@ -504,62 +629,68 @@ void BitfieldManTest::testGetMissingUnusedIndex()
 {
   BitfieldMan bt1(1024, 1024*256);
   bt1.setRandomizer(fixedNumberRandomizer);
-
-  unsigned char bitArray[] = {
-    0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff,
-  };
-  CPPUNIT_ASSERT_EQUAL(0, bt1.getMissingUnusedIndex(bitArray, 32));
+  size_t index;
+  {
+    unsigned char bitArray[] = {
+      0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff,
+    };
+    CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
+    CPPUNIT_ASSERT_EQUAL((size_t)0, index);
   
-  bt1.addFilter(1024, 1024*256);
-  bt1.enableFilter();
-  CPPUNIT_ASSERT_EQUAL(1, bt1.getMissingUnusedIndex(bitArray, 32));
-  bt1.setUseBit(1);
-  CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingUnusedIndex(bitArray, 32));
-  bt1.disableFilter();
+    bt1.addFilter(1024, 1024*256);
+    bt1.enableFilter();
+    CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
+    CPPUNIT_ASSERT_EQUAL((size_t)1, index);
+    bt1.setUseBit(1);
+    CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
+    CPPUNIT_ASSERT_EQUAL((size_t)2, index);
+    bt1.disableFilter();
 
-  bt1.setBit(0);
-  CPPUNIT_ASSERT_EQUAL(2, bt1.getMissingUnusedIndex(bitArray, 32));
+    bt1.setBit(0);
+    CPPUNIT_ASSERT(bt1.getMissingUnusedIndex(index, bitArray, 32));
+    CPPUNIT_ASSERT_EQUAL((size_t)2, index);
 
-  bt1.setAllBit();
-  CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex(bitArray, 32));
+    bt1.setAllBit();
+    CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray, 32));
   
-  bt1.clearAllBit();
-  bt1.setAllUseBit();
-  CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex(bitArray, 32));
-
-  unsigned char bitArray4[] = {
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-  };
-
-  CPPUNIT_ASSERT_EQUAL(-1, bt1.getMissingUnusedIndex(bitArray4, 32));
+    bt1.clearAllBit();
+    bt1.setAllUseBit();
+    CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray, 32));
+  }
+  {
+    unsigned char bitArray4[] = {
+      0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+    };
+    CPPUNIT_ASSERT(!bt1.getMissingUnusedIndex(index, bitArray4, 32));
+  }
 }
 
 void BitfieldManTest::testCountFilteredBlock()
 {
   BitfieldMan bt(1024, 1024*256);
-  CPPUNIT_ASSERT_EQUAL(256, bt.countBlock());
-  CPPUNIT_ASSERT_EQUAL(0, bt.countFilteredBlock());
+  CPPUNIT_ASSERT_EQUAL((size_t)256, bt.countBlock());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, bt.countFilteredBlock());
   bt.addFilter(1024, 1024*256);
   bt.enableFilter();
-  CPPUNIT_ASSERT_EQUAL(256, bt.countBlock());
-  CPPUNIT_ASSERT_EQUAL(255, bt.countFilteredBlock());
+  CPPUNIT_ASSERT_EQUAL((size_t)256, bt.countBlock());
+  CPPUNIT_ASSERT_EQUAL((size_t)255, bt.countFilteredBlock());
   bt.disableFilter();
-  CPPUNIT_ASSERT_EQUAL(256, bt.countBlock());
-  CPPUNIT_ASSERT_EQUAL(0, bt.countFilteredBlock());
+  CPPUNIT_ASSERT_EQUAL((size_t)256, bt.countBlock());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, bt.countFilteredBlock());
 }
 
 } // namespace aria2

test/BtRequestMessageTest.cc

@@ -54,7 +54,7 @@ public:
 
   class MockPieceStorage2 : public MockPieceStorage {
   public:
-    virtual bool hasPiece(int index) {
+    virtual bool hasPiece(size_t index) {
       return index == 1;
     }
   };

test/DefaultBtMessageDispatcherTest.cc

@@ -111,7 +111,7 @@ public:
   private:
     SharedHandle<Piece> piece;
   public:
-    virtual SharedHandle<Piece> getPiece(int index) {
+    virtual SharedHandle<Piece> getPiece(size_t index) {
       return piece;
     }
 
@@ -281,7 +281,9 @@ void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing() {
   RequestSlot slot(0, 0, MY_PIECE_LENGTH, 0);
   
   SharedHandle<Piece> piece = new Piece(0, MY_PIECE_LENGTH);
-  assert(piece->getMissingUnusedBlockIndex() == 0);
+  size_t index;
+  CPPUNIT_ASSERT(piece->getMissingUnusedBlockIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)0, index);
 
   SharedHandle<MockPieceStorage2> pieceStorage = new MockPieceStorage2();
   pieceStorage->setPiece(piece);
@@ -308,7 +310,9 @@ void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing_tim
   slot.setDispatchedTime(0);
 
   SharedHandle<Piece> piece = new Piece(0, MY_PIECE_LENGTH);
-  assert(piece->getMissingUnusedBlockIndex() == 0);
+  size_t index;
+  CPPUNIT_ASSERT(piece->getMissingUnusedBlockIndex(index));
+  CPPUNIT_ASSERT_EQUAL((size_t)0, index);
 
   SharedHandle<MockPieceStorage2> pieceStorage = new MockPieceStorage2();
   pieceStorage->setPiece(piece);

test/DefaultBtProgressInfoFileTest.cc

@@ -110,22 +110,22 @@ void DefaultBtProgressInfoFileTest::testLoad()
 		       Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength()));
 
   // the number of in-flight pieces
-  CPPUNIT_ASSERT_EQUAL((int32_t)2,
+  CPPUNIT_ASSERT_EQUAL((size_t)2,
 		       _pieceStorage->countInFlightPiece());
 
   // piece index 1
   std::deque<SharedHandle<Piece> > inFlightPieces = _pieceStorage->getInFlightPieces();
   SharedHandle<Piece> piece1 = inFlightPieces[0];
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, piece1->getLength());
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getBitfieldLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)1024, piece1->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getBitfieldLength());
   CPPUNIT_ASSERT_EQUAL(std::string("00"), Util::toHex(piece1->getBitfield(),
 						 piece1->getBitfieldLength()));
 
   // piece index 2
   SharedHandle<Piece> piece2 = inFlightPieces[1];
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, piece2->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)512, piece2->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)2, piece2->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)512, piece2->getLength());
 }
 
 void DefaultBtProgressInfoFileTest::testLoad_nonBt()
@@ -146,22 +146,22 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt()
 		       Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength()));
 
   // the number of in-flight pieces
-  CPPUNIT_ASSERT_EQUAL((int32_t)2,
+  CPPUNIT_ASSERT_EQUAL((size_t)2,
 		       _pieceStorage->countInFlightPiece());
 
   // piece index 1
   std::deque<SharedHandle<Piece> > inFlightPieces = _pieceStorage->getInFlightPieces();
   SharedHandle<Piece> piece1 = inFlightPieces[0];
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, piece1->getLength());
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getBitfieldLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)1024, piece1->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getBitfieldLength());
   CPPUNIT_ASSERT_EQUAL(std::string("00"), Util::toHex(piece1->getBitfield(),
 						 piece1->getBitfieldLength()));
 
   // piece index 2
   SharedHandle<Piece> piece2 = inFlightPieces[1];
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, piece2->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)512, piece2->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)2, piece2->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)512, piece2->getLength());
 
 }
 
@@ -184,7 +184,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_pieceLengthShorter()
 		       Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength()));
 
   // the number of in-flight pieces
-  CPPUNIT_ASSERT_EQUAL((int32_t)0,
+  CPPUNIT_ASSERT_EQUAL((size_t)0,
 		       _pieceStorage->countInFlightPiece());
 }
 
@@ -224,47 +224,47 @@ void DefaultBtProgressInfoFileTest::testSave_nonBt()
   in.read((char*)extension, sizeof(extension));
   CPPUNIT_ASSERT_EQUAL(std::string("00000000"), Util::toHex(extension, sizeof(extension)));
 
-  int32_t infoHashLength;
+  uint32_t infoHashLength;
   in.read(reinterpret_cast<char*>(&infoHashLength), sizeof(infoHashLength));
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, infoHashLength);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)0, infoHashLength);
 
-  int32_t pieceLength;
+  uint32_t pieceLength;
   in.read((char*)&pieceLength, sizeof(pieceLength));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, pieceLength);
-
-  int64_t totalLength;
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1024, pieceLength);
+  
+  uint64_t totalLength;
   in.read((char*)&totalLength, sizeof(totalLength));
-  CPPUNIT_ASSERT_EQUAL((int64_t)81920/* 80*1024 */, totalLength);
+  CPPUNIT_ASSERT_EQUAL((uint64_t)81920/* 80*1024 */, totalLength);
 
-  int64_t uploadLength;
+  uint64_t uploadLength;
   in.read((char*)&uploadLength, sizeof(uploadLength));
-  CPPUNIT_ASSERT_EQUAL((int64_t)0, uploadLength);
+  CPPUNIT_ASSERT_EQUAL((uint64_t)0, uploadLength);
 
-  int32_t bitfieldLength;
+  uint32_t bitfieldLength;
   in.read((char*)&bitfieldLength, sizeof(bitfieldLength));
-  CPPUNIT_ASSERT_EQUAL((int32_t)10, bitfieldLength);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)10, bitfieldLength);
 
   unsigned char bitfieldRead[10];
   in.read((char*)bitfieldRead, sizeof(bitfieldRead));
   CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
 		       Util::toHex(bitfieldRead, sizeof(bitfieldRead)));
 
-  int32_t numInFlightPiece;
+  uint32_t numInFlightPiece;
   in.read((char*)&numInFlightPiece, sizeof(numInFlightPiece));
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, numInFlightPiece);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)2, numInFlightPiece);
 
   // piece index 1
-  int32_t index1;
+  uint32_t index1;
   in.read((char*)&index1, sizeof(index1));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, index1);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1, index1);
 
-  int32_t pieceLength1;
+  uint32_t pieceLength1;
   in.read((char*)&pieceLength1, sizeof(pieceLength1));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, pieceLength1);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1024, pieceLength1);
 
-  int32_t pieceBitfieldLength1;
+  uint32_t pieceBitfieldLength1;
   in.read((char*)&pieceBitfieldLength1, sizeof(pieceBitfieldLength1));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, pieceBitfieldLength1);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1, pieceBitfieldLength1);
 
   unsigned char pieceBitfield1[1];
   in.read((char*)pieceBitfield1, sizeof(pieceBitfield1));
@@ -272,13 +272,13 @@ void DefaultBtProgressInfoFileTest::testSave_nonBt()
 		       Util::toHex(pieceBitfield1, sizeof(pieceBitfield1)));
 
   // piece index 2
-  int32_t index2;
+  uint32_t index2;
   in.read((char*)&index2, sizeof(index2));
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, index2);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)2, index2);
 
-  int32_t pieceLength2;
+  uint32_t pieceLength2;
   in.read((char*)&pieceLength2, sizeof(pieceLength2));
-  CPPUNIT_ASSERT_EQUAL((int32_t)512, pieceLength2);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)512, pieceLength2);
 
 }
 
@@ -321,52 +321,52 @@ void DefaultBtProgressInfoFileTest::testSave()
   in.read((char*)extension, sizeof(extension));
   CPPUNIT_ASSERT_EQUAL(std::string("00000001"), Util::toHex(extension, sizeof(extension)));
 
-  int32_t infoHashLength;
+  uint32_t infoHashLength;
   in.read(reinterpret_cast<char*>(&infoHashLength), sizeof(infoHashLength));
-  CPPUNIT_ASSERT_EQUAL((int32_t)20, infoHashLength);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)20, infoHashLength);
 
   unsigned char infoHashRead[20];
   in.read((char*)infoHashRead, sizeof(infoHashRead));
   CPPUNIT_ASSERT_EQUAL(std::string("112233445566778899aabbccddeeff00ffffffff"),
 		       Util::toHex(infoHashRead, sizeof(infoHashRead)));
 
-  int32_t pieceLength;
+  uint32_t pieceLength;
   in.read((char*)&pieceLength, sizeof(pieceLength));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, pieceLength);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1024, pieceLength);
 
-  int64_t totalLength;
+  uint64_t totalLength;
   in.read((char*)&totalLength, sizeof(totalLength));
-  CPPUNIT_ASSERT_EQUAL((int64_t)81920/* 80*1024 */, totalLength);
+  CPPUNIT_ASSERT_EQUAL((uint64_t)81920/* 80*1024 */, totalLength);
 
-  int64_t uploadLength;
+  uint64_t uploadLength;
   in.read((char*)&uploadLength, sizeof(uploadLength));
-  CPPUNIT_ASSERT_EQUAL((int64_t)1024, uploadLength);
+  CPPUNIT_ASSERT_EQUAL((uint64_t)1024, uploadLength);
 
-  int32_t bitfieldLength;
+  uint32_t bitfieldLength;
   in.read((char*)&bitfieldLength, sizeof(bitfieldLength));
-  CPPUNIT_ASSERT_EQUAL((int32_t)10, bitfieldLength);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)10, bitfieldLength);
 
   unsigned char bitfieldRead[10];
   in.read((char*)bitfieldRead, sizeof(bitfieldRead));
   CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
 		       Util::toHex(bitfieldRead, sizeof(bitfieldRead)));
 
-  int32_t numInFlightPiece;
+  uint32_t numInFlightPiece;
   in.read((char*)&numInFlightPiece, sizeof(numInFlightPiece));
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, numInFlightPiece);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)2, numInFlightPiece);
 
   // piece index 1
-  int32_t index1;
+  uint32_t index1;
   in.read((char*)&index1, sizeof(index1));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, index1);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1, index1);
 
-  int32_t pieceLength1;
+  uint32_t pieceLength1;
   in.read((char*)&pieceLength1, sizeof(pieceLength1));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1024, pieceLength1);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1024, pieceLength1);
 
-  int32_t pieceBitfieldLength1;
+  uint32_t pieceBitfieldLength1;
   in.read((char*)&pieceBitfieldLength1, sizeof(pieceBitfieldLength1));
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, pieceBitfieldLength1);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)1, pieceBitfieldLength1);
 
   unsigned char pieceBitfield1[1];
   in.read((char*)pieceBitfield1, sizeof(pieceBitfield1));
@@ -374,13 +374,13 @@ void DefaultBtProgressInfoFileTest::testSave()
 		       Util::toHex(pieceBitfield1, sizeof(pieceBitfield1)));
 
   // piece index 2
-  int32_t index2;
+  uint32_t index2;
   in.read((char*)&index2, sizeof(index2));
-  CPPUNIT_ASSERT_EQUAL((int32_t)2, index2);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)2, index2);
 
-  int32_t pieceLength2;
+  uint32_t pieceLength2;
   in.read((char*)&pieceLength2, sizeof(pieceLength2));
-  CPPUNIT_ASSERT_EQUAL((int32_t)512, pieceLength2);
+  CPPUNIT_ASSERT_EQUAL((uint32_t)512, pieceLength2);
 
 
 }

test/DefaultBtRequestFactoryTest.cc

@@ -39,10 +39,10 @@ public:
 
   class MockBtRequestMessage : public MockBtMessage {
   public:
-    int index;
-    int blockIndex;
+    size_t index;
+    size_t blockIndex;
 
-    MockBtRequestMessage(int index, int blockIndex):index(index), blockIndex(blockIndex) {}
+    MockBtRequestMessage(size_t index, size_t blockIndex):index(index), blockIndex(blockIndex) {}
   };
   
   typedef SharedHandle<MockBtRequestMessage> MockBtRequestMessageHandle;
@@ -126,7 +126,7 @@ void DefaultBtRequestFactoryTest::testRemoveCompletedPiece() {
   CPPUNIT_ASSERT_EQUAL((int32_t)2, btRequestFactory->countTargetPiece());
   btRequestFactory->removeCompletedPiece();
   CPPUNIT_ASSERT_EQUAL((int32_t)1, btRequestFactory->countTargetPiece());
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, btRequestFactory->getTargetPieces().front()->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, btRequestFactory->getTargetPieces().front()->getIndex());
 }
 
 void DefaultBtRequestFactoryTest::testCreateRequestMessages() {
@@ -141,16 +141,16 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages() {
   CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
   std::deque<SharedHandle<BtMessage> >::iterator itr = msgs.begin();
   MockBtRequestMessage* msg = (MockBtRequestMessage*)itr->get();
-  CPPUNIT_ASSERT_EQUAL(0, msg->index);
-  CPPUNIT_ASSERT_EQUAL(0, msg->blockIndex);
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
   ++itr;
   msg = (MockBtRequestMessage*)itr->get();
-  CPPUNIT_ASSERT_EQUAL(0, msg->index);
-  CPPUNIT_ASSERT_EQUAL(1, msg->blockIndex);
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
   ++itr;
   msg = (MockBtRequestMessage*)itr->get();
-  CPPUNIT_ASSERT_EQUAL(1, msg->index);
-  CPPUNIT_ASSERT_EQUAL(0, msg->blockIndex);
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, btRequestFactory->createRequestMessages(3).size());
 }
@@ -173,16 +173,16 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame() {
   CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
   std::deque<SharedHandle<BtMessage> >::iterator itr = msgs.begin();
   MockBtRequestMessage* msg = (MockBtRequestMessage*)itr->get();
-  CPPUNIT_ASSERT_EQUAL(0, msg->index);
-  CPPUNIT_ASSERT_EQUAL(1, msg->blockIndex);
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
   ++itr;
   msg = (MockBtRequestMessage*)itr->get();
-  CPPUNIT_ASSERT_EQUAL(1, msg->index);
-  CPPUNIT_ASSERT_EQUAL(0, msg->blockIndex);
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
   ++itr;
   msg = (MockBtRequestMessage*)itr->get();
-  CPPUNIT_ASSERT_EQUAL(1, msg->index);
-  CPPUNIT_ASSERT_EQUAL(1, msg->blockIndex);
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
 }
 
 void DefaultBtRequestFactoryTest::testRemoveTargetPiece() {

test/DefaultPieceStorageTest.cc

@@ -71,8 +71,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DefaultPieceStorageTest);
 void DefaultPieceStorageTest::testGetTotalLength() {
   DefaultPieceStorage pss(btContext, option);
 
-  CPPUNIT_ASSERT_EQUAL((long long int)384,
-		       pss.getTotalLength());
+  CPPUNIT_ASSERT_EQUAL(384ULL, pss.getTotalLength());
 }
 
 void DefaultPieceStorageTest::testGetMissingPiece() {
@@ -126,26 +125,23 @@ void DefaultPieceStorageTest::testCompletePiece() {
   CPPUNIT_ASSERT_EQUAL(std::string("piece: index=0, length=128"),
 		       piece->toString());
 
-  CPPUNIT_ASSERT_EQUAL((int64_t)0,
-		       pss.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL(0ULL, pss.getCompletedLength());
 
   pss.completePiece(piece);
 
-  CPPUNIT_ASSERT_EQUAL((int64_t)128,
-		       pss.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL(128ULL, pss.getCompletedLength());
 
   SharedHandle<Piece> incompletePiece = pss.getMissingPiece(peer);
   incompletePiece->completeBlock(0);
-  CPPUNIT_ASSERT_EQUAL((int64_t)256,
-		       pss.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL(256ULL, pss.getCompletedLength());
 }
 
 void DefaultPieceStorageTest::testGetPiece() {
   DefaultPieceStorage pss(btContext, option);
   
   SharedHandle<Piece> pieceGot = pss.getPiece(0);
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, pieceGot->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)128, pieceGot->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, pieceGot->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)128, pieceGot->getLength());
   CPPUNIT_ASSERT_EQUAL(false, pieceGot->pieceComplete());
 }
 
@@ -155,9 +151,9 @@ void DefaultPieceStorageTest::testGetPieceInUsedPieces() {
   piece->completeBlock(0);
   pss.addUsedPiece(piece);
   SharedHandle<Piece> pieceGot = pss.getPiece(0);
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, pieceGot->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)128, pieceGot->getLength());
-  CPPUNIT_ASSERT_EQUAL((int32_t)1, pieceGot->countCompleteBlock());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, pieceGot->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)128, pieceGot->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, pieceGot->countCompleteBlock());
 }
 
 void DefaultPieceStorageTest::testGetPieceCompletedPiece() {
@@ -165,15 +161,15 @@ void DefaultPieceStorageTest::testGetPieceCompletedPiece() {
   SharedHandle<Piece> piece = SharedHandle<Piece>(new Piece(0, 128));
   pss.completePiece(piece);
   SharedHandle<Piece> pieceGot = pss.getPiece(0);
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, pieceGot->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)128, pieceGot->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, pieceGot->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)128, pieceGot->getLength());
   CPPUNIT_ASSERT_EQUAL(true, pieceGot->pieceComplete());
 }
 
 void DefaultPieceStorageTest::testCancelPiece()
 {
-  int32_t pieceLength = 256*1024;
-  int64_t totalLength = 32*pieceLength; // <-- make the number of piece greater than END_GAME_PIECE_NUM
+  size_t pieceLength = 256*1024;
+  uint64_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*/);
@@ -197,8 +193,8 @@ void DefaultPieceStorageTest::testCancelPiece()
 
 void DefaultPieceStorageTest::testMarkPiecesDone()
 {
-  int32_t pieceLength = 256*1024;
-  int64_t totalLength = 4*1024*1024;
+  size_t pieceLength = 256*1024;
+  uint64_t totalLength = 4*1024*1024;
   SharedHandle<MockBtContext> dctx = new MockBtContext();
   dctx->setPieceLength(pieceLength);
   dctx->setTotalLength(totalLength);
@@ -207,17 +203,17 @@ void DefaultPieceStorageTest::testMarkPiecesDone()
 
   ps.markPiecesDone(pieceLength*10+16*1024*2+1);
 
-  for(int32_t i = 0; i < 10; ++i) {
+  for(size_t i = 0; i < 10; ++i) {
     CPPUNIT_ASSERT(ps.hasPiece(i));
   }
-  for(int32_t i = 10; i < (totalLength+pieceLength-1)/pieceLength; ++i) {
+  for(size_t i = 10; i < (totalLength+pieceLength-1)/pieceLength; ++i) {
     CPPUNIT_ASSERT(!ps.hasPiece(i));
   }
-  CPPUNIT_ASSERT_EQUAL((int64_t)pieceLength*10+16*1024*2, ps.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((uint64_t)pieceLength*10+16*1024*2, ps.getCompletedLength());
 
   ps.markPiecesDone(totalLength);
 
-  for(int32_t i = 0; i < (totalLength+pieceLength-1)/pieceLength; ++i) {
+  for(size_t i = 0; i < (totalLength+pieceLength-1)/pieceLength; ++i) {
     CPPUNIT_ASSERT(ps.hasPiece(i));
   }
 }

test/GrowSegmentTest.cc

@@ -27,7 +27,7 @@ void GrowSegmentTest::testUpdateWrittenLength()
   GrowSegment segment(new Piece());
   segment.updateWrittenLength(32*1024);
   
-  CPPUNIT_ASSERT_EQUAL((int64_t)32*1024, segment.getPositionToWrite());
+  CPPUNIT_ASSERT_EQUAL((off_t)32*1024, segment.getPositionToWrite());
   CPPUNIT_ASSERT(!segment.complete());
   CPPUNIT_ASSERT(segment.getPiece()->pieceComplete());
 }
@@ -36,9 +36,9 @@ void GrowSegmentTest::testClear()
 {
   GrowSegment segment(new Piece());
   segment.updateWrittenLength(32*1024);
-  CPPUNIT_ASSERT_EQUAL((int32_t)32*1024, segment.getWrittenLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)32*1024, segment.getWrittenLength());
   segment.clear();
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, segment.getWrittenLength());  
+  CPPUNIT_ASSERT_EQUAL((size_t)0, segment.getWrittenLength());  
 }
 
 } // namespace aria2

test/MockBtRequestFactory.h

@@ -22,10 +22,10 @@ public:
   virtual void doChokedAction() {}
 
   virtual std::deque<SharedHandle<BtMessage> >
-  createRequestMessages(int32_t max) { return std::deque<SharedHandle<BtMessage> >(); }
+  createRequestMessages(size_t max) { return std::deque<SharedHandle<BtMessage> >(); }
 
   virtual std::deque<SharedHandle<BtMessage> >
-  createRequestMessagesOnEndGame(int32_t max) { return std::deque<SharedHandle<BtMessage> >(); }
+  createRequestMessagesOnEndGame(size_t max) { return std::deque<SharedHandle<BtMessage> >(); }
 };
 
 } // namespace aria2

test/MockPieceStorage.h

@@ -11,15 +11,15 @@ namespace aria2 {
 
 class MockPieceStorage : public PieceStorage {
 private:
-  int64_t totalLength;
-  int64_t filteredTotalLength;
-  int64_t completedLength;
-  int64_t filteredCompletedLength;
+  uint64_t totalLength;
+  uint64_t filteredTotalLength;
+  uint64_t completedLength;
+  uint64_t filteredCompletedLength;
   BitfieldMan* bitfieldMan;
   bool selectiveDownloadingMode;
   bool endGame;
   SharedHandle<DiskAdaptor> diskAdaptor;
-  std::deque<int32_t> pieceLengthList;
+  std::deque<size_t> pieceLengthList;
   std::deque<SharedHandle<Piece> > inFlightPieces;
   bool _allDownloadFinished;
 public:
@@ -52,21 +52,21 @@ public:
     return new Piece();
   }
 
-  virtual SharedHandle<Piece> getMissingPiece(int32_t index)
+  virtual SharedHandle<Piece> getMissingPiece(size_t index)
   {
     return new Piece();
   }
 
-  virtual bool isPieceUsed(int32_t index)
+  virtual bool isPieceUsed(size_t index)
   {
     return false;
   }
 
-  virtual void markPieceMissing(int32_t index) {}
+  virtual void markPieceMissing(size_t index) {}
 
-  virtual void markPiecesDone(int64_t) {}
+  virtual void markPiecesDone(uint64_t) {}
 
-  virtual SharedHandle<Piece> getPiece(int32_t index) {
+  virtual SharedHandle<Piece> getPiece(size_t index) {
     return new Piece();
   }
 
@@ -74,39 +74,39 @@ public:
 
   virtual void cancelPiece(const SharedHandle<Piece>& piece) {}
 
-  virtual bool hasPiece(int32_t index) {
+  virtual bool hasPiece(size_t index) {
     return false;
   }
 
-  virtual int64_t getTotalLength() {
+  virtual uint64_t getTotalLength() {
     return totalLength;
   }
 
-  void setTotalLength(int64_t totalLength) {
+  void setTotalLength(uint64_t totalLength) {
     this->totalLength = totalLength;
   }
 
-  virtual int64_t getFilteredTotalLength() {
+  virtual uint64_t getFilteredTotalLength() {
     return filteredTotalLength;
   }
 
-  void setFilteredTotalLength(int64_t totalLength) {
+  void setFilteredTotalLength(uint64_t totalLength) {
     this->filteredTotalLength = totalLength;
   }
 
-  virtual int64_t getCompletedLength() {
+  virtual uint64_t getCompletedLength() {
     return completedLength;
   }
 
-  void setCompletedLength(int64_t completedLength) {
+  void setCompletedLength(uint64_t completedLength) {
     this->completedLength = completedLength;
   }
 
-  virtual int64_t getFilteredCompletedLength() {
+  virtual uint64_t getFilteredCompletedLength() {
     return filteredCompletedLength;
   }
 
-  void setFilteredCompletedLength(int64_t completedLength) {
+  void setFilteredCompletedLength(uint64_t completedLength) {
     this->filteredCompletedLength = completedLength;
   }
   
@@ -136,11 +136,11 @@ public:
   }
 
   virtual void setBitfield(const unsigned char* bitfield,
-			   int32_t bitfieldLength) {
+			   size_t bitfieldLength) {
     bitfieldMan->setBitfield(bitfield, bitfieldLength);
   }
   
-  virtual int32_t getBitfieldLength() {
+  virtual size_t getBitfieldLength() {
     return bitfieldMan->getBitfieldLength();
   }
 
@@ -174,22 +174,22 @@ public:
     this->diskAdaptor = adaptor;
   }
   
-  virtual int32_t getPieceLength(int32_t index) {
+  virtual size_t getPieceLength(size_t index) {
     return pieceLengthList.at(index);
   }
 
-  void addPieceLengthList(int32_t length) {
+  void addPieceLengthList(size_t length) {
     pieceLengthList.push_back(length);
   }
 
-  virtual void advertisePiece(int32_t cuid, int32_t index) {}
+  virtual void advertisePiece(int32_t cuid, size_t index) {}
 
-  virtual std::deque<int32_t> getAdvertisedPieceIndexes(int32_t myCuid,
-							const Time& lastCheckTime) {
-    return std::deque<int32_t>();
+  virtual std::deque<size_t> getAdvertisedPieceIndexes(int32_t myCuid,
+						       const Time& lastCheckTime) {
+    return std::deque<size_t>();
   }
 
-  virtual void removeAdvertisedPiece(int32_t elapsed) {}
+  virtual void removeAdvertisedPiece(time_t elapsed) {}
 
   virtual void markAllPiecesDone() {}
 
@@ -198,7 +198,7 @@ public:
     std::copy(pieces.begin(), pieces.end(), back_inserter(inFlightPieces));
   }
 
-  virtual int32_t countInFlightPiece()
+  virtual size_t countInFlightPiece()
   {
     return inFlightPieces.size();
   }

test/PieceTest.cc

@@ -42,7 +42,7 @@ void PieceTest::testGetCompletedLength()
   p.completeBlock(9);
   p.completeBlock(10); // <-- 100 bytes
   
-  CPPUNIT_ASSERT_EQUAL(blockLength*3+100, p.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)blockLength*3+100, p.getCompletedLength());
 }
 
 } // namespace aria2

test/SegmentManTest.cc

@@ -43,10 +43,10 @@ void SegmentManTest::testNullBitfield()
 
   SharedHandle<Segment> segment = segmentMan.getSegment(1);
   CPPUNIT_ASSERT(!segment.isNull());
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getIndex());
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getLength());
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getSegmentLength());
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getWrittenLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getSegmentLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, segment->getWrittenLength());
 
   SharedHandle<Segment> segment2 = segmentMan.getSegment(2);
   CPPUNIT_ASSERT(segment2.isNull());
@@ -58,8 +58,8 @@ void SegmentManTest::testNullBitfield()
 void SegmentManTest::testCompleteSegment()
 {
   Option op;
-  int32_t pieceLength = 1024*1024;
-  int64_t totalLength = 64*1024*1024;
+  size_t pieceLength = 1024*1024;
+  uint64_t totalLength = 64*1024*1024;
   SharedHandle<MockBtContext> dctx = new MockBtContext();
   dctx->setPieceLength(pieceLength);
   dctx->setTotalLength(totalLength);
@@ -78,8 +78,8 @@ void SegmentManTest::testCompleteSegment()
   
   std::deque<SharedHandle<Segment> > segments = segmentMan.getInFlightSegment(1);
   CPPUNIT_ASSERT_EQUAL((size_t)2, segments.size());
-  CPPUNIT_ASSERT_EQUAL(0, segments[0]->getIndex());
-  CPPUNIT_ASSERT_EQUAL(2, segments[1]->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, segments[0]->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)2, segments[1]->getIndex());
 }
 
 void SegmentManTest::testMarkPieceDone_usedSegment()

test/SegmentTest.cc

@@ -32,7 +32,7 @@ void SegmentTest::testUpdateWrittenLength()
 {
   SharedHandle<Piece> p = new Piece(0, 16*1024*10);
   PiecedSegment s(16*1024*10, p);
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, s.getWrittenLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, s.getWrittenLength());
 
   s.updateWrittenLength(16*1024);
   CPPUNIT_ASSERT(p->hasBlock(0));
@@ -49,7 +49,7 @@ void SegmentTest::testUpdateWrittenLength_overflow()
 
   s.updateWrittenLength(16*1024*11);
   CPPUNIT_ASSERT(p->pieceComplete());
-  CPPUNIT_ASSERT_EQUAL((int32_t)16*1024, s.getOverflowLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)16*1024, s.getOverflowLength());
 }
 
 void SegmentTest::testUpdateWrittenLength_lastPiece()
@@ -77,11 +77,11 @@ void SegmentTest::testClear()
   SharedHandle<Piece> p = new Piece(0, 16*1024*10);
   PiecedSegment s(16*1024*10, p);
   s.updateWrittenLength(16*1024*11);
-  CPPUNIT_ASSERT_EQUAL((int32_t)16*1024*10, s.getWrittenLength());
-  CPPUNIT_ASSERT_EQUAL((int32_t)16*1024, s.getOverflowLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)16*1024*10, s.getWrittenLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)16*1024, s.getOverflowLength());
   s.clear();
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, s.getWrittenLength());
-  CPPUNIT_ASSERT_EQUAL((int32_t)0, s.getOverflowLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, s.getWrittenLength());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, s.getOverflowLength());
 }
 
 } // namespace aria2