Consistent naming scheme for hash type and digest.

src/Checksum.cc

@@ -37,38 +37,40 @@
 
 namespace aria2 {
 
-Checksum::Checksum(const std::string& algo, const std::string& messageDigest)
-    : algo_(algo),
-      messageDigest_(messageDigest)
+Checksum::Checksum
+(const std::string& hashType,
+ const std::string& digest)
+    : hashType_(hashType),
+      digest_(digest)
 {}
 
 Checksum::Checksum()
-    : algo_("sha-1")
+    : hashType_("sha-1")
 {}
 
 Checksum::~Checksum() {}
 
 bool Checksum::isEmpty() const
 {
-  return messageDigest_.empty();
+  return digest_.empty();
 }
 
-void Checksum::setMessageDigest(const std::string& md)
+void Checksum::setDigest(const std::string& digest)
 {
-  messageDigest_ = md;
+  digest_ = digest;
 }
   
-void Checksum::setAlgo(const std::string& algo)
+void Checksum::setHashType(const std::string& hashType)
 {
-  algo_ = algo;
+  hashType_ = hashType;
 }
 
 void Checksum::swap(Checksum& other)
 {
   using std::swap;
   if(this != &other) {
-    swap(algo_, other.algo_);
-    swap(messageDigest_, other.messageDigest_);
+    swap(hashType_, other.hashType_);
+    swap(digest_, other.digest_);
   }
 }
 
@@ -80,7 +82,7 @@ void swap(Checksum& a, Checksum& b)
 bool HashTypeStronger::operator()
   (const Checksum& lhs, const Checksum& rhs) const
 {
-  return MessageDigest::isStronger(lhs.getAlgo(), rhs.getAlgo());
+  return MessageDigest::isStronger(lhs.getHashType(), rhs.getHashType());
 }
 
 } // namespace aria2

src/Checksum.h

@@ -43,26 +43,26 @@ namespace aria2 {
 
 class Checksum {
 private:
-  std::string algo_;
-  std::string messageDigest_;
+  std::string hashType_;
+  std::string digest_;
 public:
   // messageDigest_ is ascii hexadecimal notation.
-  Checksum(const std::string& algo, const std::string& messageDigest);
+  Checksum(const std::string& hashType, const std::string& digest);
   Checksum();
   ~Checksum();
 
   bool isEmpty() const;
 
-  void setMessageDigest(const std::string& md);
-  const std::string& getMessageDigest() const
+  void setDigest(const std::string& md);
+  const std::string& getDigest() const
   {
-    return messageDigest_;
+    return digest_;
   }
   
-  void setAlgo(const std::string& algo);
-  const std::string& getAlgo() const
+  void setHashType(const std::string& type);
+  const std::string& getHashType() const
   {
-    return algo_;
+    return hashType_;
   }
 
   void swap(Checksum& other);

src/ChunkChecksum.cc

@@ -37,55 +37,52 @@
 
 namespace aria2 {
 
-ChunkChecksum::ChunkChecksum():checksumLength_(0) {}
+ChunkChecksum::ChunkChecksum():pieceLength_(0) {}
 
 ChunkChecksum::ChunkChecksum
-(const std::string& algo,
- const std::vector<std::string>& checksums,
- size_t checksumLength)
-    : algo_(algo),
-      checksums_(checksums),
-      checksumLength_(checksumLength)
+(const std::string& hashType,
+ const std::vector<std::string>& pieceHashes,
+ size_t pieceLength)
+    : hashType_(hashType),
+      pieceHashes_(pieceHashes),
+      pieceLength_(pieceLength)
 {}
 
 bool ChunkChecksum::validateChunk
-(const std::string& actualChecksum,
- size_t checksumIndex) const
+(const std::string& actualDigest,
+ size_t index) const
 {
-  if(checksumIndex < checksums_.size()) {
-    return actualChecksum == getChecksum(checksumIndex);
-  } else {
-    return false;
-  }
+  const std::string& digest = getPieceHash(index);
+  return !digest.empty() && actualDigest == digest;
 }
 
 uint64_t ChunkChecksum::getEstimatedDataLength() const
 {
-  return static_cast<uint64_t>(checksumLength_)*checksums_.size();
+  return static_cast<uint64_t>(pieceLength_)*pieceHashes_.size();
 }
 
-size_t ChunkChecksum::countChecksum() const
+size_t ChunkChecksum::countPieceHash() const
 {
-  return checksums_.size();
+  return pieceHashes_.size();
 }
 
-const std::string& ChunkChecksum::getChecksum(size_t index) const
+const std::string& ChunkChecksum::getPieceHash(size_t index) const
 {
-  if(index < checksums_.size()) {
-    return checksums_[index];
+  if(index < pieceHashes_.size()) {
+    return pieceHashes_[index];
   } else {
     return A2STR::NIL;
   }
 }
 
-void ChunkChecksum::setAlgo(const std::string& algo)
+void ChunkChecksum::setHashType(const std::string& hashType)
 {
-  algo_ = algo;
+  hashType_ = hashType;
 }
 
-void ChunkChecksum::setChecksums(const std::vector<std::string>& mds)
+void ChunkChecksum::setPieceHashes(const std::vector<std::string>& pieceHashes)
 {
-  checksums_ = mds;
+  pieceHashes_ = pieceHashes;
 }
 
 } // namespace aria2

src/ChunkChecksum.h

@@ -46,45 +46,46 @@ namespace aria2 {
 
 class ChunkChecksum {
 private:
-  std::string algo_;
-  std::vector<std::string> checksums_;
-  size_t checksumLength_;
+  std::string hashType_;
+  std::vector<std::string> pieceHashes_;
+  size_t pieceLength_;
 public:
   ChunkChecksum();
 
-  ChunkChecksum(const std::string& algo,
-                const std::vector<std::string>& checksums,
-                size_t checksumLength);
+  ChunkChecksum
+  (const std::string& hashType,
+   const std::vector<std::string>& pieceHashes,
+   size_t pieceLength);
 
-  bool validateChunk(const std::string& actualChecksum,
-                     size_t checksumIndex) const;
+  bool validateChunk(const std::string& actualDigest,
+                     size_t index) const;
 
   uint64_t getEstimatedDataLength() const;
 
-  size_t countChecksum() const;
+  size_t countPieceHash() const;
 
-  const std::string& getChecksum(size_t index) const;
+  const std::string& getPieceHash(size_t index) const;
   
-  void setChecksums(const std::vector<std::string>& mds);
-  const std::vector<std::string>& getChecksums() const
+  void setPieceHashes(const std::vector<std::string>& pieceHashes);
+  const std::vector<std::string>& getPieceHashes() const
   {
-    return checksums_;
+    return pieceHashes_;
   }
 
-  size_t getChecksumLength() const
+  void setHashType(const std::string& hashType);
+  const std::string& getHashType() const
   {
-    return checksumLength_;
+    return hashType_;
   }
 
-  void setAlgo(const std::string& algo);
-  const std::string& getAlgo() const
+  size_t getPieceLength() const
   {
-    return algo_;
+    return pieceLength_;
   }
 
-  void setChecksumLength(size_t length)
+  void setPieceLength(size_t length)
   {
-    checksumLength_ = length;
+    pieceLength_ = length;
   }
 };
 

src/HttpResponse.cc

@@ -424,10 +424,10 @@ void HttpResponse::getDigest(std::vector<Checksum>& result) const
     bool ok = true;
     std::vector<Checksum>::iterator j = i+1;
     for(; j != eoi; ++j) {
-      if((*i).getAlgo() != (*j).getAlgo()) {
+      if((*i).getHashType() != (*j).getHashType()) {
         break;
       }
-      if((*i).getMessageDigest() != (*j).getMessageDigest()) {
+      if((*i).getDigest() != (*j).getDigest()) {
         ok = false;
       }
     }

src/HttpResponseCommand.cc

@@ -215,10 +215,10 @@ bool HttpResponseCommand::executeInternal()
             eoi = checksums.end(); i != eoi; ++i) {
         if(getDownloadContext()->getChecksumHashAlgo().empty()) {
           A2_LOG_DEBUG(fmt("Setting digest: type=%s, digest=%s",
-                           (*i).getAlgo().c_str(),
-                           (*i).getMessageDigest().c_str()));
-          getDownloadContext()->setChecksumHashAlgo((*i).getAlgo());
-          getDownloadContext()->setChecksum((*i).getMessageDigest());
+                           (*i).getHashType().c_str(),
+                           (*i).getDigest().c_str()));
+          getDownloadContext()->setChecksumHashAlgo((*i).getHashType());
+          getDownloadContext()->setChecksum((*i).getDigest());
           break;
         } else {
           if(checkChecksum(getDownloadContext(), *i)) {
@@ -559,8 +559,8 @@ bool HttpResponseCommand::checkChecksum
 (const SharedHandle<DownloadContext>& dctx,
  const Checksum& checksum)
 {
-  if(dctx->getChecksumHashAlgo() == checksum.getAlgo()) {
-    if(dctx->getChecksum() == checksum.getMessageDigest()) {
+  if(dctx->getChecksumHashAlgo() == checksum.getHashType()) {
+    if(dctx->getChecksum() == checksum.getDigest()) {
       A2_LOG_INFO("Valid hash found in Digest header field.");
       return true;
     } else {

src/Metalink2RequestGroup.cc

@@ -245,7 +245,7 @@ Metalink2RequestGroup::createRequestGroup
       if(!entry->chunkChecksum) {
         pieceLength = option->getAsInt(PREF_SEGMENT_SIZE);
       } else {
-        pieceLength = entry->chunkChecksum->getChecksumLength();
+        pieceLength = entry->chunkChecksum->getPieceLength();
       }
 #else
       pieceLength = option->getAsInt(PREF_SEGMENT_SIZE);
@@ -263,13 +263,13 @@ Metalink2RequestGroup::createRequestGroup
       }
 #ifdef ENABLE_MESSAGE_DIGEST
       if(entry->checksum) {
-        dctx->setChecksum(entry->checksum->getMessageDigest());
-        dctx->setChecksumHashAlgo(entry->checksum->getAlgo());
+        dctx->setChecksum(entry->checksum->getDigest());
+        dctx->setChecksumHashAlgo(entry->checksum->getHashType());
       }
       if(entry->chunkChecksum) {
-        dctx->setPieceHashes(entry->chunkChecksum->getChecksums().begin(),
-                             entry->chunkChecksum->getChecksums().end());
-        dctx->setPieceHashAlgo(entry->chunkChecksum->getAlgo());
+        dctx->setPieceHashes(entry->chunkChecksum->getPieceHashes().begin(),
+                             entry->chunkChecksum->getPieceHashes().end());
+        dctx->setPieceHashAlgo(entry->chunkChecksum->getHashType());
       }
 #endif // ENABLE_MESSAGE_DIGEST
       dctx->setSignature(entry->getSignature());

src/MetalinkParserController.cc

@@ -270,7 +270,7 @@ void MetalinkParserController::setTypeOfChecksum(const std::string& type)
   }
   std::string calgo = MessageDigest::getCanonicalHashType(type);
   if(MessageDigest::supports(calgo)) {
-    tChecksum_->setAlgo(calgo);
+    tChecksum_->setHashType(calgo);
   } else {
     cancelChecksumTransaction();
   }
@@ -283,8 +283,8 @@ void MetalinkParserController::setHashOfChecksum(const std::string& md)
   if(!tChecksum_) {
     return;
   }
-  if(MessageDigest::isValidHash(tChecksum_->getAlgo(), md)) {
-    tChecksum_->setMessageDigest(md);
+  if(MessageDigest::isValidHash(tChecksum_->getHashType(), md)) {
+    tChecksum_->setDigest(md);
   } else {
     cancelChecksumTransaction();
   }
@@ -298,8 +298,8 @@ void MetalinkParserController::commitChecksumTransaction()
     return;
   }
   if(!tEntry_->checksum ||
-     MessageDigest::isStronger(tChecksum_->getAlgo(),
-                               tEntry_->checksum->getAlgo())) {
+     MessageDigest::isStronger(tChecksum_->getHashType(),
+                               tEntry_->checksum->getHashType())) {
     tEntry_->checksum = tChecksum_;
   }
   tChecksum_.reset();
@@ -332,7 +332,7 @@ void MetalinkParserController::setTypeOfChunkChecksumV4(const std::string& type)
   }
   std::string calgo = MessageDigest::getCanonicalHashType(type);
   if(MessageDigest::supports(calgo)) {
-    tChunkChecksumV4_->setAlgo(calgo);
+    tChunkChecksumV4_->setHashType(calgo);
   } else {
     cancelChunkChecksumTransactionV4();
   }
@@ -346,7 +346,7 @@ void MetalinkParserController::setLengthOfChunkChecksumV4(size_t length)
     return;
   }
   if(length > 0) {
-    tChunkChecksumV4_->setChecksumLength(length);
+    tChunkChecksumV4_->setPieceLength(length);
   } else {
     cancelChunkChecksumTransactionV4();
   }
@@ -359,7 +359,7 @@ void MetalinkParserController::addHashOfChunkChecksumV4(const std::string& md)
   if(!tChunkChecksumV4_) {
     return;
   }
-  if(MessageDigest::isValidHash(tChunkChecksumV4_->getAlgo(), md)) {
+  if(MessageDigest::isValidHash(tChunkChecksumV4_->getHashType(), md)) {
     tempChunkChecksumsV4_.push_back(md);
   } else {
     cancelChunkChecksumTransactionV4();
@@ -374,11 +374,11 @@ void MetalinkParserController::commitChunkChecksumTransactionV4()
     return;
   }
   if(!tEntry_->chunkChecksum ||
-     MessageDigest::isStronger(tChunkChecksumV4_->getAlgo(),
-                               tEntry_->chunkChecksum->getAlgo())) {
-    std::vector<std::string> checksums(tempChunkChecksumsV4_.begin(),
-				      tempChunkChecksumsV4_.end());
-    tChunkChecksumV4_->setChecksums(checksums);
+     MessageDigest::isStronger(tChunkChecksumV4_->getHashType(),
+                               tEntry_->chunkChecksum->getHashType())) {
+    std::vector<std::string> pieceHashes(tempChunkChecksumsV4_.begin(),
+                                         tempChunkChecksumsV4_.end());
+    tChunkChecksumV4_->setPieceHashes(pieceHashes);
     tEntry_->chunkChecksum = tChunkChecksumV4_;
   }
   tChunkChecksumV4_.reset();
@@ -411,7 +411,7 @@ void MetalinkParserController::setTypeOfChunkChecksum(const std::string& type)
   }
   std::string calgo = MessageDigest::getCanonicalHashType(type);
   if(MessageDigest::supports(calgo)) {
-    tChunkChecksum_->setAlgo(calgo);
+    tChunkChecksum_->setHashType(calgo);
   } else {
     cancelChunkChecksumTransaction();
   }
@@ -425,7 +425,7 @@ void MetalinkParserController::setLengthOfChunkChecksum(size_t length)
     return;
   }
   if(length > 0) {
-    tChunkChecksum_->setChecksumLength(length);
+    tChunkChecksum_->setPieceLength(length);
   } else {
     cancelChunkChecksumTransaction();
   }
@@ -438,7 +438,7 @@ void MetalinkParserController::addHashOfChunkChecksum(size_t order, const std::s
   if(!tChunkChecksum_) {
     return;
   }
-  if(MessageDigest::isValidHash(tChunkChecksum_->getAlgo(), md)) {
+  if(MessageDigest::isValidHash(tChunkChecksum_->getHashType(), md)) {
     tempChunkChecksums_.push_back(std::make_pair(order, md));
   } else {
     cancelChunkChecksumTransaction();
@@ -462,7 +462,7 @@ void MetalinkParserController::setMessageDigestOfChunkChecksum(const std::string
   if(!tChunkChecksum_) {
     return;
   }
-  if(MessageDigest::isValidHash(tChunkChecksum_->getAlgo(), md)) {
+  if(MessageDigest::isValidHash(tChunkChecksum_->getHashType(), md)) {
     tempHashPair_.second = md;
   } else {
     cancelChunkChecksumTransaction();
@@ -487,15 +487,15 @@ void MetalinkParserController::commitChunkChecksumTransaction()
     return;
   }
   if(!tEntry_->chunkChecksum ||
-     MessageDigest::isStronger(tChunkChecksum_->getAlgo(),
-                               tEntry_->chunkChecksum->getAlgo())) {
+     MessageDigest::isStronger(tChunkChecksum_->getHashType(),
+                               tEntry_->chunkChecksum->getHashType())) {
     std::sort(tempChunkChecksums_.begin(), tempChunkChecksums_.end(),
               Ascend1st<std::pair<size_t, std::string> >());
-    std::vector<std::string> checksums;
+    std::vector<std::string> pieceHashes;
     std::transform(tempChunkChecksums_.begin(), tempChunkChecksums_.end(),
-                   std::back_inserter(checksums),
+                   std::back_inserter(pieceHashes),
                    select2nd<std::pair<size_t, std::string> >());
-    tChunkChecksum_->setChecksums(checksums);
+    tChunkChecksum_->setPieceHashes(pieceHashes);
     tEntry_->chunkChecksum = tChunkChecksum_;
   }
   tChunkChecksum_.reset();

test/HttpResponseTest.cc

@@ -671,14 +671,14 @@ void HttpResponseTest::testGetDigest()
   CPPUNIT_ASSERT_EQUAL((size_t)3, result.size());
 
   Checksum c = result[0];
-  CPPUNIT_ASSERT_EQUAL(std::string("sha-256"), c.getAlgo());
+  CPPUNIT_ASSERT_EQUAL(std::string("sha-256"), c.getHashType());
   CPPUNIT_ASSERT_EQUAL(std::string("f83f271ae773dc6fe4a6454a41e0eb237c43e7bbf451e426cc60993a4d379ec5"),
-                       c.getMessageDigest());
+                       c.getDigest());
 
   c = result[1];
-  CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c.getAlgo());
+  CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c.getHashType());
   CPPUNIT_ASSERT_EQUAL(std::string("f36003f22b462ffa184390533c500d8989e9f681"),
-                       c.getMessageDigest());
+                       c.getDigest());
 }
 #endif // ENABLE_MESSAGE_DIGEST
 

test/MetalinkParserControllerTest.cc

@@ -205,9 +205,9 @@ void MetalinkParserControllerTest::testChecksumTransaction()
   {
     SharedHandle<Metalinker> m = ctrl.getResult();
     SharedHandle<Checksum> md = m->getEntries().front()->checksum;
-    CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getAlgo());
+    CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getHashType());
     CPPUNIT_ASSERT_EQUAL(std::string("acbd18db4cc2f85cedef654fccc4a4d8"),
-                         md->getMessageDigest());
+                         md->getDigest());
   }
   ctrl.newEntryTransaction();
   ctrl.newChecksumTransaction();
@@ -239,19 +239,19 @@ void MetalinkParserControllerTest::testChunkChecksumTransaction()
   {
     SharedHandle<Metalinker> m = ctrl.getResult();
     SharedHandle<ChunkChecksum> md = m->getEntries().front()->chunkChecksum;
-    CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getAlgo());
-    CPPUNIT_ASSERT_EQUAL((size_t)256*1024, md->getChecksumLength());
-    CPPUNIT_ASSERT_EQUAL((size_t)5, md->countChecksum());
+    CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getHashType());
+    CPPUNIT_ASSERT_EQUAL((size_t)256*1024, md->getPieceLength());
+    CPPUNIT_ASSERT_EQUAL((size_t)5, md->countPieceHash());
     CPPUNIT_ASSERT_EQUAL(std::string("1cbd18db4cc2f85cedef654fccc4a4d8"),
-                         md->getChecksums()[0]);
+                         md->getPieceHashes()[0]);
     CPPUNIT_ASSERT_EQUAL(std::string("2cbd18db4cc2f85cedef654fccc4a4d8"),
-                         md->getChecksums()[1]);
+                         md->getPieceHashes()[1]);
     CPPUNIT_ASSERT_EQUAL(std::string("3cbd18db4cc2f85cedef654fccc4a4d8"),
-                         md->getChecksums()[2]);
+                         md->getPieceHashes()[2]);
     CPPUNIT_ASSERT_EQUAL(std::string("4cbd18db4cc2f85cedef654fccc4a4d8"),
-                         md->getChecksums()[3]);
+                         md->getPieceHashes()[3]);
     CPPUNIT_ASSERT_EQUAL(std::string("5cbd18db4cc2f85cedef654fccc4a4d8"),
-                         md->getChecksums()[4]);
+                         md->getPieceHashes()[4]);
   }
   ctrl.newEntryTransaction();
   ctrl.newChunkChecksumTransaction();
@@ -283,18 +283,18 @@ void MetalinkParserControllerTest::testChunkChecksumTransactionV4()
   {
     SharedHandle<Metalinker> m = ctrl.getResult();
     SharedHandle<ChunkChecksum> md = m->getEntries().front()->chunkChecksum;
-    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), md->getAlgo());
-    CPPUNIT_ASSERT_EQUAL((size_t)256*1024, md->getChecksumLength());
-    CPPUNIT_ASSERT_EQUAL((size_t)3, md->countChecksum());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), md->getHashType());
+    CPPUNIT_ASSERT_EQUAL((size_t)256*1024, md->getPieceLength());
+    CPPUNIT_ASSERT_EQUAL((size_t)3, md->countPieceHash());
     CPPUNIT_ASSERT_EQUAL
       (std::string("5bd9f7248df0f3a6a86ab6c95f48787d546efa14"),
-       md->getChecksums()[0]);
+       md->getPieceHashes()[0]);
     CPPUNIT_ASSERT_EQUAL
       (std::string("9413ee70957a09d55704123687478e07f18c7b29"),
-       md->getChecksums()[1]);
+       md->getPieceHashes()[1]);
     CPPUNIT_ASSERT_EQUAL
       (std::string("44213f9f4d59b557314fadcd233232eebcac8012"),
-       md->getChecksums()[2]);
+       md->getPieceHashes()[2]);
   }
   ctrl.newEntryTransaction();
   ctrl.newChunkChecksumTransactionV4();

test/MetalinkProcessorTest.cc

@@ -93,33 +93,33 @@ void MetalinkProcessorTest::testParseFileV4()
   CPPUNIT_ASSERT_EQUAL(-1, e->maxConnections);
 #ifdef ENABLE_MESSAGE_DIGEST
   CPPUNIT_ASSERT_EQUAL(std::string("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"),
-		       e->checksum->getMessageDigest());
+		       e->checksum->getDigest());
   CPPUNIT_ASSERT(e->checksum);
-  CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->checksum->getAlgo());
+  CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->checksum->getHashType());
   CPPUNIT_ASSERT(e->chunkChecksum);
   if(MessageDigest::supports("sha-256")) {
-    CPPUNIT_ASSERT_EQUAL(std::string("sha-256"), e->chunkChecksum->getAlgo());
-    CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getChecksumLength());
-    CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countChecksum());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha-256"), e->chunkChecksum->getHashType());
+    CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getPieceLength());
+    CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countPieceHash());
     CPPUNIT_ASSERT_EQUAL(std::string("0245178074fd042e19b7c3885b360fc21064b30e73f5626c7e3b005d048069c5"),
-                         e->chunkChecksum->getChecksum(0));
+                         e->chunkChecksum->getPieceHash(0));
     CPPUNIT_ASSERT_EQUAL(std::string("487ba2299be7f759d7c7bf6a4ac3a32cee81f1bb9332fc485947e32918864fb2"),
-                         e->chunkChecksum->getChecksum(1));
+                         e->chunkChecksum->getPieceHash(1));
     CPPUNIT_ASSERT_EQUAL(std::string("37290d74ac4d186e3a8e5785d259d2ec04fac91ae28092e7620ec8bc99e830aa"),
-                         e->chunkChecksum->getChecksum(2));
+                         e->chunkChecksum->getPieceHash(2));
   } else {
-    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->chunkChecksum->getAlgo());
-    CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getChecksumLength());
-    CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countChecksum());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->chunkChecksum->getHashType());
+    CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getPieceLength());
+    CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countPieceHash());
     CPPUNIT_ASSERT_EQUAL
       (std::string("5bd9f7248df0f3a6a86ab6c95f48787d546efa14"),
-       e->chunkChecksum->getChecksum(0));
+       e->chunkChecksum->getPieceHash(0));
     CPPUNIT_ASSERT_EQUAL
       (std::string("9413ee70957a09d55704123687478e07f18c7b29"),
-       e->chunkChecksum->getChecksum(1));
+       e->chunkChecksum->getPieceHash(1));
     CPPUNIT_ASSERT_EQUAL
       (std::string("44213f9f4d59b557314fadcd233232eebcac8012"),
-       e->chunkChecksum->getChecksum(2));    
+       e->chunkChecksum->getPieceHash(2));
   }
 #endif // ENABLE_MESSAGE_DIGEST
   CPPUNIT_ASSERT(e->getSignature());
@@ -508,8 +508,8 @@ void MetalinkProcessorTest::testParseFile()
     CPPUNIT_ASSERT_EQUAL(1, entry1->maxConnections);
 #ifdef ENABLE_MESSAGE_DIGEST
     CPPUNIT_ASSERT_EQUAL(std::string("a96cf3f0266b91d87d5124cf94326422800b627d"),
-                         entry1->checksum->getMessageDigest());
-    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry1->checksum->getAlgo());
+                         entry1->checksum->getDigest());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry1->checksum->getHashType());
 #endif // ENABLE_MESSAGE_DIGEST
     CPPUNIT_ASSERT(entry1->getSignature());
     CPPUNIT_ASSERT_EQUAL(std::string("pgp"), entry1->getSignature()->getType());
@@ -557,14 +557,14 @@ void MetalinkProcessorTest::testParseFile()
     CPPUNIT_ASSERT_EQUAL(-1, entry2->maxConnections);
 #ifdef ENABLE_MESSAGE_DIGEST
     CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
-                         entry2->checksum->getMessageDigest());
-    CPPUNIT_ASSERT_EQUAL((size_t)2, entry2->chunkChecksum->countChecksum());
-    CPPUNIT_ASSERT_EQUAL((size_t)262144, entry2->chunkChecksum->getChecksumLength());
+                         entry2->checksum->getDigest());
+    CPPUNIT_ASSERT_EQUAL((size_t)2, entry2->chunkChecksum->countPieceHash());
+    CPPUNIT_ASSERT_EQUAL((size_t)262144, entry2->chunkChecksum->getPieceLength());
     CPPUNIT_ASSERT_EQUAL(std::string("179463a88d79cbf0b1923991708aead914f26142"),
-                         entry2->chunkChecksum->getChecksum(0));
+                         entry2->chunkChecksum->getPieceHash(0));
     CPPUNIT_ASSERT_EQUAL(std::string("fecf8bc9a1647505fe16746f94e97a477597dbf3"),
-                         entry2->chunkChecksum->getChecksum(1));
-    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry2->checksum->getAlgo());
+                         entry2->chunkChecksum->getPieceHash(1));
+    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry2->checksum->getHashType());
 #endif // ENABLE_MESSAGE_DIGEST
     // See that signature is null
     CPPUNIT_ASSERT(!entry2->getSignature());
@@ -585,10 +585,10 @@ void MetalinkProcessorTest::testParseFile()
     SharedHandle<MetalinkEntry> entry4 = *entryItr;
     CPPUNIT_ASSERT_EQUAL(std::string("UnsupportedVerificationHashTypeIncluded"), entry4->getPath());
 #ifdef ENABLE_MESSAGE_DIGEST
-    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry4->checksum->getAlgo());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry4->checksum->getHashType());
     CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
-                         entry4->checksum->getMessageDigest());
-    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"),entry4->chunkChecksum->getAlgo());
+                         entry4->checksum->getDigest());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"),entry4->chunkChecksum->getHashType());
 #endif // ENABLE_MESSAGE_DIGEST
 
 
@@ -898,8 +898,8 @@ void MetalinkProcessorTest::testMultiplePieces()
     SharedHandle<MetalinkEntry> e = m->getEntries()[0];
     SharedHandle<ChunkChecksum> c = e->chunkChecksum;
  
-    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getAlgo());
-    CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getChecksumLength());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType());
+    CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getPieceLength());
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
@@ -932,8 +932,8 @@ void MetalinkProcessorTest::testBadPieceNo()
     SharedHandle<ChunkChecksum> c = e->chunkChecksum;
 
     CPPUNIT_ASSERT(c);
-    CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getChecksumLength());
-    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getAlgo());
+    CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getPieceLength());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType());
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
@@ -965,8 +965,8 @@ void MetalinkProcessorTest::testBadPieceLength()
     SharedHandle<MetalinkEntry> e = m->getEntries()[0];
     SharedHandle<ChunkChecksum> c = e->chunkChecksum;
     CPPUNIT_ASSERT(c);
-    CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getChecksumLength());
-    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getAlgo());
+    CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getPieceLength());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType());
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
@@ -998,8 +998,8 @@ void MetalinkProcessorTest::testUnsupportedType_piece()
     SharedHandle<ChunkChecksum> c = e->chunkChecksum;
  
     CPPUNIT_ASSERT(c);
-    CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getChecksumLength());
-    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getAlgo());
+    CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getPieceLength());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType());
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }