Add flatc '--cpp_std' switch (#5656)

* Add flatc '--cpp_std' switch and sandbox for C++17 code generator

- Added 'flac --cpp_std legacy' for compatibility with old compilers (VS2010);
- Added experimental switch 'flac --cpp_std c++17' for future development;
- Added C++17 sandbox test_cpp17.cpp;
- C++ code generator generates enums with explicit underlying type to avoid problems with the forward and backward schema compatibility;
- Adjusted CMakeLists.txt, CI and generate code scripts to support of introduced '--cpp_std';

* Fix --cpp_std values: c++0x, c++11, c++17

* Add 'cpp::CppStandard' enum

* Add testing engine into test_cpp17

* Rebase to upstream/master

* Set default '--cpp-std C++0x'

* Fix code generation (--cpp_std C++11) in CMakeLists.txt

- Fix dependency declaration of grpctest target

* Revert --cpp-std for the tests from explicit C++11 to flatc default value (C++0x)

tests/namespace_test/NamespaceC/TableInC.go

@@ -8,6 +8,33 @@ import (
 	NamespaceA "NamespaceA"
 )
 
+type TableInCT struct {
+	ReferToA1 *NamespaceA.TableInFirstNST
+	ReferToA2 *NamespaceA.SecondTableInAT
+}
+
+func TableInCPack(builder *flatbuffers.Builder, t *TableInCT) flatbuffers.UOffsetT {
+	if t == nil { return 0 }
+	referToA1Offset := NamespaceA.TableInFirstNSPack(builder, t.ReferToA1)
+	referToA2Offset := NamespaceA.SecondTableInAPack(builder, t.ReferToA2)
+	TableInCStart(builder)
+	TableInCAddReferToA1(builder, referToA1Offset)
+	TableInCAddReferToA2(builder, referToA2Offset)
+	return TableInCEnd(builder)
+}
+
+func (rcv *TableInC) UnPackTo(t *TableInCT) {
+	t.ReferToA1 = rcv.ReferToA1(nil).UnPack()
+	t.ReferToA2 = rcv.ReferToA2(nil).UnPack()
+}
+
+func (rcv *TableInC) UnPack() *TableInCT {
+	if rcv == nil { return nil }
+	t := &TableInCT{}
+	rcv.UnPackTo(t)
+	return t
+}
+
 type TableInC struct {
 	_tab flatbuffers.Table
 }

tests/namespace_test/NamespaceC/TableInC.py

@@ -25,7 +25,6 @@ class TableInC(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from NamespaceA.TableInFirstNS import TableInFirstNS
             obj = TableInFirstNS()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -36,7 +35,6 @@ class TableInC(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from NamespaceA.SecondTableInA import SecondTableInA
             obj = SecondTableInA()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -46,3 +44,50 @@ def TableInCStart(builder): builder.StartObject(2)
 def TableInCAddReferToA1(builder, referToA1): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToA1), 0)
 def TableInCAddReferToA2(builder, referToA2): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(referToA2), 0)
 def TableInCEnd(builder): return builder.EndObject()
+
+try:
+    from typing import Optional
+except:
+    pass
+
+class TableInCT(object):
+
+    # TableInCT
+    def __init__(self):
+        self.referToA1 = None  # type: Optional[TableInFirstNST]
+        self.referToA2 = None  # type: Optional[SecondTableInAT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        tableInC = TableInC()
+        tableInC.Init(buf, pos)
+        return cls.InitFromObj(tableInC)
+
+    @classmethod
+    def InitFromObj(cls, tableInC):
+        x = TableInCT()
+        x._UnPack(tableInC)
+        return x
+
+    # TableInCT
+    def _UnPack(self, tableInC):
+        if tableInC is None:
+            return
+        if tableInC.ReferToA1() is not None:
+            self.referToA1 = TableInFirstNST.InitFromObj(tableInC.ReferToA1())
+        if tableInC.ReferToA2() is not None:
+            self.referToA2 = SecondTableInAT.InitFromObj(tableInC.ReferToA2())
+
+    # TableInCT
+    def Pack(self, builder):
+        if self.referToA1 is not None:
+            referToA1 = self.referToA1.Pack(builder)
+        if self.referToA2 is not None:
+            referToA2 = self.referToA2.Pack(builder)
+        TableInCStart(builder)
+        if self.referToA1 is not None:
+            TableInCAddReferToA1(builder, referToA1)
+        if self.referToA2 is not None:
+            TableInCAddReferToA2(builder, referToA2)
+        tableInC = TableInCEnd(builder)
+        return tableInC