1 files changed, 87 insertions, 81 deletions

diff --git a/libtransport/src/core/manifest_format.h b/libtransport/src/core/manifest_format.h
index 90d221f5e..89412316a 100644
--- a/libtransport/src/core/manifest_format.h
+++ b/libtransport/src/core/manifest_format.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:
@@ -17,46 +17,40 @@
 
 #include <hicn/transport/auth/crypto_hash.h>
 #include <hicn/transport/core/name.h>
+#include <hicn/transport/interfaces/socket_options_keys.h>
+#include <protocols/fec_utils.h>
 
 #include <cinttypes>
 #include <type_traits>
 #include <unordered_map>
 
 namespace transport {
-
 namespace core {
 
-enum class ManifestFields : uint8_t {
-  VERSION,
-  HASH_ALGORITHM,
-  SEGMENT_CALCULATION_STRATEGY,
-  FINAL_MANIFEST,
-  NAME_HASH_LIST,
-  BASE_NAME
-};
-
-enum class ManifestVersion : uint8_t {
-  VERSION_1 = 1,
-};
-
 enum class ManifestType : uint8_t {
   INLINE_MANIFEST = 1,
   FINAL_CHUNK_NUMBER = 2,
   FLIC_MANIFEST = 3,
 };
 
-/**
- * INCREMENTAL: Manifests will be received inline with the data with no specific
- * assumption regarding the manifest capacity. Consumers can send interests
- * using a +1 heuristic.
- *
- * MANIFEST_CAPACITY_BASED: manifests with capacity N have a suffix multiple of
- * N+1: 0, N+1, 2(N+1) etc. Contents have a suffix incremented by 1 except when
- * it conflicts with a manifest: 1, 2, ..., N, N+2, N+3, ..., 2N+1, 2N+3
- */
-enum class NextSegmentCalculationStrategy : uint8_t {
-  INCREMENTAL = 1,
-  MANIFEST_CAPACITY_BASED = 2,
+struct ParamsRTC {
+  std::uint64_t timestamp;
+  std::uint32_t prod_rate;
+  std::uint32_t prod_seg;
+  protocol::fec::FECType fec_type;
+
+  bool operator==(const ParamsRTC &other) const {
+    return (timestamp == other.timestamp && prod_rate == other.prod_rate &&
+            prod_seg == other.prod_seg && fec_type == other.fec_type);
+  }
+};
+
+struct ParamsBytestream {
+  std::uint32_t final_segment;
+
+  bool operator==(const ParamsBytestream &other) const {
+    return (final_segment == other.final_segment);
+  }
 };
 
 template <typename T>
@@ -84,22 +78,25 @@ class ManifestEncoder {
     return static_cast<Implementation &>(*this).clearImpl();
   }
 
-  ManifestEncoder &setManifestType(ManifestType type) {
-    return static_cast<Implementation &>(*this).setManifestTypeImpl(type);
+  bool isEncoded() const {
+    return static_cast<const Implementation &>(*this).isEncodedImpl();
   }
 
-  ManifestEncoder &setHashAlgorithm(auth::CryptoHashType hash) {
-    return static_cast<Implementation &>(*this).setHashAlgorithmImpl(hash);
+  ManifestEncoder &setType(ManifestType type) {
+    return static_cast<Implementation &>(*this).setTypeImpl(type);
   }
 
-  ManifestEncoder &setFinalChunkNumber(uint32_t final_chunk) {
-    return static_cast<Implementation &>(*this).setFinalChunkImpl(final_chunk);
+  ManifestEncoder &setMaxCapacity(uint8_t max_capacity) {
+    return static_cast<Implementation &>(*this).setMaxCapacityImpl(
+        max_capacity);
   }
 
-  ManifestEncoder &setNextSegmentCalculationStrategy(
-      NextSegmentCalculationStrategy strategy) {
-    return static_cast<Implementation &>(*this)
-        .setNextSegmentCalculationStrategyImpl(strategy);
+  ManifestEncoder &setHashAlgorithm(auth::CryptoHashType hash) {
+    return static_cast<Implementation &>(*this).setHashAlgorithmImpl(hash);
+  }
+
+  ManifestEncoder &setIsLast(bool is_last) {
+    return static_cast<Implementation &>(*this).setIsLastImpl(is_last);
   }
 
   template <
@@ -110,40 +107,36 @@ class ManifestEncoder {
     return static_cast<Implementation &>(*this).setBaseNameImpl(name);
   }
 
-  template <typename Hash>
-  ManifestEncoder &addSuffixAndHash(uint32_t suffix, Hash &&hash) {
-    return static_cast<Implementation &>(*this).addSuffixAndHashImpl(
-        suffix, std::forward<Hash &&>(hash));
+  ManifestEncoder &setParamsBytestream(const ParamsBytestream &params) {
+    return static_cast<Implementation &>(*this).setParamsBytestreamImpl(params);
   }
 
-  ManifestEncoder &setIsFinalManifest(bool is_last) {
-    return static_cast<Implementation &>(*this).setIsFinalManifestImpl(is_last);
+  ManifestEncoder &setParamsRTC(const ParamsRTC &params) {
+    return static_cast<Implementation &>(*this).setParamsRTCImpl(params);
   }
 
-  ManifestEncoder &setVersion(ManifestVersion version) {
-    return static_cast<Implementation &>(*this).setVersionImpl(version);
-  }
-
-  std::size_t estimateSerializedLength(std::size_t number_of_entries) {
-    return static_cast<Implementation &>(*this).estimateSerializedLengthImpl(
-        number_of_entries);
+  template <typename Hash>
+  ManifestEncoder &addEntry(uint32_t suffix, Hash &&hash) {
+    return static_cast<Implementation &>(*this).addEntryImpl(
+        suffix, std::forward<Hash>(hash));
   }
 
-  ManifestEncoder &update() {
-    return static_cast<Implementation &>(*this).updateImpl();
+  ManifestEncoder &removeEntry(uint32_t suffix) {
+    return static_cast<Implementation &>(*this).removeEntryImpl(suffix);
   }
 
-  ManifestEncoder &setFinalBlockNumber(std::uint32_t final_block_number) {
-    return static_cast<Implementation &>(*this).setFinalBlockNumberImpl(
-        final_block_number);
+  std::size_t manifestHeaderSize() const {
+    return static_cast<const Implementation &>(*this).manifestHeaderSizeImpl();
   }
 
-  static std::size_t getManifestHeaderSize() {
-    return Implementation::getManifestHeaderSizeImpl();
+  std::size_t manifestPayloadSize(size_t additional_entries = 0) const {
+    return static_cast<const Implementation &>(*this).manifestPayloadSizeImpl(
+        additional_entries);
   }
 
-  static std::size_t getManifestEntrySize() {
-    return Implementation::getManifestEntrySizeImpl();
+  std::size_t manifestSize(size_t additional_entries = 0) const {
+    return static_cast<const Implementation &>(*this).manifestSizeImpl(
+        additional_entries);
   }
 };
 
@@ -152,55 +145,68 @@ class ManifestDecoder {
  public:
   virtual ~ManifestDecoder() = default;
 
+  ManifestDecoder &decode() {
+    return static_cast<Implementation &>(*this).decodeImpl();
+  }
+
   ManifestDecoder &clear() {
     return static_cast<Implementation &>(*this).clearImpl();
   }
 
-  void decode() { static_cast<Implementation &>(*this).decodeImpl(); }
+  bool isDecoded() const {
+    return static_cast<const Implementation &>(*this).isDecodedImpl();
+  }
 
-  ManifestType getManifestType() const {
-    return static_cast<const Implementation &>(*this).getManifestTypeImpl();
+  ManifestType getType() const {
+    return static_cast<const Implementation &>(*this).getTypeImpl();
   }
 
-  auth::CryptoHashType getHashAlgorithm() const {
-    return static_cast<const Implementation &>(*this).getHashAlgorithmImpl();
+  interface::ProductionProtocolAlgorithms getTransportType() const {
+    return static_cast<const Implementation &>(*this).getTransportTypeImpl();
+  }
+
+  uint8_t getMaxCapacity() const {
+    return static_cast<const Implementation &>(*this).getMaxCapacityImpl();
   }
 
-  uint32_t getFinalChunkNumber() const {
-    return static_cast<const Implementation &>(*this).getFinalChunkImpl();
+  auth::CryptoHashType getHashAlgorithm() const {
+    return static_cast<const Implementation &>(*this).getHashAlgorithmImpl();
   }
 
-  NextSegmentCalculationStrategy getNextSegmentCalculationStrategy() const {
-    return static_cast<const Implementation &>(*this)
-        .getNextSegmentCalculationStrategyImpl();
+  bool getIsLast() const {
+    return static_cast<const Implementation &>(*this).getIsLastImpl();
   }
 
   core::Name getBaseName() const {
     return static_cast<const Implementation &>(*this).getBaseNameImpl();
   }
 
-  auto getSuffixHashList() {
-    return static_cast<Implementation &>(*this).getSuffixHashListImpl();
+  ParamsBytestream getParamsBytestream() const {
+    return static_cast<const Implementation &>(*this).getParamsBytestreamImpl();
+  }
+
+  ParamsRTC getParamsRTC() const {
+    return static_cast<const Implementation &>(*this).getParamsRTCImpl();
   }
 
-  bool getIsFinalManifest() const {
-    return static_cast<const Implementation &>(*this).getIsFinalManifestImpl();
+  auto getEntries() const {
+    return static_cast<const Implementation &>(*this).getEntriesImpl();
   }
 
-  ManifestVersion getVersion() const {
-    return static_cast<const Implementation &>(*this).getVersionImpl();
+  std::size_t manifestHeaderSize() const {
+    return static_cast<const Implementation &>(*this).manifestHeaderSizeImpl();
   }
 
-  std::size_t estimateSerializedLength(std::size_t number_of_entries) const {
-    return static_cast<const Implementation &>(*this)
-        .estimateSerializedLengthImpl(number_of_entries);
+  std::size_t manifestPayloadSize(size_t additional_entries = 0) const {
+    return static_cast<const Implementation &>(*this).manifestPayloadSizeImpl(
+        additional_entries);
   }
 
-  uint32_t getFinalBlockNumber() const {
-    return static_cast<const Implementation &>(*this).getFinalBlockNumberImpl();
+  std::size_t manifestSize(size_t additional_entries = 0) const {
+    return static_cast<const Implementation &>(*this).manifestSizeImpl(
+        additional_entries);
   }
 };
 
 }  // namespace core
-
 }  // namespace transport