src: Improving consistency and correcting code style
As of this commit, all data structures can be directly constructed from
wire format.
This commit excludes full correction of code style in security/ and
tools/ndnsec*, which will be part of a different commit.
Change-Id: I121ac1f81948bc7468990df52cdefeb2988d91a1
Refs: #1403
diff --git a/src/encoding/encoding-buffer.hpp b/src/encoding/encoding-buffer.hpp
index 4251fa9..78b1628 100644
--- a/src/encoding/encoding-buffer.hpp
+++ b/src/encoding/encoding-buffer.hpp
@@ -12,10 +12,6 @@
#include "../common.hpp"
-#include <list>
-#include <exception>
-#include <algorithm>
-
#include "buffer.hpp"
#include "tlv.hpp"
#include "block.hpp"
@@ -48,11 +44,11 @@
* The caller should make sure that that reserveFromBack does not exceed totalReserve,
* otherwise behavior is undefined.
*/
- EncodingImpl (size_t totalReserve = 8800,
- size_t reserveFromBack = 400)
- : m_buffer (new Buffer (totalReserve))
+ EncodingImpl(size_t totalReserve = 8800,
+ size_t reserveFromBack = 400)
+ : m_buffer(new Buffer(totalReserve))
{
- m_begin = m_end = m_buffer->end () - (reserveFromBack < totalReserve ? reserveFromBack : 0);
+ m_begin = m_end = m_buffer->end() - (reserveFromBack < totalReserve ? reserveFromBack : 0);
}
/**
@@ -66,24 +62,24 @@
* after sign operation.
*/
explicit
- EncodingImpl (const Block& block)
+ EncodingImpl(const Block& block)
: m_buffer(const_pointer_cast<Buffer>(block.m_buffer))
, m_begin(m_buffer->begin() + (block.begin() - m_buffer->begin()))
, m_end(m_buffer->begin() + (block.end() - m_buffer->begin()))
{
}
-
- inline size_t
- size () const;
inline size_t
- capacity () const;
+ size() const;
+
+ inline size_t
+ capacity() const;
inline uint8_t*
- buf ();
+ buf();
inline const uint8_t*
- buf () const;
+ buf() const;
/**
* @brief Create Block from the underlying EncodingBuffer
@@ -93,59 +89,59 @@
* length in the Block, otherwise ignored
*/
inline Block
- block (bool verifyLength = true) const;
+ block(bool verifyLength = true) const;
inline void
- resize (size_t sz, bool addInFront);
+ resize(size_t size, bool addInFront);
inline Buffer::iterator
- begin ();
+ begin();
inline Buffer::iterator
- end ();
+ end();
inline Buffer::const_iterator
- begin () const;
+ begin() const;
inline Buffer::const_iterator
- end () const;
+ end() const;
inline size_t
- prependByte (uint8_t val);
+ prependByte(uint8_t value);
inline size_t
- prependByteArray (const uint8_t *arr, size_t len);
+ prependByteArray(const uint8_t* array, size_t length);
inline size_t
- prependNonNegativeInteger (uint64_t varNumber);
+ prependNonNegativeInteger(uint64_t varNumber);
inline size_t
- prependVarNumber (uint64_t varNumber);
+ prependVarNumber(uint64_t varNumber);
inline size_t
- appendByte (uint8_t val);
+ appendByte(uint8_t value);
inline size_t
- appendByteArray (const uint8_t *arr, size_t len);
+ appendByteArray(const uint8_t* array, size_t length);
inline size_t
- appendNonNegativeInteger (uint64_t varNumber);
+ appendNonNegativeInteger(uint64_t varNumber);
inline size_t
- appendVarNumber (uint64_t varNumber);
+ appendVarNumber(uint64_t varNumber);
// inline void
- // removeByteFromFront ();
+ // removeByteFromFront();
// inline void
- // removeByteFromEnd ();
+ // removeByteFromEnd();
// inline void
- // removeVarNumberFromFront (uint64_t varNumber);
+ // removeVarNumberFromFront(uint64_t varNumber);
// inline void
- // removeVarNumberFromBack (uint64_t varNumber);
-
+ // removeVarNumberFromBack(uint64_t varNumber);
+
private:
BufferPtr m_buffer;
@@ -165,34 +161,34 @@
class EncodingImpl<encoding::Estimator>
{
public:
- EncodingImpl (size_t totalReserve = 8800,
- size_t reserveFromBack = 400)
+ EncodingImpl(size_t totalReserve = 8800,
+ size_t reserveFromBack = 400)
{
}
inline size_t
- prependByte (uint8_t val);
+ prependByte(uint8_t value);
inline size_t
- prependByteArray (const uint8_t *arr, size_t len);
+ prependByteArray(const uint8_t* array, size_t length);
inline size_t
- prependNonNegativeInteger (uint64_t varNumber);
+ prependNonNegativeInteger(uint64_t varNumber);
inline size_t
- prependVarNumber (uint64_t varNumber);
+ prependVarNumber(uint64_t varNumber);
inline size_t
- appendByte (uint8_t val);
+ appendByte(uint8_t value);
inline size_t
- appendByteArray (const uint8_t *arr, size_t len);
+ appendByteArray(const uint8_t* array, size_t length);
inline size_t
- appendNonNegativeInteger (uint64_t varNumber);
+ appendNonNegativeInteger(uint64_t varNumber);
inline size_t
- appendVarNumber (uint64_t varNumber);
+ appendVarNumber(uint64_t varNumber);
};
@@ -201,31 +197,31 @@
////////////////////////////////////////////////////////////////////////////////
inline size_t
-EncodingImpl<encoding::Buffer>::size () const
+EncodingImpl<encoding::Buffer>::size() const
{
return m_end - m_begin;
}
inline size_t
-EncodingImpl<encoding::Buffer>::capacity () const
+EncodingImpl<encoding::Buffer>::capacity() const
{
- return m_buffer->size ();
+ return m_buffer->size();
}
inline uint8_t*
-EncodingImpl<encoding::Buffer>::buf ()
+EncodingImpl<encoding::Buffer>::buf()
{
return &(*m_begin);
}
inline const uint8_t*
-EncodingImpl<encoding::Buffer>::buf () const
+EncodingImpl<encoding::Buffer>::buf() const
{
return &(*m_begin);
}
inline Block
-EncodingImpl<encoding::Buffer>::block (bool verifyLength/* = true*/) const
+EncodingImpl<encoding::Buffer>::block(bool verifyLength/* = true*/) const
{
return Block(m_buffer,
m_begin, m_end,
@@ -233,56 +229,56 @@
}
inline void
-EncodingImpl<encoding::Buffer>::resize (size_t sz, bool addInFront)
+EncodingImpl<encoding::Buffer>::resize(size_t size, bool addInFront)
{
if (addInFront)
{
- size_t diff_end = m_buffer->end () - m_end;
- size_t diff_begin = m_buffer->end () - m_begin;
+ size_t diff_end = m_buffer->end() - m_end;
+ size_t diff_begin = m_buffer->end() - m_begin;
- Buffer* buf = new Buffer (sz);
- std::copy_backward (m_buffer->begin (), m_buffer->end (), buf->end ());
+ Buffer* buf = new Buffer(size);
+ std::copy_backward(m_buffer->begin(), m_buffer->end(), buf->end());
- m_buffer.reset (buf);
+ m_buffer.reset(buf);
- m_end = m_buffer->end () - diff_end;
- m_begin = m_buffer->end () - diff_begin;
+ m_end = m_buffer->end() - diff_end;
+ m_begin = m_buffer->end() - diff_begin;
}
else
{
- size_t diff_end = m_end - m_buffer->begin ();
- size_t diff_begin = m_begin - m_buffer->begin ();
+ size_t diff_end = m_end - m_buffer->begin();
+ size_t diff_begin = m_begin - m_buffer->begin();
- Buffer* buf = new Buffer (sz);
- std::copy (m_buffer->begin (), m_buffer->end (), buf->begin ());
+ Buffer* buf = new Buffer(size);
+ std::copy(m_buffer->begin(), m_buffer->end(), buf->begin());
- m_buffer.reset (buf);
+ m_buffer.reset(buf);
- m_end = m_buffer->begin () + diff_end;
- m_begin = m_buffer->begin () + diff_begin;
+ m_end = m_buffer->begin() + diff_end;
+ m_begin = m_buffer->begin() + diff_begin;
}
}
inline Buffer::iterator
-EncodingImpl<encoding::Buffer>::begin ()
+EncodingImpl<encoding::Buffer>::begin()
{
return m_begin;
}
inline Buffer::iterator
-EncodingImpl<encoding::Buffer>::end ()
+EncodingImpl<encoding::Buffer>::end()
{
return m_end;
}
inline Buffer::const_iterator
-EncodingImpl<encoding::Buffer>::begin () const
+EncodingImpl<encoding::Buffer>::begin() const
{
return m_begin;
}
inline Buffer::const_iterator
-EncodingImpl<encoding::Buffer>::end () const
+EncodingImpl<encoding::Buffer>::end() const
{
return m_end;
}
@@ -293,69 +289,69 @@
//////////////////////////////////////////////////////////
inline size_t
-EncodingImpl<encoding::Buffer>::prependByte (uint8_t val)
+EncodingImpl<encoding::Buffer>::prependByte(uint8_t value)
{
- if (m_begin == m_buffer->begin ())
- resize (m_buffer->size () * 2, true);
+ if (m_begin == m_buffer->begin())
+ resize(m_buffer->size() * 2, true);
m_begin--;
- *m_begin = val;
+ *m_begin = value;
return 1;
}
inline size_t
-EncodingImpl<encoding::Estimator>::prependByte (uint8_t val)
+EncodingImpl<encoding::Estimator>::prependByte(uint8_t value)
{
return 1;
}
inline size_t
-EncodingImpl<encoding::Buffer>::prependByteArray (const uint8_t *arr, size_t len)
+EncodingImpl<encoding::Buffer>::prependByteArray(const uint8_t* array, size_t length)
{
- if ((m_buffer->begin () + len) > m_begin)
- resize (m_buffer->size () * 2 + len, true);
+ if ((m_buffer->begin() + length) > m_begin)
+ resize(m_buffer->size() * 2 + length, true);
- m_begin -= len;
- std::copy (arr, arr + len, m_begin);
- return len;
+ m_begin -= length;
+ std::copy(array, array + length, m_begin);
+ return length;
}
inline size_t
-EncodingImpl<encoding::Estimator>::prependByteArray (const uint8_t *arr, size_t len)
+EncodingImpl<encoding::Estimator>::prependByteArray(const uint8_t* array, size_t length)
{
- return len;
+ return length;
}
inline size_t
-EncodingImpl<encoding::Buffer>::prependNonNegativeInteger (uint64_t varNumber)
+EncodingImpl<encoding::Buffer>::prependNonNegativeInteger(uint64_t varNumber)
{
if (varNumber <= std::numeric_limits<uint8_t>::max()) {
- return prependByte (static_cast<uint8_t> (varNumber));
+ return prependByte(static_cast<uint8_t>(varNumber));
}
- else if (varNumber <= std::numeric_limits<uint16_t>::max ()) {
- uint16_t value = htobe16 (static_cast<uint16_t> (varNumber));
- return prependByteArray (reinterpret_cast<const uint8_t*> (&value), 2);
+ else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
+ uint16_t value = htobe16(static_cast<uint16_t>(varNumber));
+ return prependByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
}
- else if (varNumber <= std::numeric_limits<uint32_t>::max ()) {
- uint32_t value = htobe32 (static_cast<uint32_t> (varNumber));
- return prependByteArray (reinterpret_cast<const uint8_t*> (&value), 4);
+ else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
+ uint32_t value = htobe32(static_cast<uint32_t>(varNumber));
+ return prependByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
}
else {
- uint64_t value = htobe64 (varNumber);
- return prependByteArray (reinterpret_cast<const uint8_t*> (&value), 8);
+ uint64_t value = htobe64(varNumber);
+ return prependByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
}
}
inline size_t
-EncodingImpl<encoding::Estimator>::prependNonNegativeInteger (uint64_t varNumber)
+EncodingImpl<encoding::Estimator>::prependNonNegativeInteger(uint64_t varNumber)
{
if (varNumber <= std::numeric_limits<uint8_t>::max()) {
return 1;
}
- else if (varNumber <= std::numeric_limits<uint16_t>::max ()) {
+ else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
return 2;
}
- else if (varNumber <= std::numeric_limits<uint32_t>::max ()) {
+ else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
return 4;
}
else {
@@ -364,42 +360,42 @@
}
inline size_t
-EncodingImpl<encoding::Buffer>::prependVarNumber (uint64_t varNumber)
+EncodingImpl<encoding::Buffer>::prependVarNumber(uint64_t varNumber)
{
if (varNumber < 253) {
- prependByte (static_cast<uint8_t> (varNumber));
+ prependByte(static_cast<uint8_t>(varNumber));
return 1;
}
- else if (varNumber <= std::numeric_limits<uint16_t>::max ()) {
- uint16_t value = htobe16 (static_cast<uint16_t> (varNumber));
- prependByteArray (reinterpret_cast<const uint8_t*> (&value), 2);
- prependByte (253);
+ else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
+ uint16_t value = htobe16(static_cast<uint16_t>(varNumber));
+ prependByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
+ prependByte(253);
return 3;
}
- else if (varNumber <= std::numeric_limits<uint32_t>::max ()) {
- uint32_t value = htobe32 (static_cast<uint32_t> (varNumber));
- prependByteArray (reinterpret_cast<const uint8_t*> (&value), 4);
- prependByte (254);
+ else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
+ uint32_t value = htobe32(static_cast<uint32_t>(varNumber));
+ prependByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
+ prependByte(254);
return 5;
}
else {
- uint64_t value = htobe64 (varNumber);
- prependByteArray (reinterpret_cast<const uint8_t*> (&value), 8);
- prependByte (255);
+ uint64_t value = htobe64(varNumber);
+ prependByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
+ prependByte(255);
return 9;
}
}
inline size_t
-EncodingImpl<encoding::Estimator>::prependVarNumber (uint64_t varNumber)
+EncodingImpl<encoding::Estimator>::prependVarNumber(uint64_t varNumber)
{
if (varNumber < 253) {
return 1;
}
- else if (varNumber <= std::numeric_limits<uint16_t>::max ()) {
+ else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
return 3;
}
- else if (varNumber <= std::numeric_limits<uint32_t>::max ()) {
+ else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
return 5;
}
else {
@@ -412,94 +408,94 @@
/////////////////////////////////////////////////////////
inline size_t
-EncodingImpl<encoding::Buffer>::appendByte (uint8_t val)
+EncodingImpl<encoding::Buffer>::appendByte(uint8_t value)
{
- if (m_end == m_buffer->end ())
- resize (m_buffer->size () * 2, false);
+ if (m_end == m_buffer->end())
+ resize(m_buffer->size() * 2, false);
- *m_end = val;
+ *m_end = value;
m_end++;
return 1;
}
inline size_t
-EncodingImpl<encoding::Estimator>::appendByte (uint8_t val)
+EncodingImpl<encoding::Estimator>::appendByte(uint8_t value)
{
return 1;
}
inline size_t
-EncodingImpl<encoding::Buffer>::appendByteArray (const uint8_t *arr, size_t len)
+EncodingImpl<encoding::Buffer>::appendByteArray(const uint8_t* array, size_t length)
{
- if ((m_end + len) > m_buffer->end ())
- resize (m_buffer->size () * 2 + len, false);
+ if ((m_end + length) > m_buffer->end())
+ resize(m_buffer->size() * 2 + length, false);
- std::copy (arr, arr + len, m_end);
- m_end += len;
- return len;
+ std::copy(array, array + length, m_end);
+ m_end += length;
+ return length;
}
inline size_t
-EncodingImpl<encoding::Estimator>::appendByteArray (const uint8_t *arr, size_t len)
+EncodingImpl<encoding::Estimator>::appendByteArray(const uint8_t* array, size_t length)
{
- return prependByteArray(arr, len);
+ return prependByteArray(array, length);
}
inline size_t
-EncodingImpl<encoding::Buffer>::appendNonNegativeInteger (uint64_t varNumber)
+EncodingImpl<encoding::Buffer>::appendNonNegativeInteger(uint64_t varNumber)
{
- if (varNumber <= std::numeric_limits<uint8_t>::max ()) {
- return appendByte (static_cast<uint8_t> (varNumber));
+ if (varNumber <= std::numeric_limits<uint8_t>::max()) {
+ return appendByte(static_cast<uint8_t>(varNumber));
}
- else if (varNumber <= std::numeric_limits<uint16_t>::max ()) {
- uint16_t value = htobe16 (static_cast<uint16_t> (varNumber));
- return appendByteArray (reinterpret_cast<const uint8_t*> (&value), 2);
+ else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
+ uint16_t value = htobe16(static_cast<uint16_t>(varNumber));
+ return appendByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
}
- else if (varNumber <= std::numeric_limits<uint32_t>::max ()) {
- uint32_t value = htobe32 (static_cast<uint32_t> (varNumber));
- return appendByteArray (reinterpret_cast<const uint8_t*> (&value), 4);
+ else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
+ uint32_t value = htobe32(static_cast<uint32_t>(varNumber));
+ return appendByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
}
else {
- uint64_t value = htobe64 (varNumber);
- return appendByteArray (reinterpret_cast<const uint8_t*> (&value), 8);
+ uint64_t value = htobe64(varNumber);
+ return appendByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
}
}
inline size_t
-EncodingImpl<encoding::Estimator>::appendNonNegativeInteger (uint64_t varNumber)
+EncodingImpl<encoding::Estimator>::appendNonNegativeInteger(uint64_t varNumber)
{
return prependNonNegativeInteger(varNumber);
}
inline size_t
-EncodingImpl<encoding::Buffer>::appendVarNumber (uint64_t varNumber)
+EncodingImpl<encoding::Buffer>::appendVarNumber(uint64_t varNumber)
{
if (varNumber < 253) {
- appendByte (static_cast<uint8_t> (varNumber));
+ appendByte(static_cast<uint8_t>(varNumber));
return 1;
}
- else if (varNumber <= std::numeric_limits<uint16_t>::max ()) {
- appendByte (253);
- uint16_t value = htobe16 (static_cast<uint16_t> (varNumber));
- appendByteArray (reinterpret_cast<const uint8_t*> (&value), 2);
+ else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
+ appendByte(253);
+ uint16_t value = htobe16(static_cast<uint16_t>(varNumber));
+ appendByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
return 3;
}
- else if (varNumber <= std::numeric_limits<uint32_t>::max ()) {
- appendByte (254);
- uint32_t value = htobe32 (static_cast<uint32_t> (varNumber));
- appendByteArray (reinterpret_cast<const uint8_t*> (&value), 4);
+ else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
+ appendByte(254);
+ uint32_t value = htobe32(static_cast<uint32_t>(varNumber));
+ appendByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
return 5;
}
else {
- appendByte (255);
- uint64_t value = htobe64 (varNumber);
- appendByteArray (reinterpret_cast<const uint8_t*> (&value), 8);
+ appendByte(255);
+ uint64_t value = htobe64(varNumber);
+ appendByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
return 9;
}
}
inline size_t
-EncodingImpl<encoding::Estimator>::appendVarNumber (uint64_t varNumber)
+EncodingImpl<encoding::Estimator>::appendVarNumber(uint64_t varNumber)
{
return prependVarNumber(varNumber);
}
@@ -508,56 +504,57 @@
template<bool P>
inline size_t
-prependNonNegativeIntegerBlock(EncodingImpl<P>& blk, uint32_t type, uint64_t number)
+prependNonNegativeIntegerBlock(EncodingImpl<P>& encoder, uint32_t type, uint64_t number)
{
- size_t var_len = blk.prependNonNegativeInteger(number);
- size_t total_len = var_len;
- total_len += blk.prependVarNumber(var_len);
- total_len += blk.prependVarNumber(type);
+ size_t valueLength = encoder.prependNonNegativeInteger(number);
+ size_t totalLength = valueLength;
+ totalLength += encoder.prependVarNumber(valueLength);
+ totalLength += encoder.prependVarNumber(type);
- return total_len;
+ return totalLength;
}
template<bool P>
inline size_t
-prependByteArrayBlock(EncodingImpl<P>& blk, uint32_t type, const uint8_t* array, size_t arraySize)
+prependByteArrayBlock(EncodingImpl<P>& encoder, uint32_t type,
+ const uint8_t* array, size_t arraySize)
{
- size_t var_len = blk.prependByteArray(array, arraySize);
- size_t total_len = var_len;
- total_len += blk.prependVarNumber(var_len);
- total_len += blk.prependVarNumber(type);
+ size_t valueLength = encoder.prependByteArray(array, arraySize);
+ size_t totalLength = valueLength;
+ totalLength += encoder.prependVarNumber(valueLength);
+ totalLength += encoder.prependVarNumber(type);
- return total_len;
+ return totalLength;
}
template<bool P>
inline size_t
-prependBooleanBlock(EncodingImpl<P>& blk, uint32_t type)
+prependBooleanBlock(EncodingImpl<P>& encoder, uint32_t type)
{
- size_t total_len = blk.prependVarNumber(0);
- total_len += blk.prependVarNumber(type);
+ size_t totalLength = encoder.prependVarNumber(0);
+ totalLength += encoder.prependVarNumber(type);
- return total_len;
+ return totalLength;
}
template<bool P, class U>
inline size_t
-prependNestedBlock(EncodingImpl<P>& blk, uint32_t type, const U& nestedBlock)
+prependNestedBlock(EncodingImpl<P>& encoder, uint32_t type, const U& nestedBlock)
{
- size_t var_len = nestedBlock.wireEncode(blk);
- size_t total_len = var_len;
- total_len += blk.prependVarNumber(var_len);
- total_len += blk.prependVarNumber(type);
+ size_t valueLength = nestedBlock.wireEncode(encoder);
+ size_t totalLength = valueLength;
+ totalLength += encoder.prependVarNumber(valueLength);
+ totalLength += encoder.prependVarNumber(type);
- return total_len;
+ return totalLength;
}
template<bool P>
inline size_t
-prependBlock(EncodingImpl<P>& blk, const Block& block)
+prependBlock(EncodingImpl<P>& encoder, const Block& block)
{
- return blk.prependByteArray(block.wire(), block.size());
+ return encoder.prependByteArray(block.wire(), block.size());
}