From bac3da61644515f05663789b122554dc77549286 Mon Sep 17 00:00:00 2001
From: Luca Muscariello <lumuscar+fdio@cisco.com>
Date: Thu, 17 Jan 2019 13:47:57 +0100
Subject: This is the first commit of the hicn project

Change-Id: I6f2544ad9b9f8891c88cc4bcce3cf19bd3cc863f
Signed-off-by: Luca Muscariello <lumuscar+fdio@cisco.com>
---
 .../src/hicn/transport/core/manifest_format.h      | 196 +++++++++++++++++++++
 1 file changed, 196 insertions(+)
 create mode 100755 libtransport/src/hicn/transport/core/manifest_format.h

(limited to 'libtransport/src/hicn/transport/core/manifest_format.h')

diff --git a/libtransport/src/hicn/transport/core/manifest_format.h b/libtransport/src/hicn/transport/core/manifest_format.h
new file mode 100755
index 000000000..1dcf013dc
--- /dev/null
+++ b/libtransport/src/hicn/transport/core/manifest_format.h
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2017-2019 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:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <hicn/transport/core/name.h>
+#include <hicn/transport/utils/crypto_hasher.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,
+};
+
+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),
+};
+
+enum class NextSegmentCalculationStrategy : uint8_t {
+  INCREMENTAL = 1,
+};
+
+template <typename T>
+struct format_traits {
+  using Encoder = typename T::Encoder;
+  using Decoder = typename T::Decoder;
+  using HashType = typename T::HashType;
+  using HashList = typename T::HashList;
+};
+
+class Packet;
+
+template <typename Implementation>
+class ManifestEncoder {
+ public:
+  virtual ~ManifestEncoder() = default;
+
+  ManifestEncoder encode() {
+    return static_cast<Implementation&>(*this).encodeImpl();
+  }
+
+  ManifestEncoder& clear() {
+    return static_cast<Implementation&>(*this).clearImpl();
+  }
+
+  ManifestEncoder& setManifestType(ManifestType type) {
+    return static_cast<Implementation&>(*this).setManifestTypeImpl(type);
+  }
+
+  ManifestEncoder& setHashAlgorithm(HashAlgorithm hash) {
+    return static_cast<Implementation&>(*this).setHashAlgorithmImpl(hash);
+  }
+
+  ManifestEncoder& setFinalChunkNumber(uint32_t final_chunk) {
+    return static_cast<Implementation&>(*this).setFinalChunkImpl(final_chunk);
+  }
+
+  ManifestEncoder& setNextSegmentCalculationStrategy(
+      NextSegmentCalculationStrategy strategy) {
+    return static_cast<Implementation&>(*this)
+        .setNextSegmentCalculationStrategyImpl(strategy);
+  }
+
+  template <
+      typename T,
+      typename = std::enable_if_t<std::is_same<
+          std::remove_const_t<std::remove_reference_t<T>>, core::Name>::value>>
+  ManifestEncoder& setBaseName(T&& name) {
+    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& setIsFinalManifest(bool is_last) {
+    return static_cast<Implementation&>(*this).setIsFinalManifestImpl(is_last);
+  }
+
+  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);
+  }
+
+  ManifestEncoder& update() {
+    return static_cast<Implementation&>(*this).updateImpl();
+  }
+
+  ManifestEncoder& setFinalBlockNumber(std::uint32_t final_block_number) {
+    return static_cast<Implementation&>(*this).setFinalBlockNumberImpl(
+        final_block_number);
+  }
+
+  static std::size_t getManifestHeaderSize() {
+    return Implementation::getManifestHeaderSizeImpl();
+  }
+};
+
+template <typename Implementation>
+class ManifestDecoder {
+ public:
+  virtual ~ManifestDecoder() = default;
+
+  ManifestDecoder& clear() {
+    return static_cast<Implementation&>(*this).clearImpl();
+  }
+
+  void decode() { static_cast<Implementation&>(*this).decodeImpl(); }
+
+  ManifestType getManifestType() const {
+    return static_cast<const Implementation&>(*this).getManifestTypeImpl();
+  }
+
+  HashAlgorithm getHashAlgorithm() const {
+    return static_cast<const Implementation&>(*this).getHashAlgorithmImpl();
+  }
+
+  uint32_t getFinalChunkNumber() const {
+    return static_cast<const Implementation&>(*this).getFinalChunkImpl();
+  }
+
+  NextSegmentCalculationStrategy getNextSegmentCalculationStrategy() const {
+    return static_cast<const Implementation&>(*this)
+        .getNextSegmentCalculationStrategyImpl();
+  }
+
+  core::Name getBaseName() const {
+    return static_cast<const Implementation&>(*this).getBaseNameImpl();
+  }
+
+  auto getSuffixHashList() {
+    return static_cast<Implementation&>(*this).getSuffixHashListImpl();
+  }
+
+  bool getIsFinalManifest() const {
+    return static_cast<const Implementation&>(*this).getIsFinalManifestImpl();
+  }
+
+  ManifestVersion getVersion() const {
+    return static_cast<const Implementation&>(*this).getVersionImpl();
+  }
+
+  std::size_t estimateSerializedLength(std::size_t number_of_entries) const {
+    return static_cast<const Implementation&>(*this)
+        .estimateSerializedLengthImpl(number_of_entries);
+  }
+
+  uint32_t getFinalBlockNumber() const {
+    return static_cast<const Implementation&>(*this).getFinalBlockNumberImpl();
+  }
+};
+
+}  // namespace core
+
+}  // namespace transport
\ No newline at end of file
-- 
cgit 1.2.3-korg