fix for constant length sequences

This fixes error which occurs when parsing Eurex messages with mFAST.

Eurex schema uses constant length sequences in several places, e.g. in
QuoteRequest message:
```
  <sequence name="SequenceGroup">
      <length name="NoElements" id="111">
        <constant value="1"/>
      </length>
      <int64 name="Id" id="112">
        <copy/>
      </int64>
    </sequence>
```

Unfortunately mFAST fails to properly handle that schema.

The problem boils down to code decoding sequence instruction:
```
    template <typename T>
    inline void fast_decoder_base::decode_field(const T &ext_ref,
                                                sequence_type_tag) {
      value_storage storage;

      auto length = ext_ref.set_length(storage);
      this->visit(length);
```
Here value_storage is not initialized with initial (constant) value.
Later, in
```
    template <typename T, typename TypeCategory>
    void fast_decoder_base::decode_field(const T &ext_ref,
                                         constant_operator_tag,
                                         TypeCategory) {
```
the value for constant field is not copied (and that's what was changed
in original patch) and sequence length is considered to be 0 leaving all
of sequence payload bytes unparsed.

Author: a-dmitrovsky-db

src/mfast/ext_ref.h

@@ -310,8 +310,12 @@ class ext_mref<sequence_mref, LengthExtRef, ElementExtRef> {
   cref_type get() const { return base_; }
   is_optional_type optional() const { return is_optional_type(); }
   length_type set_length(value_storage &storage) const {
+    auto* length_inst = base_.instruction()->length_instruction();
     field_mref_base length_mref(nullptr, &storage,
-                                base_.instruction()->length_instruction());
+                                length_inst);
+    // a temporary storage is used for sequence length field
+    // and we must initialize it properly to support constant operators
+    length_inst->construct_value(storage, nullptr);
     return length_type(length_mref);
   }
 

tests/CMakeLists.txt

@@ -18,6 +18,7 @@ FASTTYPEGEN_TARGET(simple_types6 simple6.xml)
 FASTTYPEGEN_TARGET(simple_types7 simple7.xml)
 FASTTYPEGEN_TARGET(simple_types8 simple8.xml)
 FASTTYPEGEN_TARGET(simple_types9 simple9.xml)
+FASTTYPEGEN_TARGET(simple_types10 simple10.xml)
 
 
 FASTTYPEGEN_TARGET(test_types1 test1.xml test2.xml)
@@ -51,6 +52,7 @@ add_executable (mfast_test
                 ${FASTTYPEGEN_simple_types7_OUTPUTS}
                 ${FASTTYPEGEN_simple_types8_OUTPUTS}
                 ${FASTTYPEGEN_simple_types9_OUTPUTS}
+                ${FASTTYPEGEN_simple_types10_OUTPUTS}
                 fast_type_gen_test.cpp
                 dictionary_builder_test.cpp
                 json_test.cpp

tests/simple10.xml

@@ -0,0 +1,14 @@
+<?xml version=" 1.0 "?>
+<templates xmlns="http://www.fixprotocol.org/ns/template-definition"
+ templateNs="http://www.fixprotocol.org/ns/templates/sample" ns="http://www.fixprotocol.org/ns/fix">
+<template name="Test" id="1">
+  <sequence name="sequence1">
+    <length id="110">
+      <constant value="1"/>
+    </length>
+    <int64 name="field1" id="111">
+      <copy/>
+    </int64>
+  </sequence>
+</template>
+</templates>

tests/simple_coder_test.cpp

@@ -34,6 +34,7 @@
 #include "simple7.h"
 #include "simple8.h"
 #include "simple9.h"
+#include "simple10.h"
 
 #include "byte_stream.h"
 #include "debug_allocator.h"
@@ -294,3 +295,31 @@ TEST_CASE("test fast coder v2 for a simple template with absent optional fields
   REQUIRE(test_case.decoding("\xA0\x81\x83\x80\x84\x82\x80", msg_ref));
 }
 
+
+TEST_CASE("test fast decoder for a simple template with constant len in a sequence", "[constant_sequence_length_test]")
+{
+  fast_coding_test_case<simple10::templates_description> test_case;
+
+  debug_allocator alloc;
+  simple10::Test msg(&alloc);
+  simple10::Test_mref msg_ref = msg.mref();
+
+  simple10::Test_mref::sequence1_mref seq(msg_ref.set_sequence1());
+  seq.resize(1);
+  seq[0].set_field1().as(10);
+
+  // The value of a constant field is never transferred.
+  // ...
+  // A field will not occupy any bit in the presence map if it is mandatory and has the constant operator.
+  // ...
+  // The default, copy, and increment operators have the following presence map and NULL utilization:
+  //    - Mandatory integer, decimal, string and byte vector fields – one bit. If set, the value appears in the stream.
+  REQUIRE(test_case.encoding(msg_ref,
+                                 // pmap | elem1 pmap | f1 |
+                                 //  80       C0        8A
+                                 "\x80\xC0\x8A"
+                                 ));
+
+  REQUIRE(test_case.decoding("\x80\xC0\x8A", msg_ref, true));
+}
+