- Code style fix

- Improved vpp binary api interface
- Correction in object pool destructor
- Fix error in Memif Connector

Change-Id: Id1dd9219fc1ac0b3717ae019ebff17373bebc635
Signed-off-by: Mauro Sardara <msardara@cisco.com>

1 files changed, 32 insertions, 32 deletions

diff --git a/libtransport/src/hicn/transport/core/manifest_format_fixed.cc b/libtransport/src/hicn/transport/core/manifest_format_fixed.cc
index f26f20adb..6141ae311 100755..100644
--- a/libtransport/src/hicn/transport/core/manifest_format_fixed.cc
+++ b/libtransport/src/hicn/transport/core/manifest_format_fixed.cc
@@ -23,72 +23,72 @@ namespace transport {
 namespace core {
 
 // TODO use preallocated pool of membufs
-FixedManifestEncoder::FixedManifestEncoder(Packet& packet)
+FixedManifestEncoder::FixedManifestEncoder(Packet &packet)
     : packet_(packet),
       max_size_(Packet::default_mtu - packet_.headerSize()),
       manifest_(
           utils::MemBuf::create(Packet::default_mtu - packet_.headerSize())),
       manifest_header_(
-          reinterpret_cast<ManifestHeader*>(manifest_->writableData())),
-      manifest_entries_(reinterpret_cast<ManifestEntry*>(
+          reinterpret_cast<ManifestHeader *>(manifest_->writableData())),
+      manifest_entries_(reinterpret_cast<ManifestEntry *>(
           manifest_->writableData() + sizeof(ManifestHeader))),
       current_entry_(0) {}
 
 FixedManifestEncoder::~FixedManifestEncoder() {}
 
-FixedManifestEncoder& FixedManifestEncoder::encodeImpl() {
+FixedManifestEncoder &FixedManifestEncoder::encodeImpl() {
   packet_.appendPayload(std::move(manifest_));
   return *this;
 }
 
-FixedManifestEncoder& FixedManifestEncoder::clearImpl() {
+FixedManifestEncoder &FixedManifestEncoder::clearImpl() {
   manifest_ = utils::MemBuf::create(Packet::default_mtu - packet_.headerSize());
   return *this;
 }
 
-FixedManifestEncoder& FixedManifestEncoder::setHashAlgorithmImpl(
+FixedManifestEncoder &FixedManifestEncoder::setHashAlgorithmImpl(
     HashAlgorithm algorithm) {
   manifest_header_->hash_algorithm = static_cast<uint8_t>(algorithm);
   return *this;
 }
 
-FixedManifestEncoder& FixedManifestEncoder::setManifestTypeImpl(
+FixedManifestEncoder &FixedManifestEncoder::setManifestTypeImpl(
     ManifestType manifest_type) {
   manifest_header_->manifest_type = static_cast<uint8_t>(manifest_type);
   return *this;
 }
 
-FixedManifestEncoder&
+FixedManifestEncoder &
 FixedManifestEncoder::setNextSegmentCalculationStrategyImpl(
     NextSegmentCalculationStrategy strategy) {
   manifest_header_->next_segment_strategy = static_cast<uint8_t>(strategy);
   return *this;
 }
 
-FixedManifestEncoder& FixedManifestEncoder::setBaseNameImpl(
-    const core::Name& base_name) {
+FixedManifestEncoder &FixedManifestEncoder::setBaseNameImpl(
+    const core::Name &base_name) {
   base_name.copyToDestination(
-      reinterpret_cast<uint8_t*>(&manifest_header_->prefix[0]), false);
+      reinterpret_cast<uint8_t *>(&manifest_header_->prefix[0]), false);
   manifest_header_->flags.ipv6 =
       base_name.getAddressFamily() == AF_INET6 ? 1_U8 : 0_U8;
   return *this;
 }
 
-FixedManifestEncoder& FixedManifestEncoder::addSuffixAndHashImpl(
-    uint32_t suffix, const utils::CryptoHash& hash) {
+FixedManifestEncoder &FixedManifestEncoder::addSuffixAndHashImpl(
+    uint32_t suffix, const utils::CryptoHash &hash) {
   auto _hash = hash.getDigest<std::uint8_t>();
   addSuffixHashBytes(suffix, _hash.data(), _hash.length());
   return *this;
 }
 
 void FixedManifestEncoder::addSuffixHashBytes(uint32_t suffix,
-                                              const uint8_t* hash,
+                                              const uint8_t *hash,
                                               std::size_t length) {
   manifest_entries_[current_entry_].suffix = utils::hton(suffix);
   //  std::copy(hash, hash + length,
   //            manifest_entries_[current_entry_].hash);
   std::memcpy(
-      reinterpret_cast<uint8_t*>(manifest_entries_[current_entry_].hash), hash,
+      reinterpret_cast<uint8_t *>(manifest_entries_[current_entry_].hash), hash,
       length);
 
   manifest_header_->number_of_entries++;
@@ -99,13 +99,13 @@ void FixedManifestEncoder::addSuffixHashBytes(uint32_t suffix,
   }
 }
 
-FixedManifestEncoder& FixedManifestEncoder::setIsFinalManifestImpl(
+FixedManifestEncoder &FixedManifestEncoder::setIsFinalManifestImpl(
     bool is_last) {
   manifest_header_->flags.is_last = static_cast<uint8_t>(is_last);
   return *this;
 }
 
-FixedManifestEncoder& FixedManifestEncoder::setVersionImpl(
+FixedManifestEncoder &FixedManifestEncoder::setVersionImpl(
     ManifestVersion version) {
   manifest_header_->version = static_cast<uint8_t>(version);
   return *this;
@@ -118,17 +118,17 @@ std::size_t FixedManifestEncoder::estimateSerializedLengthImpl(
              sizeof(ManifestEntry);
 }
 
-FixedManifestEncoder& FixedManifestEncoder::updateImpl() {
+FixedManifestEncoder &FixedManifestEncoder::updateImpl() {
   max_size_ = Packet::default_mtu - packet_.headerSize();
-  manifest_header_ = reinterpret_cast<ManifestHeader*>(
-      const_cast<uint8_t*>(packet_.getPayload().data()));
-  manifest_entries_ = reinterpret_cast<ManifestEntry*>(
-      const_cast<uint8_t*>(packet_.getPayload().data()) +
+  manifest_header_ = reinterpret_cast<ManifestHeader *>(
+      const_cast<uint8_t *>(packet_.getPayload().data()));
+  manifest_entries_ = reinterpret_cast<ManifestEntry *>(
+      const_cast<uint8_t *>(packet_.getPayload().data()) +
       sizeof(ManifestHeader));
   return *this;
 }
 
-FixedManifestEncoder& FixedManifestEncoder::setFinalBlockNumberImpl(
+FixedManifestEncoder &FixedManifestEncoder::setFinalBlockNumberImpl(
     std::uint32_t final_block_number) {
   manifest_header_->final_block_number = utils::hton(final_block_number);
   return *this;
@@ -138,12 +138,12 @@ std::size_t FixedManifestEncoder::getManifestHeaderSizeImpl() {
   return sizeof(ManifestHeader);
 }
 
-FixedManifestDecoder::FixedManifestDecoder(Packet& packet)
+FixedManifestDecoder::FixedManifestDecoder(Packet &packet)
     : packet_(packet),
-      manifest_header_(reinterpret_cast<ManifestHeader*>(
-          const_cast<uint8_t*>(packet_.getPayload().data()))),
-      manifest_entries_(reinterpret_cast<ManifestEntry*>(
-          const_cast<uint8_t*>(packet_.getPayload().data()) +
+      manifest_header_(reinterpret_cast<ManifestHeader *>(
+          const_cast<uint8_t *>(packet_.getPayload().data()))),
+      manifest_entries_(reinterpret_cast<ManifestEntry *>(
+          const_cast<uint8_t *>(packet_.getPayload().data()) +
           sizeof(ManifestHeader))) {}
 
 FixedManifestDecoder::~FixedManifestDecoder() {}
@@ -158,7 +158,7 @@ void FixedManifestDecoder::decodeImpl() {
   }
 }
 
-FixedManifestDecoder& FixedManifestDecoder::clearImpl() { return *this; }
+FixedManifestDecoder &FixedManifestDecoder::clearImpl() { return *this; }
 
 ManifestType FixedManifestDecoder::getManifestTypeImpl() const {
   return static_cast<ManifestType>(manifest_header_->manifest_type);
@@ -180,7 +180,7 @@ typename Fixed::SuffixList FixedManifestDecoder::getSuffixHashListImpl() {
   for (int i = 0; i < manifest_header_->number_of_entries; i++) {
     hash_list.insert(hash_list.end(),
                      std::make_pair(utils::ntoh(manifest_entries_[i].suffix),
-                                    reinterpret_cast<uint8_t*>(
+                                    reinterpret_cast<uint8_t *>(
                                         &manifest_entries_[i].hash[0])));
   }
 
@@ -190,10 +190,10 @@ typename Fixed::SuffixList FixedManifestDecoder::getSuffixHashListImpl() {
 core::Name FixedManifestDecoder::getBaseNameImpl() const {
   if (static_cast<bool>(manifest_header_->flags.ipv6)) {
     return core::Name(AF_INET6,
-                      reinterpret_cast<uint8_t*>(&manifest_header_->prefix));
+                      reinterpret_cast<uint8_t *>(&manifest_header_->prefix));
   } else {
     return core::Name(AF_INET,
-                      reinterpret_cast<uint8_t*>(&manifest_header_->prefix));
+                      reinterpret_cast<uint8_t *>(&manifest_header_->prefix));
   }
 }