1 files changed, 57 insertions, 109 deletions

diff --git a/libtransport/src/utils/suffix_strategy.h b/libtransport/src/utils/suffix_strategy.h
index ee016308e..4b3ddbc74 100644
--- a/libtransport/src/utils/suffix_strategy.h
+++ b/libtransport/src/utils/suffix_strategy.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:
@@ -15,72 +15,88 @@
 
 #pragma once
 
-#include <core/manifest_format.h>
+#include <hicn/transport/core/name.h>
+#include <hicn/transport/errors/runtime_exception.h>
 
 namespace utils {
 
-using transport::core::NextSegmentCalculationStrategy;
+/**
+ * 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 NextSuffixStrategy : uint8_t {
+  INCREMENTAL = 1,
+};
 
 class SuffixStrategy {
  public:
-  static constexpr uint32_t INVALID_SUFFIX =
-      std::numeric_limits<uint32_t>::max();
+  static constexpr uint32_t MAX_SUFFIX = std::numeric_limits<uint32_t>::max();
+  static constexpr uint8_t MANIFEST_MAX_CAPACITY =
+      std::numeric_limits<uint8_t>::max();
 
-  SuffixStrategy(NextSegmentCalculationStrategy strategy)
+  SuffixStrategy(NextSuffixStrategy strategy, uint32_t offset = 0,
+                 uint32_t manifest_capacity = MANIFEST_MAX_CAPACITY)
       : suffix_stragegy_(strategy),
+        next_suffix_(offset),
+        manifest_capacity_(manifest_capacity),
         total_count_(0),
-        final_suffix_(INVALID_SUFFIX) {}
+        final_suffix_(MAX_SUFFIX) {}
 
   virtual ~SuffixStrategy() = default;
 
-  virtual uint32_t checkNextSuffix() = 0;
-
+  virtual uint32_t checkNextSuffix() const = 0;
   virtual uint32_t getNextSuffix() = 0;
 
-  virtual uint32_t getFinalSuffix() { return final_suffix_; }
-
-  virtual void setFinalSuffix(std::uint32_t final_suffix) {
-    if (final_suffix != INVALID_SUFFIX) {
-      final_suffix_ = final_suffix;
-    }
-  }
-
-  virtual uint32_t checkNextManifestSuffix() = 0;
-
+  virtual uint32_t checkNextManifestSuffix() const = 0;
   virtual uint32_t getNextManifestSuffix() = 0;
 
-  virtual uint32_t checkNextContentSuffix() = 0;
-
+  virtual uint32_t checkNextContentSuffix() const = 0;
   virtual uint32_t getNextContentSuffix() = 0;
 
-  virtual void reset(uint32_t offset = 0) = 0;
+  virtual void reset(uint32_t offset = 0) {
+    next_suffix_ = offset;
+    total_count_ = 0;
+  }
 
-  virtual uint32_t getManifestCapacity() = 0;
+  virtual uint32_t getManifestCapacity() const { return manifest_capacity_; };
 
-  virtual void setManifestCapacity(uint32_t capacity) = 0;
+  virtual void setManifestCapacity(uint8_t capacity) {
+    manifest_capacity_ = capacity;
+  }
 
-  virtual uint32_t getTotalCount() { return total_count_; };
+  virtual uint32_t getFinalSuffix() const { return final_suffix_; }
 
-  NextSegmentCalculationStrategy getSuffixStrategy() {
-    return suffix_stragegy_;
+  virtual void setFinalSuffix(std::uint32_t final_suffix) {
+    if (final_suffix != MAX_SUFFIX) {
+      final_suffix_ = final_suffix;
+    }
   }
 
- protected:
-  inline void incrementTotalCount() { total_count_++; };
+  NextSuffixStrategy getSuffixStrategy() const { return suffix_stragegy_; }
+
+  virtual uint32_t getTotalCount() const { return total_count_; }
 
  protected:
-  NextSegmentCalculationStrategy suffix_stragegy_;
+  NextSuffixStrategy suffix_stragegy_;
+  std::uint32_t next_suffix_;
+  std::uint8_t manifest_capacity_;
   std::uint32_t total_count_;
   std::uint32_t final_suffix_;
+
+  inline void incrementTotalCount() { total_count_++; };
 };
 
 class IncrementalSuffixStrategy : public SuffixStrategy {
  public:
   IncrementalSuffixStrategy(std::uint32_t start_offset)
-      : SuffixStrategy(NextSegmentCalculationStrategy::INCREMENTAL),
-        next_suffix_(start_offset) {}
+      : SuffixStrategy(NextSuffixStrategy::INCREMENTAL, start_offset) {}
 
-  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextSuffix() override {
+  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextSuffix() const override {
     return next_suffix_;
   }
 
@@ -89,7 +105,8 @@ class IncrementalSuffixStrategy : public SuffixStrategy {
     return next_suffix_++;
   }
 
-  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextContentSuffix() override {
+  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextContentSuffix()
+      const override {
     return checkNextSuffix();
   }
 
@@ -97,7 +114,8 @@ class IncrementalSuffixStrategy : public SuffixStrategy {
     return getNextSuffix();
   }
 
-  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextManifestSuffix() override {
+  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextManifestSuffix()
+      const override {
     return checkNextSuffix();
   }
 
@@ -105,90 +123,20 @@ class IncrementalSuffixStrategy : public SuffixStrategy {
     return getNextSuffix();
   }
 
-  uint32_t getManifestCapacity() override {
-    throw errors::RuntimeException(
-        "No manifest capacity in IncrementalSuffixStrategy.");
-  }
-
-  void setManifestCapacity(uint32_t capacity) override {
-    throw errors::RuntimeException(
-        "No manifest capacity in IncrementalSuffixStrategy.");
-  }
-
   void reset(std::uint32_t offset = 0) override { next_suffix_ = offset; }
-
- protected:
-  std::uint32_t next_suffix_;
-};
-
-class CapacityBasedSuffixStrategy : public SuffixStrategy {
- public:
-  CapacityBasedSuffixStrategy(std::uint32_t start_offset,
-                              std::uint32_t manifest_capacity)
-      : SuffixStrategy(NextSegmentCalculationStrategy::INCREMENTAL),
-        next_suffix_(start_offset),
-        segments_in_manifest_(manifest_capacity),
-        current_manifest_iteration_(0) {}
-
-  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextSuffix() override {
-    return next_suffix_;
-  }
-
-  TRANSPORT_ALWAYS_INLINE std::uint32_t getNextSuffix() override {
-    incrementTotalCount();
-    return next_suffix_++;
-  }
-
-  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextContentSuffix() override {
-    return next_suffix_ % segments_in_manifest_ == 0 ? next_suffix_
-                                                     : (next_suffix_ + 1);
-  }
-
-  TRANSPORT_ALWAYS_INLINE std::uint32_t getNextContentSuffix() override {
-    incrementTotalCount();
-    return next_suffix_ % segments_in_manifest_ == 0 ? next_suffix_++
-                                                     : ++next_suffix_;
-  }
-
-  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextManifestSuffix() override {
-    return (current_manifest_iteration_ + 1) * (segments_in_manifest_ + 1);
-  }
-
-  TRANSPORT_ALWAYS_INLINE std::uint32_t getNextManifestSuffix() override {
-    incrementTotalCount();
-    return (current_manifest_iteration_++) * (segments_in_manifest_ + 1);
-  }
-
-  TRANSPORT_ALWAYS_INLINE uint32_t getManifestCapacity() override {
-    return segments_in_manifest_;
-  }
-
-  TRANSPORT_ALWAYS_INLINE void setManifestCapacity(uint32_t capacity) override {
-    segments_in_manifest_ = capacity;
-  }
-
-  void reset(std::uint32_t offset = 0) override { next_suffix_ = offset; }
-
- protected:
-  std::uint32_t next_suffix_;
-  std::uint32_t segments_in_manifest_;
-  std::uint32_t current_manifest_iteration_;
 };
 
 class SuffixStrategyFactory {
  public:
   static std::unique_ptr<SuffixStrategy> getSuffixStrategy(
-      NextSegmentCalculationStrategy strategy, uint32_t start_offset,
-      uint32_t manifest_capacity = 0) {
+      NextSuffixStrategy strategy, uint32_t start_offset = 0,
+      uint32_t manifest_capacity = SuffixStrategy::MANIFEST_MAX_CAPACITY) {
     switch (strategy) {
-      case NextSegmentCalculationStrategy::INCREMENTAL:
+      case NextSuffixStrategy::INCREMENTAL:
         return std::make_unique<IncrementalSuffixStrategy>(start_offset);
-      case NextSegmentCalculationStrategy::MANIFEST_CAPACITY_BASED:
-        return std::make_unique<CapacityBasedSuffixStrategy>(start_offset,
-                                                             manifest_capacity);
       default:
         throw errors::RuntimeException(
-            "No valid NextSegmentCalculationStrategy specified.");
+            "No valid NextSuffixStrategy specified.");
     }
   }
 };