From f4433f28b509a9f67ca85d79000ccf9c2f4b7a24 Mon Sep 17 00:00:00 2001 From: Mauro Sardara Date: Fri, 21 Feb 2020 11:52:28 +0100 Subject: [HICN-534] Major rework on libtransport organization Change-Id: I361b83a18b4fd59be136d5f0817fc28e17e89884 Signed-off-by: Mauro Sardara --- libtransport/src/core/manifest_format.h | 210 ++++++++++++++++++++++++++++++++ 1 file changed, 210 insertions(+) create mode 100644 libtransport/src/core/manifest_format.h (limited to 'libtransport/src/core/manifest_format.h') diff --git a/libtransport/src/core/manifest_format.h b/libtransport/src/core/manifest_format.h new file mode 100644 index 000000000..f95d19aa8 --- /dev/null +++ b/libtransport/src/core/manifest_format.h @@ -0,0 +1,210 @@ +/* + * 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 +#include + +#include +#include +#include + +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(utils::CryptoHashType::SHA_256), + SHA_512 = static_cast(utils::CryptoHashType::SHA_512), + CRC32C = static_cast(utils::CryptoHashType::CRC32C), +}; + +/** + * 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, +}; + +template +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 +class ManifestEncoder { + public: + virtual ~ManifestEncoder() = default; + + ManifestEncoder encode() { + return static_cast(*this).encodeImpl(); + } + + ManifestEncoder &clear() { + return static_cast(*this).clearImpl(); + } + + ManifestEncoder &setManifestType(ManifestType type) { + return static_cast(*this).setManifestTypeImpl(type); + } + + ManifestEncoder &setHashAlgorithm(HashAlgorithm hash) { + return static_cast(*this).setHashAlgorithmImpl(hash); + } + + ManifestEncoder &setFinalChunkNumber(uint32_t final_chunk) { + return static_cast(*this).setFinalChunkImpl(final_chunk); + } + + ManifestEncoder &setNextSegmentCalculationStrategy( + NextSegmentCalculationStrategy strategy) { + return static_cast(*this) + .setNextSegmentCalculationStrategyImpl(strategy); + } + + template < + typename T, + typename = std::enable_if_t>, core::Name>::value>> + ManifestEncoder &setBaseName(T &&name) { + return static_cast(*this).setBaseNameImpl(name); + } + + template + ManifestEncoder &addSuffixAndHash(uint32_t suffix, Hash &&hash) { + return static_cast(*this).addSuffixAndHashImpl( + suffix, std::forward(hash)); + } + + ManifestEncoder &setIsFinalManifest(bool is_last) { + return static_cast(*this).setIsFinalManifestImpl(is_last); + } + + ManifestEncoder &setVersion(ManifestVersion version) { + return static_cast(*this).setVersionImpl(version); + } + + std::size_t estimateSerializedLength(std::size_t number_of_entries) { + return static_cast(*this).estimateSerializedLengthImpl( + number_of_entries); + } + + ManifestEncoder &update() { + return static_cast(*this).updateImpl(); + } + + ManifestEncoder &setFinalBlockNumber(std::uint32_t final_block_number) { + return static_cast(*this).setFinalBlockNumberImpl( + final_block_number); + } + + static std::size_t getManifestHeaderSize() { + return Implementation::getManifestHeaderSizeImpl(); + } + + static std::size_t getManifestEntrySize() { + return Implementation::getManifestEntrySizeImpl(); + } +}; + +template +class ManifestDecoder { + public: + virtual ~ManifestDecoder() = default; + + ManifestDecoder &clear() { + return static_cast(*this).clearImpl(); + } + + void decode() { static_cast(*this).decodeImpl(); } + + ManifestType getManifestType() const { + return static_cast(*this).getManifestTypeImpl(); + } + + HashAlgorithm getHashAlgorithm() const { + return static_cast(*this).getHashAlgorithmImpl(); + } + + uint32_t getFinalChunkNumber() const { + return static_cast(*this).getFinalChunkImpl(); + } + + NextSegmentCalculationStrategy getNextSegmentCalculationStrategy() const { + return static_cast(*this) + .getNextSegmentCalculationStrategyImpl(); + } + + core::Name getBaseName() const { + return static_cast(*this).getBaseNameImpl(); + } + + auto getSuffixHashList() { + return static_cast(*this).getSuffixHashListImpl(); + } + + bool getIsFinalManifest() const { + return static_cast(*this).getIsFinalManifestImpl(); + } + + ManifestVersion getVersion() const { + return static_cast(*this).getVersionImpl(); + } + + std::size_t estimateSerializedLength(std::size_t number_of_entries) const { + return static_cast(*this) + .estimateSerializedLengthImpl(number_of_entries); + } + + uint32_t getFinalBlockNumber() const { + return static_cast(*this).getFinalBlockNumberImpl(); + } +}; + +} // namespace core + +} // namespace transport -- cgit 1.2.3-korg