[HICN-538] Use type utils::CryptoHashtype instead of HashAlgorithm everywhere

Change-Id: Iddbc427611c888b28059170a70c0925ebb299cb5
Signed-off-by: Mauro Sardara <msardara@cisco.com>

6 files changed, 12 insertions, 18 deletions

diff --git a/libtransport/src/core/manifest.h b/libtransport/src/core/manifest.h
index b4875bf22..eadfed752 100644
--- a/libtransport/src/core/manifest.h
+++ b/libtransport/src/core/manifest.h
@@ -96,13 +96,13 @@ class Manifest : public Base {
     return *this;
   }
 
-  Manifest &setHashAlgorithm(HashAlgorithm hash_algorithm) {
+  Manifest &setHashAlgorithm(utils::CryptoHashType hash_algorithm) {
     hash_algorithm_ = hash_algorithm;
     encoder_.setHashAlgorithm(hash_algorithm_);
     return *this;
   }
 
-  HashAlgorithm getHashAlgorithm() { return hash_algorithm_; }
+  utils::CryptoHashType getHashAlgorithm() { return hash_algorithm_; }
 
   ManifestType getManifestType() const { return manifest_type_; }
 
@@ -138,7 +138,7 @@ class Manifest : public Base {
 
  protected:
   ManifestType manifest_type_;
-  HashAlgorithm hash_algorithm_;
+  utils::CryptoHashType hash_algorithm_;
   bool is_last_;
 
   Encoder encoder_;
diff --git a/libtransport/src/core/manifest_format.h b/libtransport/src/core/manifest_format.h
index f95d19aa8..36d23f99b 100644
--- a/libtransport/src/core/manifest_format.h
+++ b/libtransport/src/core/manifest_format.h
@@ -45,12 +45,6 @@ enum class ManifestType : uint8_t {
   FLIC_MANIFEST = 3,
 };
 
-enum class HashAlgorithm : uint8_t {
-  SHA_256 = static_cast<uint8_t>(utils::CryptoHashType::SHA_256),
-  SHA_512 = static_cast<uint8_t>(utils::CryptoHashType::SHA_512),
-  CRC32C = static_cast<uint8_t>(utils::CryptoHashType::CRC32C),
-};
-
 /**
  * INCREMENTAL: Manifests will be received inline with the data with no specific
  * assumption regarding the manifest capacity. Consumers can send interests
@@ -92,7 +86,7 @@ class ManifestEncoder {
     return static_cast<Implementation &>(*this).setManifestTypeImpl(type);
   }
 
-  ManifestEncoder &setHashAlgorithm(HashAlgorithm hash) {
+  ManifestEncoder &setHashAlgorithm(utils::CryptoHashType hash) {
     return static_cast<Implementation &>(*this).setHashAlgorithmImpl(hash);
   }
 
@@ -166,7 +160,7 @@ class ManifestDecoder {
     return static_cast<const Implementation &>(*this).getManifestTypeImpl();
   }
 
-  HashAlgorithm getHashAlgorithm() const {
+  utils::CryptoHashType getHashAlgorithm() const {
     return static_cast<const Implementation &>(*this).getHashAlgorithmImpl();
   }
 
diff --git a/libtransport/src/core/manifest_format_fixed.cc b/libtransport/src/core/manifest_format_fixed.cc
index 4073a5d26..ca80c38b1 100644
--- a/libtransport/src/core/manifest_format_fixed.cc
+++ b/libtransport/src/core/manifest_format_fixed.cc
@@ -55,7 +55,7 @@ FixedManifestEncoder &FixedManifestEncoder::clearImpl() {
 }
 
 FixedManifestEncoder &FixedManifestEncoder::setHashAlgorithmImpl(
-    HashAlgorithm algorithm) {
+    utils::CryptoHashType algorithm) {
   manifest_header_->hash_algorithm = static_cast<uint8_t>(algorithm);
   return *this;
 }
@@ -170,8 +170,8 @@ ManifestType FixedManifestDecoder::getManifestTypeImpl() const {
   return static_cast<ManifestType>(manifest_header_->manifest_type);
 }
 
-HashAlgorithm FixedManifestDecoder::getHashAlgorithmImpl() const {
-  return static_cast<HashAlgorithm>(manifest_header_->hash_algorithm);
+utils::CryptoHashType FixedManifestDecoder::getHashAlgorithmImpl() const {
+  return static_cast<utils::CryptoHashType>(manifest_header_->hash_algorithm);
 }
 
 NextSegmentCalculationStrategy
diff --git a/libtransport/src/core/manifest_format_fixed.h b/libtransport/src/core/manifest_format_fixed.h
index 9cacb3bc2..1d7cd7d32 100644
--- a/libtransport/src/core/manifest_format_fixed.h
+++ b/libtransport/src/core/manifest_format_fixed.h
@@ -94,7 +94,7 @@ class FixedManifestEncoder : public ManifestEncoder<FixedManifestEncoder> {
 
   FixedManifestEncoder &setManifestTypeImpl(ManifestType manifest_type);
 
-  FixedManifestEncoder &setHashAlgorithmImpl(HashAlgorithm algorithm);
+  FixedManifestEncoder &setHashAlgorithmImpl(utils::CryptoHashType algorithm);
 
   FixedManifestEncoder &setNextSegmentCalculationStrategyImpl(
       NextSegmentCalculationStrategy strategy);
@@ -144,7 +144,7 @@ class FixedManifestDecoder : public ManifestDecoder<FixedManifestDecoder> {
 
   ManifestType getManifestTypeImpl() const;
 
-  HashAlgorithm getHashAlgorithmImpl() const;
+  utils::CryptoHashType getHashAlgorithmImpl() const;
 
   NextSegmentCalculationStrategy getNextSegmentCalculationStrategyImpl() const;
 
diff --git a/libtransport/src/core/manifest_inline.h b/libtransport/src/core/manifest_inline.h
index 235c6f3a0..0227fa93a 100644
--- a/libtransport/src/core/manifest_inline.h
+++ b/libtransport/src/core/manifest_inline.h
@@ -44,7 +44,7 @@ class ManifestInline
 
   static TRANSPORT_ALWAYS_INLINE ManifestInline *createManifest(
       const core::Name &manifest_name, ManifestVersion version,
-      ManifestType type, HashAlgorithm algorithm, bool is_last,
+      ManifestType type, utils::CryptoHashType algorithm, bool is_last,
       const Name &base_name, NextSegmentCalculationStrategy strategy,
       std::size_t signature_size) {
     auto manifest = new ManifestInline(manifest_name, signature_size);
diff --git a/libtransport/src/core/packet.cc b/libtransport/src/core/packet.cc
index 817f8de66..67e647fca 100644
--- a/libtransport/src/core/packet.cc
+++ b/libtransport/src/core/packet.cc
@@ -344,7 +344,7 @@ utils::KeyId Packet::getKeyId() const {
   return return_value;
 }
 
-utils::CryptoHash Packet::computeDigest(HashAlgorithm algorithm) const {
+utils::CryptoHash Packet::computeDigest(utils::CryptoHashType algorithm) const {
   utils::CryptoHasher hasher(static_cast<utils::CryptoHashType>(algorithm));
   hasher.init();