[C++] Port access order checking tests and implementation to C++.

In this commit, I also addressed these issues (1-3):

--- 1. Tidy up string format usage. ---

For convenience and readability, I had inlined some concatenation into
`string.format(...)` templates; however, this makes it unclear whether
the variable/method-output being concatenated uses template parameters.
Therefore, I have adjusted to inject these strings via template
parameters. FWIW I'd prefer to use `StringBuilder` everywhere, as I
think it is hard to read large string format templates.

--- 2. Explcitly delete copy constructors of flyweights. ---

I found it easy to accidentally write sub-optimal code where I relied on
copy constructors. For example:

```
MyMessage::MyGroup myGroup = myMessage.myGroup(10);
```

rather than:

```
MyMessage::MyGroup &myGroup = myMessage.myGroup(10);
```

Copying semantics are a bit strange when it comes to flyweights and
trees of flyweights. Therefore, I think it is best to avoid entirely.

This change is behind a feature flag. To re-enable implicit copy
constructors specify the system property
`-Dsbe.generate.implicit.copy.constructors=true`.

--- 3. Adjust state machines to allow repeated decoding of variable-length ---
data lengths, as accesses do not advance `limit`.

Author: ZachBray

.gitignore

@@ -33,6 +33,9 @@ out
 # cmake
 cmake-build-debug
 codecs
+.cmake
+CMakeFiles
+thirdparty
 
 # cpp build linux
 cppbuild/CMakeCache.txt

csharp/sbe-tests/FieldAccessOrderCheckTests.cs

@@ -131,6 +131,19 @@ public void DisallowsSkippingDecodingOfVariableLengthField3()
             Assert.IsTrue(exception.Message.Contains("Cannot access field \"c\" in state: V0_BLOCK"));
         }
 
+        [TestMethod]
+        public void AllowsRepeatedDecodingOfVariableLengthDataLength()
+        {
+            var decoder = DecodeUntilVarLengthFields();
+            Assert.AreEqual(3, decoder.BLength());
+            Assert.AreEqual(3, decoder.BLength());
+            Assert.AreEqual(3, decoder.BLength());
+            Assert.AreEqual("abc", decoder.GetB());
+            Assert.AreEqual(3, decoder.CLength());
+            Assert.AreEqual(3, decoder.CLength());
+            Assert.AreEqual(3, decoder.CLength());
+        }
+
         [TestMethod]
         public void DisallowsReDecodingEarlierVariableLengthField()
         {
@@ -2806,7 +2819,8 @@ public void DisallowsMissedEncodingOfVarLengthFieldInNestedGroupToNextOuterEleme
             Assert.IsTrue(exception.Message.Contains("Cannot access next element in repeating group \"b\" in state: " +
                                                      expectedState));
             Assert.IsTrue(
-                exception.Message.Contains("Expected one of these transitions: [\"b.d.e(?)\", \"b.d.f(?)\"]."));
+                exception.Message.Contains(
+                    "Expected one of these transitions: [\"b.d.e(?)\", \"b.d.fLength()\", \"b.d.f(?)\"]."));
         }
 
         [TestMethod]
@@ -2841,7 +2855,8 @@ public void DisallowsMissedDecodingOfVarLengthFieldInNestedGroupToNextInnerEleme
                 exception.Message.Contains(
                     "Cannot access next element in repeating group \"b.d\" in state: V0_B_1_D_N_BLOCK."));
             Assert.IsTrue(
-                exception.Message.Contains("Expected one of these transitions: [\"b.d.e(?)\", \"b.d.f(?)\"]."));
+                exception.Message.Contains(
+                    "Expected one of these transitions: [\"b.d.e(?)\", \"b.d.fLength()\", \"b.d.f(?)\"]."));
         }
 
         [TestMethod]
@@ -2878,7 +2893,8 @@ public void DisallowsMissedDecodingOfVarLengthFieldInNestedGroupToNextInnerEleme
                 exception.Message.Contains(
                     "Cannot access next element in repeating group \"b.d\" in state: V0_B_N_D_N_BLOCK."));
             Assert.IsTrue(
-                exception.Message.Contains("Expected one of these transitions: [\"b.d.e(?)\", \"b.d.f(?)\"]."));
+                exception.Message.Contains(
+                    "Expected one of these transitions: [\"b.d.e(?)\", \"b.d.fLength()\", \"b.d.f(?)\"]."));
         }
 
         [TestMethod]
@@ -2915,7 +2931,8 @@ public void DisallowsMissedDecodingOfVarLengthFieldInNestedGroupToNextOuterEleme
                 exception.Message.Contains(
                     "Cannot access next element in repeating group \"b\" in state: V0_B_N_D_N_BLOCK."));
             Assert.IsTrue(
-                exception.Message.Contains("Expected one of these transitions: [\"b.d.e(?)\", \"b.d.f(?)\"]."));
+                exception.Message.Contains(
+                    "Expected one of these transitions: [\"b.d.e(?)\", \"b.d.fLength()\", \"b.d.f(?)\"]."));
         }
 
         [TestMethod]
@@ -2949,7 +2966,8 @@ public void DisallowsMissedDecodingOfVarLengthFieldInNestedGroupToNextOuterEleme
                 exception.Message.Contains(
                     "Cannot access next element in repeating group \"b\" in state: V0_B_N_D_1_BLOCK."));
             Assert.IsTrue(
-                exception.Message.Contains("Expected one of these transitions: [\"b.d.e(?)\", \"b.d.f(?)\"]."));
+                exception.Message.Contains(
+                    "Expected one of these transitions: [\"b.d.e(?)\", \"b.d.fLength()\", \"b.d.f(?)\"]."));
         }
 
         [TestMethod]
@@ -2962,7 +2980,7 @@ public void DisallowsIncompleteMessagesDueToMissingVarLengthField1()
             var exception = Assert.ThrowsException<InvalidOperationException>(() => encoder.CheckEncodingIsComplete());
             Assert.IsTrue(
                 exception.Message.Contains(
-                    "Not fully encoded, current state: V0_B_DONE, allowed transitions: \"c(?)\""));
+                    "Not fully encoded, current state: V0_B_DONE, allowed transitions: \"cLength()\", \"c(?)\""));
         }
 
         [TestMethod]
@@ -2973,7 +2991,7 @@ public void DisallowsIncompleteMessagesDueToMissingVarLengthField2()
             var exception = Assert.ThrowsException<InvalidOperationException>(() => encoder.CheckEncodingIsComplete());
             Assert.IsTrue(
                 exception.Message.Contains(
-                    "Not fully encoded, current state: V0_BLOCK, allowed transitions: \"a(?)\""));
+                    "Not fully encoded, current state: V0_BLOCK, allowed transitions: \"aLength()\", \"a(?)\""));
         }
 
         [TestMethod]

sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/common/AccessOrderModel.java

@@ -116,6 +116,15 @@ public void forEachWrappedStateByVersion(final IntObjConsumer<State> consumer)
         }
     }
 
+    /**
+     * Returns the number of schema versions.
+     * @return the number of schema versions.
+     */
+    public int versionCount()
+    {
+        return versionWrappedStates.size();
+    }
+
     /**
      * Iterates over the states in which a codec is fully encoded.
      * @param consumer the consumer of the states.
@@ -136,6 +145,15 @@ public void forEachStateOrderedByStateNumber(final Consumer<State> consumer)
             .forEach(consumer);
     }
 
+    /**
+     * Returns the number of states in the state machine.
+     * @return the number of states in the state machine.
+     */
+    public int stateCount()
+    {
+        return transitionsByState.size();
+    }
+
     /**
      * Returns a hash-consing factory for codec interactions.
      * These interactions are the transitions in the state machine.
@@ -541,6 +559,12 @@ public void onVarData(final Token token)
         {
             if (filter.test(token))
             {
+                final CodecInteraction lengthAccessInteraction = interactionFactory.accessVarDataLength(token);
+                currentStates.forEach(state ->
+                {
+                    allocateTransitions(lengthAccessInteraction, Collections.singleton(state), state);
+                });
+
                 final CodecInteraction codecInteraction = interactionFactory.accessField(token);
                 final State accessedState = allocateState(statePrefix + token.name().toUpperCase() + "_DONE");
                 allocateTransitions(codecInteraction, currentStates, accessedState);
@@ -635,6 +659,15 @@ public State endState()
             return to;
         }
 
+        /**
+         * Returns {@code true} if the transitions in this group do not change state.
+         * @return {@code true} if the transitions in this group do not change state.
+         */
+        public boolean alwaysEndsInStartState()
+        {
+            return from.size() == 1 && from.contains(to);
+        }
+
         /**
          * Returns some example code for the codec interaction that the transitions in this group share.
          * Useful for producing error messages.
@@ -902,6 +935,42 @@ String exampleConditions()
             }
         }
 
+        /**
+         * When the length of a variable length field is accessed without adjusting the position.
+         */
+        private static final class AccessVarDataLength extends CodecInteraction
+        {
+            private final String groupPath;
+            private final Token token;
+
+            private AccessVarDataLength(final String groupPath, final Token token)
+            {
+                assert groupPath != null;
+                assert token.signal() == Signal.BEGIN_VAR_DATA;
+                this.groupPath = groupPath;
+                this.token = token;
+            }
+
+            @Override
+            public String groupQualifiedName()
+            {
+                return groupPath + token.name();
+            }
+
+            @Override
+            String exampleCode()
+            {
+                return groupPath + token.name() + "Length()";
+            }
+
+            @Override
+            String exampleConditions()
+            {
+                return "";
+            }
+        }
+
+
         /**
          * Factory for creating {@link CodecInteraction} instances. This factory
          * is used to hash-cons the instances, so that they can be compared by
@@ -915,6 +984,7 @@ public static final class HashConsingFactory
             private final Map<Token, CodecInteraction> determineGroupHasElementsInteractions = new HashMap<>();
             private final Map<Token, CodecInteraction> moveToNextElementInteractions = new HashMap<>();
             private final Map<Token, CodecInteraction> moveToLastElementInteractions = new HashMap<>();
+            private final Map<Token, CodecInteraction> accessVarDataLengthInteractions = new HashMap<>();
             private final Map<Token, String> groupPathsByField;
             private final Set<Token> topLevelBlockFields;
 
@@ -1029,6 +1099,24 @@ public CodecInteraction moveToLastElement(final Token token)
                 return moveToLastElementInteractions.computeIfAbsent(token,
                     t -> new MoveToLastElement(groupPathsByField.get(t), t));
             }
+
+            /**
+             * Find or create a {@link CodecInteraction} to represent accessing the length
+             * of a variable-length data field without advancing the codec position.
+             *
+             * <p>For decoders and codecs, this will be when the length is accessed, e.g.,
+             * {@code decoder.myVarDataLength()}.
+             *
+             * <p>The supplied token must carry a {@link Signal#BEGIN_VAR_DATA} signal.
+             *
+             * @param token the token identifying the field
+             * @return the {@link CodecInteraction} instance
+             */
+            public CodecInteraction accessVarDataLength(final Token token)
+            {
+                return accessVarDataLengthInteractions.computeIfAbsent(token,
+                    t -> new AccessVarDataLength(groupPathsByField.get(t), t));
+            }
         }
     }
 }