[c++] Improve IR and OTF code by reducing warnings and avoiding unnecessary copies.

Author: mjpt777

sbe-tool/src/main/cpp/otf/Encoding.h

@@ -156,9 +156,9 @@ inline std::size_t lengthOfType(PrimitiveType type)
 class PrimitiveValue
 {
 public:
-    PrimitiveValue(PrimitiveType type, std::size_t valueLength, const char *value)
+    PrimitiveValue(PrimitiveType type, std::size_t valueLength, const char *value) :
+        m_type(type)
     {
-        m_type = type;
         if (0 == valueLength)
         {
             m_type = PrimitiveType::NONE;

sbe-tool/src/main/cpp/otf/IrDecoder.h

@@ -150,7 +150,7 @@ class IrDecoder
         FILE *fptr = ::fopen(filename, "rb");
         std::uint64_t remaining = length;
 
-        if (NULL == fptr)
+        if (nullptr == fptr)
         {
             return -1;
         }

sbe-tool/src/main/cpp/otf/OtfHeaderDecoder.h

@@ -30,42 +30,72 @@ namespace otf {
 class OtfHeaderDecoder
 {
 public:
-    OtfHeaderDecoder(std::shared_ptr<std::vector<Token>> tokens) :
-        m_tokens(tokens)
+    explicit OtfHeaderDecoder(const std::shared_ptr<std::vector<Token>>& tokens)
     {
         m_encodedLength = tokens->at(0).encodedLength();
 
+        Token* blockLengthToken = nullptr;
+        Token* templateIdToken = nullptr;
+        Token* schemaIdToken = nullptr;
+        Token* versionToken = nullptr;
+
         std::for_each(tokens->begin(), tokens->end(), [&](Token& token)
         {
             const std::string& name = token.name();
-            const Encoding& encoding = token.encoding();
 
             if (name == "blockLength")
             {
-                m_blockLengthOffset = token.offset();
-                m_blockLengthType = encoding.primitiveType();
-                m_blockLengthByteOrder = encoding.byteOrder();
+                blockLengthToken = &token;
             }
             else if (name == "templateId")
             {
-                m_templateIdOffset = token.offset();
-                m_templateIdType = encoding.primitiveType();
-                m_templateIdByteOrder = encoding.byteOrder();
+                templateIdToken = &token;
             }
             else if (name == "schemaId")
             {
-                m_schemaIdOffset = token.offset();
-                m_schemaIdType = encoding.primitiveType();
-                m_schemaIdByteOrder = encoding.byteOrder();
+                schemaIdToken = &token;
             }
             else if (name == "version")
             {
-                m_schemaVersionOffset = token.offset();
-                m_schemaVersionType = encoding.primitiveType();
-                m_schemaVersionByteOrder = encoding.byteOrder();
+                versionToken = &token;
             }
-
         });
+
+        if (nullptr == blockLengthToken)
+        {
+            throw std::runtime_error("blockLength token not found");
+        }
+
+        m_blockLengthOffset = blockLengthToken->offset();
+        m_blockLengthType = blockLengthToken->encoding().primitiveType();
+        m_blockLengthByteOrder = blockLengthToken->encoding().byteOrder();
+
+        if (nullptr == templateIdToken)
+        {
+            throw std::runtime_error("templateId token not found");
+        }
+
+        m_templateIdOffset = templateIdToken->offset();
+        m_templateIdType = templateIdToken->encoding().primitiveType();
+        m_templateIdByteOrder = templateIdToken->encoding().byteOrder();
+
+        if (nullptr == schemaIdToken)
+        {
+            throw std::runtime_error("schemaId token not found");
+        }
+
+        m_schemaIdOffset = schemaIdToken->offset();
+        m_schemaIdType = schemaIdToken->encoding().primitiveType();
+        m_schemaIdByteOrder = schemaIdToken->encoding().byteOrder();
+
+        if (nullptr == versionToken)
+        {
+            throw std::runtime_error("version token not found");
+        }
+
+        m_schemaVersionOffset = versionToken->offset();
+        m_schemaVersionType = versionToken->encoding().primitiveType();
+        m_schemaVersionByteOrder = versionToken->encoding().byteOrder();
     }
 
     inline std::uint32_t encodedLength() const
@@ -74,7 +104,7 @@ class OtfHeaderDecoder
     }
 
     /*
-     * All elements must be unsigned integers according to RC3
+     * All elements must be unsigned integers according to Specification
      */
 
     std::uint64_t getTemplateId(const char *headerBuffer)
@@ -98,7 +128,6 @@ class OtfHeaderDecoder
     }
 
 private:
-    std::shared_ptr<std::vector<Token>> m_tokens;
     std::int32_t m_encodedLength;
     std::int32_t m_blockLengthOffset;
     std::int32_t m_templateIdOffset;

sbe-tool/src/main/cpp/otf/OtfMessageDecoder.h

@@ -173,15 +173,19 @@ static void decodeComposite(
             case Signal::BEGIN_COMPOSITE:
                 decodeComposite(fieldToken, buffer, bufferIndex + offset, length, tokens, i, nextFieldIndex - 1, actingVersion, listener);
                 break;
+
             case Signal::BEGIN_ENUM:
                 listener.onEnum(fieldToken, buffer + bufferIndex + offset, *tokens.get(), i, nextFieldIndex - 1, actingVersion);
                 break;
+
             case Signal::BEGIN_SET:
                 listener.onBitSet(fieldToken, buffer + bufferIndex + offset, *tokens.get(), i, nextFieldIndex - 1, actingVersion);
                 break;
+
             case Signal::ENCODING:
                 listener.onEncoding(token, buffer + bufferIndex + offset, token, actingVersion);
                 break;
+
             default:
                 throw std::runtime_error("incorrect signal type in decodeComposite");
         }
@@ -223,15 +227,19 @@ static size_t decodeFields(
                 decodeComposite<TokenListener>(
                     fieldToken, buffer, offset, length, tokens, tokenIndex, nextFieldIndex - 2, actingVersion, listener);
                 break;
+
             case Signal::BEGIN_ENUM:
                 listener.onEnum(fieldToken, buffer + offset, *tokens.get(), tokenIndex, nextFieldIndex - 2, actingVersion);
                 break;
+
             case Signal::BEGIN_SET:
                 listener.onBitSet(fieldToken, buffer + offset, *tokens.get(), tokenIndex, nextFieldIndex - 2, actingVersion);
                 break;
+
             case Signal::ENCODING:
                 listener.onEncoding(fieldToken, buffer + offset, typeToken, actingVersion);
                 break;
+
             default:
                 throw std::runtime_error("incorrect signal type in decodeFields");
         }
@@ -247,7 +255,7 @@ std::size_t decodeData(
     const char *buffer,
     std::size_t bufferIndex,
     const std::size_t length,
-    std::shared_ptr<std::vector<Token>> tokens,
+    const std::shared_ptr<std::vector<Token>>& tokens,
     std::size_t tokenIndex,
     const std::size_t numTokens,
     std::uint64_t actingVersion,