1 files changed, 43 insertions, 108 deletions

diff --git a/libtransport/src/core/manifest.h b/libtransport/src/core/manifest.h
index 9b25ebd67..40832bb6b 100644
--- a/libtransport/src/core/manifest.h
+++ b/libtransport/src/core/manifest.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,138 +16,73 @@
 #pragma once
 
 #include <core/manifest_format.h>
-#include <hicn/transport/core/content_object.h>
-#include <hicn/transport/core/name.h>
-
-#include <set>
+#include <glog/logging.h>
+#include <hicn/transport/auth/verifier.h>
+#include <hicn/transport/core/global_object_pool.h>
+#include <hicn/transport/core/packet.h>
 
 namespace transport {
-
 namespace core {
 
-using typename core::Name;
-using typename core::Packet;
-using typename core::PayloadType;
-
-template <typename Base, typename FormatTraits, typename ManifestImpl>
-class Manifest : public Base {
-  static_assert(std::is_base_of<Packet, Base>::value,
-                "Base must inherit from packet!");
-
+template <typename FormatTraits>
+class Manifest : public FormatTraits::Encoder, public FormatTraits::Decoder {
  public:
-  // core::ContentObjectManifest::Ptr
+  using Ptr = std::shared_ptr<Manifest>;
 
   using Encoder = typename FormatTraits::Encoder;
   using Decoder = typename FormatTraits::Decoder;
 
-  Manifest(std::size_t signature_size = 0)
-      : Base(HF_INET6_TCP_AH, signature_size),
-        encoder_(*this, signature_size),
-        decoder_(*this) {
-    Base::setPayloadType(PayloadType::MANIFEST);
-  }
-
-  Manifest(const core::Name &name, std::size_t signature_size = 0)
-      : Base(name, HF_INET6_TCP_AH, signature_size),
-        encoder_(*this, signature_size),
-        decoder_(*this) {
-    Base::setPayloadType(PayloadType::MANIFEST);
-  }
+  using Hash = typename FormatTraits::Hash;
+  using HashType = typename FormatTraits::HashType;
+  using Suffix = typename FormatTraits::Suffix;
+  using SuffixList = typename FormatTraits::SuffixList;
+  using HashEntry = std::pair<auth::CryptoHashType, std::vector<uint8_t>>;
 
-  template <typename T>
-  Manifest(T &&base)
-      : Base(std::forward<T &&>(base)),
-        encoder_(*this, 0, false),
-        decoder_(*this) {
-    Base::setPayloadType(PayloadType::MANIFEST);
+  Manifest(Packet::Ptr packet, bool clear = false)
+      : Encoder(packet, clear), Decoder(packet), packet_(packet) {
+    packet->setPayloadType(PayloadType::MANIFEST);
   }
 
   virtual ~Manifest() = default;
 
-  std::size_t estimateManifestSize(std::size_t additional_entries = 0) {
-    return static_cast<ManifestImpl &>(*this).estimateManifestSizeImpl(
-        additional_entries);
-  }
+  Packet::Ptr getPacket() const { return packet_; }
 
-  /*
-   * After the call to encode, users MUST call clear before adding data
-   * to the manifest.
-   */
-  Manifest &encode() { return static_cast<ManifestImpl &>(*this).encodeImpl(); }
-
-  Manifest &decode() {
-    Manifest::decoder_.decode();
-
-    manifest_type_ = decoder_.getManifestType();
-    hash_algorithm_ = decoder_.getHashAlgorithm();
-    is_last_ = decoder_.getIsFinalManifest();
-
-    return static_cast<ManifestImpl &>(*this).decodeImpl();
+  void setHeaders(ManifestType type, uint8_t max_capacity, HashType hash_algo,
+                  bool is_last, const Name &base_name) {
+    Encoder::setType(type);
+    Encoder::setMaxCapacity(max_capacity);
+    Encoder::setHashAlgorithm(hash_algo);
+    Encoder::setIsLast(is_last);
+    Encoder::setBaseName(base_name);
   }
 
-  static std::size_t getManifestHeaderSize() {
-    return Encoder::getManifestHeaderSize();
-  }
+  auth::Verifier::SuffixMap getSuffixMap() const {
+    auth::Verifier::SuffixMap suffix_map;
 
-  static std::size_t getManifestEntrySize() {
-    return Encoder::getManifestEntrySize();
-  }
+    HashType hash_algo = Decoder::getHashAlgorithm();
+    SuffixList suffix_list = Decoder::getEntries();
 
-  Manifest &setManifestType(ManifestType type) {
-    manifest_type_ = type;
-    encoder_.setManifestType(manifest_type_);
-    return *this;
-  }
+    for (auto it = suffix_list.begin(); it != suffix_list.end(); ++it) {
+      Hash hash(it->second, Hash::getSize(hash_algo), hash_algo);
+      suffix_map[it->first] = hash;
+    }
 
-  Manifest &setHashAlgorithm(auth::CryptoHashType hash_algorithm) {
-    hash_algorithm_ = hash_algorithm;
-    encoder_.setHashAlgorithm(hash_algorithm_);
-    return *this;
+    return suffix_map;
   }
 
-  auth::CryptoHashType getHashAlgorithm() { return hash_algorithm_; }
-
-  ManifestType getManifestType() const { return manifest_type_; }
-
-  bool isFinalManifest() const { return is_last_; }
-
-  Manifest &setVersion(ManifestVersion version) {
-    encoder_.setVersion(version);
-    return *this;
-  }
-
-  Manifest &setFinalBlockNumber(std::uint32_t final_block_number) {
-    encoder_.setFinalBlockNumber(final_block_number);
-    return *this;
-  }
-
-  uint32_t getFinalBlockNumber() const {
-    return decoder_.getFinalBlockNumber();
-  }
-
-  ManifestVersion getVersion() const { return decoder_.getVersion(); }
-
-  Manifest &setFinalManifest(bool is_final_manifest) {
-    encoder_.setIsFinalManifest(is_final_manifest);
-    is_last_ = is_final_manifest;
-    return *this;
-  }
-
-  Manifest &clear() {
-    encoder_.clear();
-    decoder_.clear();
-    return *this;
-  }
+  static Manifest::Ptr createContentManifest(Packet::Format format,
+                                             const core::Name &manifest_name,
+                                             std::size_t signature_size) {
+    ContentObject::Ptr content_object =
+        core::PacketManager<>::getInstance().getPacket<ContentObject>(
+            format, signature_size);
+    content_object->setName(manifest_name);
+    return std::make_shared<Manifest>(content_object, true);
+  };
 
  protected:
-  ManifestType manifest_type_;
-  auth::CryptoHashType hash_algorithm_;
-  bool is_last_;
-
-  Encoder encoder_;
-  Decoder decoder_;
+  Packet::Ptr packet_;
 };
 
 }  // end namespace core
-
 }  // end namespace transport