Diff to HTML by rtfpessoa

Files changed (22) hide show
  1. Debug/Thunder/Source/plugins/generated/ProxyStubs_Controller.cpp +6 -0
  2. Debug/ThunderInterfaces/example_interfaces/example_generated/ProxyStubs_SimpleAsync.cpp +89 -22
  3. Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_AudioStream.cpp +6 -0
  4. Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_BluetoothRemoteControl.cpp +15 -0
  5. Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_DeviceIdentification.cpp +6 -0
  6. Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_LocationSync.cpp +15 -0
  7. Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_TimeSync.cpp +3 -0
  8. Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_ValuePoint.cpp +3 -0
  9. Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_WifiControl.cpp +30 -0
  10. Debug/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_Benchmark.cpp +9 -0
  11. Debug/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_BenchmarkPayload.cpp +1 -0
  12. Release/Thunder/Source/plugins/generated/ProxyStubs_Controller.cpp +6 -0
  13. Release/ThunderInterfaces/example_interfaces/example_generated/ProxyStubs_SimpleAsync.cpp +89 -22
  14. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_AudioStream.cpp +6 -0
  15. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_BluetoothRemoteControl.cpp +15 -0
  16. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_DeviceIdentification.cpp +6 -0
  17. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_LocationSync.cpp +15 -0
  18. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_TimeSync.cpp +3 -0
  19. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_ValuePoint.cpp +3 -0
  20. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_WifiControl.cpp +30 -0
  21. Release/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_Benchmark.cpp +9 -0
  22. Release/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_BenchmarkPayload.cpp +1 -0
Debug/Thunder/Source/plugins/generated/ProxyStubs_Controller.cpp CHANGED
@@ -1799,18 +1799,24 @@
1799
1799
  _buildInfo.SystemType = reader.Number<Controller::IMetadata::Data::BuildInfo::systemtype>();
1800
1800
  _buildInfo.BuildType = reader.Number<Controller::IMetadata::Data::BuildInfo::buildtype>();
1801
1801
  if (reader.Boolean() == true) {
1802
1802
  _buildInfo.Extensions = reader.Number<Controller::IMetadata::Data::BuildInfo::extensiontype>();
1803
1803
  }
1804
+ else {
1805
+ _buildInfo.Extensions = Core::OptionalType<Controller::IMetadata::Data::BuildInfo::extensiontype>();
1806
+ }
1804
1807
  _buildInfo.Messaging = reader.Boolean();
1805
1808
  _buildInfo.ExceptionCatching = reader.Boolean();
1806
1809
  _buildInfo.DeadlockDetection = reader.Boolean();
1807
1810
  _buildInfo.WCharSupport = reader.Boolean();
1808
1811
  _buildInfo.InstanceIDBits = reader.Number<uint8_t>();
1809
1812
  if (reader.Boolean() == true) {
1810
1813
  _buildInfo.TraceLevel = reader.Number<uint8_t>();
1811
1814
  }
1815
+ else {
1816
+ _buildInfo.TraceLevel = Core::OptionalType<uint8_t>();
1817
+ }
1812
1818
  _buildInfo.ThreadPoolCount = reader.Number<uint8_t>();
1813
1819
  _buildInfo.COMRPCTimeOut = reader.Number<uint32_t>();
1814
1820
  } else {
1815
1821
  ASSERT((hresult & COM_ERROR) != 0);
1816
1822
  }
Debug/ThunderInterfaces/example_interfaces/example_generated/ProxyStubs_SimpleAsync.cpp CHANGED
@@ -281,14 +281,14 @@
281
281
  Core::OptionalType<std::vector<uint8_t>> _address{};
282
282
  if (reader.Boolean() == true) {
283
283
  std::vector<uint8_t> _addressObject__{};
284
284
  uint8_t _addressObject__Size = reader.Number<uint8_t>();
285
285
  ASSERT((_addressObject__Size >= 6) && (_addressObject__Size <= 6));
286
- _address.Value().reserve(_addressObject__Size);
286
+ _addressObject__.reserve(_addressObject__Size);
287
287
  for (uint8_t i = 0; i < _addressObject__Size; i++) {
288
288
  uint8_t _addressObject__Item = reader.Number<uint8_t>();
289
- _address.Value().push_back(std::move(_addressObject__Item));
289
+ _addressObject__.push_back(std::move(_addressObject__Item));
290
290
  }
291
291
  _address = std::move(_addressObject__);
292
292
  }
293
293
  Core::OptionalType<uint16_t> _timeout{};
294
294
  if (reader.Boolean() == true) {
@@ -972,14 +972,14 @@
972
972
  Core::OptionalType<std::vector<uint8_t>> _address{};
973
973
  if (reader.Boolean() == true) {
974
974
  std::vector<uint8_t> _addressObject__{};
975
975
  uint8_t _addressObject__Size = reader.Number<uint8_t>();
976
976
  ASSERT((_addressObject__Size >= 6) && (_addressObject__Size <= 6));
977
- _address.Value().reserve(_addressObject__Size);
977
+ _addressObject__.reserve(_addressObject__Size);
978
978
  for (uint8_t i = 0; i < _addressObject__Size; i++) {
979
979
  uint8_t _addressObject__Item = reader.Number<uint8_t>();
980
- _address.Value().push_back(std::move(_addressObject__Item));
980
+ _addressObject__.push_back(std::move(_addressObject__Item));
981
981
  }
982
982
  _address = std::move(_addressObject__);
983
983
  }
984
984
  const Example::ISimpleAsync::state _state = reader.Number<Example::ISimpleAsync::state>();
985
985
 
@@ -1676,10 +1676,11 @@
1676
1676
  if (hresult == Core::ERROR_NONE) {
1677
1677
  RPC::Data::Frame::Reader reader(message->Response().Reader());
1678
1678
  hresult = reader.Number<Core::hresult>();
1679
1679
  uint8_t _stringTablesSize{};
1680
1680
  _stringTablesSize = reader.Number<uint8_t>();
1681
+ _stringTables.clear();
1681
1682
  _stringTables.reserve(_stringTablesSize);
1682
1683
  for (uint8_t i = 0; i < _stringTablesSize; i++) {
1683
1684
  string _stringTablesItem{};
1684
1685
  _stringTablesItem = reader.Text();
1685
1686
  _stringTables.push_back(std::move(_stringTablesItem));
@@ -1702,18 +1703,20 @@
1702
1703
  if (hresult == Core::ERROR_NONE) {
1703
1704
  RPC::Data::Frame::Reader reader(message->Response().Reader());
1704
1705
  hresult = reader.Number<Core::hresult>();
1705
1706
  uint8_t _stringTablesSize{};
1706
1707
  _stringTablesSize = reader.Number<uint8_t>();
1708
+ _stringTables.clear();
1707
1709
  _stringTables.reserve(_stringTablesSize);
1708
1710
  for (uint8_t i = 0; i < _stringTablesSize; i++) {
1709
1711
  string _stringTablesItem{};
1710
1712
  _stringTablesItem = reader.Text();
1711
1713
  _stringTables.push_back(std::move(_stringTablesItem));
1712
1714
  }
1713
1715
  uint8_t _intTablesSize{};
1714
1716
  _intTablesSize = reader.Number<uint8_t>();
1717
+ _intTables.clear();
1715
1718
  _intTables.reserve(_intTablesSize);
1716
1719
  for (uint8_t i = 0; i < _intTablesSize; i++) {
1717
1720
  uint8_t _intTablesItem{};
1718
1721
  _intTablesItem = reader.Number<uint8_t>();
1719
1722
  _intTables.push_back(std::move(_intTablesItem));
@@ -1735,18 +1738,23 @@
1735
1738
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1736
1739
  if (hresult == Core::ERROR_NONE) {
1737
1740
  RPC::Data::Frame::Reader reader(message->Response().Reader());
1738
1741
  hresult = reader.Number<Core::hresult>();
1739
1742
  if (reader.Boolean() == true) {
1743
+ std::vector<string> _stringTablesObject__{};
1740
1744
  uint8_t _stringTablesSize{};
1741
1745
  _stringTablesSize = reader.Number<uint8_t>();
1742
- _stringTables.Value().reserve(_stringTablesSize);
1746
+ _stringTablesObject__.reserve(_stringTablesSize);
1743
1747
  for (uint8_t i = 0; i < _stringTablesSize; i++) {
1744
1748
  string _stringTablesItem{};
1745
1749
  _stringTablesItem = reader.Text();
1746
- _stringTables.Value().push_back(std::move(_stringTablesItem));
1750
+ _stringTablesObject__.push_back(std::move(_stringTablesItem));
1747
1751
  }
1752
+ _stringTables = std::move(_stringTablesObject__);
1753
+ }
1754
+ else {
1755
+ _stringTables = Core::OptionalType<std::vector<string>>();
1748
1756
  }
1749
1757
  } else {
1750
1758
  ASSERT((hresult & COM_ERROR) != 0);
1751
1759
  }
1752
1760
 
@@ -1804,52 +1812,67 @@
1804
1812
  RPC::Data::Frame::Reader reader(message->Response().Reader());
1805
1813
  hresult = reader.Number<Core::hresult>();
1806
1814
  _pod.param0 = reader.Text();
1807
1815
  uint8_t _pod_param1Size{};
1808
1816
  _pod_param1Size = reader.Number<uint8_t>();
1817
+ _pod.param1.clear();
1809
1818
  _pod.param1.reserve(_pod_param1Size);
1810
1819
  for (uint8_t i = 0; i < _pod_param1Size; i++) {
1811
1820
  string _pod_param1Item{};
1812
1821
  _pod_param1Item = reader.Text();
1813
1822
  _pod.param1.push_back(std::move(_pod_param1Item));
1814
1823
  }
1815
1824
  uint8_t _pod_param2Size{};
1816
1825
  _pod_param2Size = reader.Number<uint8_t>();
1826
+ _pod.param2.clear();
1817
1827
  _pod.param2.reserve(_pod_param2Size);
1818
1828
  for (uint8_t i = 0; i < _pod_param2Size; i++) {
1819
1829
  string _pod_param2Item{};
1820
1830
  _pod_param2Item = reader.Text();
1821
1831
  _pod.param2.push_back(std::move(_pod_param2Item));
1822
1832
  }
1823
1833
  if (reader.Boolean() == true) {
1834
+ std::vector<string> _pod_param3Object__{};
1824
1835
  uint8_t _pod_param3Size{};
1825
1836
  _pod_param3Size = reader.Number<uint8_t>();
1826
- _pod.param3.Value().reserve(_pod_param3Size);
1837
+ _pod_param3Object__.reserve(_pod_param3Size);
1827
1838
  for (uint8_t i = 0; i < _pod_param3Size; i++) {
1828
1839
  string _pod_param3Item{};
1829
1840
  _pod_param3Item = reader.Text();
1830
- _pod.param3.Value().push_back(std::move(_pod_param3Item));
1841
+ _pod_param3Object__.push_back(std::move(_pod_param3Item));
1831
1842
  }
1843
+ _pod.param3 = std::move(_pod_param3Object__);
1844
+ }
1845
+ else {
1846
+ _pod.param3 = Core::OptionalType<std::vector<string>>();
1832
1847
  }
1833
1848
  if (reader.Boolean() == true) {
1849
+ std::vector<string> _pod_param4Object__{};
1834
1850
  uint8_t _pod_param4Size{};
1835
1851
  _pod_param4Size = reader.Number<uint8_t>();
1836
- _pod.param4.Value().reserve(_pod_param4Size);
1852
+ _pod_param4Object__.reserve(_pod_param4Size);
1837
1853
  for (uint8_t i = 0; i < _pod_param4Size; i++) {
1838
1854
  string _pod_param4Item{};
1839
1855
  _pod_param4Item = reader.Text();
1840
- _pod.param4.Value().push_back(std::move(_pod_param4Item));
1856
+ _pod_param4Object__.push_back(std::move(_pod_param4Item));
1841
1857
  }
1858
+ _pod.param4 = std::move(_pod_param4Object__);
1859
+ }
1860
+ else {
1861
+ _pod.param4 = Core::OptionalType<std::vector<string>>();
1842
1862
  }
1843
1863
  _pod.param5.param0 = reader.Text();
1844
1864
  _pod.param5.param1 = reader.Boolean();
1845
1865
  if (reader.Boolean() == true) {
1846
1866
  Example::ISimpleAsync::SmallRecord _pod_param6Object__{};
1847
1867
  _pod_param6Object__.param0 = reader.Text();
1848
1868
  _pod_param6Object__.param1 = reader.Boolean();
1849
1869
  _pod.param6 = std::move(_pod_param6Object__);
1850
1870
  }
1871
+ else {
1872
+ _pod.param6 = Core::OptionalType<Example::ISimpleAsync::SmallRecord>();
1873
+ }
1851
1874
  } else {
1852
1875
  ASSERT((hresult & COM_ERROR) != 0);
1853
1876
  }
1854
1877
 
1855
1878
  return (hresult);
@@ -1869,54 +1892,72 @@
1869
1892
  if (reader.Boolean() == true) {
1870
1893
  Example::ISimpleAsync::Record _podObject__{};
1871
1894
  _podObject__.param0 = reader.Text();
1872
1895
  uint8_t _podObject___param1Size{};
1873
1896
  _podObject___param1Size = reader.Number<uint8_t>();
1897
+ _podObject__.param1.clear();
1874
1898
  _podObject__.param1.reserve(_podObject___param1Size);
1875
1899
  for (uint8_t i = 0; i < _podObject___param1Size; i++) {
1876
1900
  string _podObject___param1Item{};
1877
1901
  _podObject___param1Item = reader.Text();
1878
1902
  _podObject__.param1.push_back(std::move(_podObject___param1Item));
1879
1903
  }
1880
1904
  uint8_t _podObject___param2Size{};
1881
1905
  _podObject___param2Size = reader.Number<uint8_t>();
1906
+ _podObject__.param2.clear();
1882
1907
  _podObject__.param2.reserve(_podObject___param2Size);
1883
1908
  for (uint8_t i = 0; i < _podObject___param2Size; i++) {
1884
1909
  string _podObject___param2Item{};
1885
1910
  _podObject___param2Item = reader.Text();
1886
1911
  _podObject__.param2.push_back(std::move(_podObject___param2Item));
1887
1912
  }
1888
1913
  if (reader.Boolean() == true) {
1914
+ std::vector<string> _podObject___param3Object__{};
1889
1915
  uint8_t _podObject___param3Size{};
1890
1916
  _podObject___param3Size = reader.Number<uint8_t>();
1891
- _podObject__.param3.Value().reserve(_podObject___param3Size);
1917
+ _podObject___param3Object__.reserve(_podObject___param3Size);
1892
1918
  for (uint8_t i = 0; i < _podObject___param3Size; i++) {
1893
1919
  string _podObject___param3Item{};
1894
1920
  _podObject___param3Item = reader.Text();
1895
- _podObject__.param3.Value().push_back(std::move(_podObject___param3Item));
1921
+ _podObject___param3Object__.push_back(std::move(_podObject___param3Item));
1896
1922
  }
1923
+ _podObject__.param3 = std::move(_podObject___param3Object__);
1924
+ }
1925
+ else {
1926
+ _podObject__.param3 = Core::OptionalType<std::vector<string>>();
1897
1927
  }
1898
1928
  if (reader.Boolean() == true) {
1929
+ std::vector<string> _podObject___param4Object__{};
1899
1930
  uint8_t _podObject___param4Size{};
1900
1931
  _podObject___param4Size = reader.Number<uint8_t>();
1901
- _podObject__.param4.Value().reserve(_podObject___param4Size);
1932
+ _podObject___param4Object__.reserve(_podObject___param4Size);
1902
1933
  for (uint8_t i = 0; i < _podObject___param4Size; i++) {
1903
1934
  string _podObject___param4Item{};
1904
1935
  _podObject___param4Item = reader.Text();
1905
- _podObject__.param4.Value().push_back(std::move(_podObject___param4Item));
1936
+ _podObject___param4Object__.push_back(std::move(_podObject___param4Item));
1906
1937
  }
1938
+ _podObject__.param4 = std::move(_podObject___param4Object__);
1939
+ }
1940
+ else {
1941
+ _podObject__.param4 = Core::OptionalType<std::vector<string>>();
1907
1942
  }
1908
1943
  _podObject__.param5.param0 = reader.Text();
1909
1944
  _podObject__.param5.param1 = reader.Boolean();
1910
1945
  if (reader.Boolean() == true) {
1911
1946
  Example::ISimpleAsync::SmallRecord _podObject___param6Object__{};
1912
1947
  _podObject___param6Object__.param0 = reader.Text();
1913
1948
  _podObject___param6Object__.param1 = reader.Boolean();
1914
1949
  _podObject__.param6 = std::move(_podObject___param6Object__);
1915
1950
  }
1951
+ else {
1952
+ _podObject__.param6 = Core::OptionalType<Example::ISimpleAsync::SmallRecord>();
1953
+ }
1916
1954
  _pod = std::move(_podObject__);
1917
1955
  }
1956
+ else {
1957
+ _pod = Core::OptionalType<Example::ISimpleAsync::Record>();
1958
+ }
1918
1959
  } else {
1919
1960
  ASSERT((hresult & COM_ERROR) != 0);
1920
1961
  }
1921
1962
 
1922
1963
  return (hresult);
@@ -1934,31 +1975,44 @@
1934
1975
  RPC::Data::Frame::Reader reader(message->Response().Reader());
1935
1976
  hresult = reader.Number<Core::hresult>();
1936
1977
  if (reader.Boolean() == true) {
1937
1978
  Example::ISimpleAsync::Record2 _podObject__{};
1938
1979
  if (reader.Boolean() == true) {
1980
+ std::vector<string> _podObject___param3Object__{};
1939
1981
  uint8_t _podObject___param3Size{};
1940
1982
  _podObject___param3Size = reader.Number<uint8_t>();
1941
- _podObject__.param3.Value().reserve(_podObject___param3Size);
1983
+ _podObject___param3Object__.reserve(_podObject___param3Size);
1942
1984
  for (uint8_t i = 0; i < _podObject___param3Size; i++) {
1943
1985
  string _podObject___param3Item{};
1944
1986
  _podObject___param3Item = reader.Text();
1945
- _podObject__.param3.Value().push_back(std::move(_podObject___param3Item));
1987
+ _podObject___param3Object__.push_back(std::move(_podObject___param3Item));
1946
1988
  }
1989
+ _podObject__.param3 = std::move(_podObject___param3Object__);
1990
+ }
1991
+ else {
1992
+ _podObject__.param3 = Core::OptionalType<std::vector<string>>();
1947
1993
  }
1948
1994
  if (reader.Boolean() == true) {
1995
+ std::vector<string> _podObject___param4Object__{};
1949
1996
  uint8_t _podObject___param4Size{};
1950
1997
  _podObject___param4Size = reader.Number<uint8_t>();
1951
- _podObject__.param4.Value().reserve(_podObject___param4Size);
1998
+ _podObject___param4Object__.reserve(_podObject___param4Size);
1952
1999
  for (uint8_t i = 0; i < _podObject___param4Size; i++) {
1953
2000
  string _podObject___param4Item{};
1954
2001
  _podObject___param4Item = reader.Text();
1955
- _podObject__.param4.Value().push_back(std::move(_podObject___param4Item));
2002
+ _podObject___param4Object__.push_back(std::move(_podObject___param4Item));
1956
2003
  }
2004
+ _podObject__.param4 = std::move(_podObject___param4Object__);
2005
+ }
2006
+ else {
2007
+ _podObject__.param4 = Core::OptionalType<std::vector<string>>();
1957
2008
  }
1958
2009
  _pod = std::move(_podObject__);
1959
2010
  }
2011
+ else {
2012
+ _pod = Core::OptionalType<Example::ISimpleAsync::Record2>();
2013
+ }
1960
2014
  } else {
1961
2015
  ASSERT((hresult & COM_ERROR) != 0);
1962
2016
  }
1963
2017
 
1964
2018
  return (hresult);
@@ -1974,28 +2028,38 @@
1974
2028
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1975
2029
  if (hresult == Core::ERROR_NONE) {
1976
2030
  RPC::Data::Frame::Reader reader(message->Response().Reader());
1977
2031
  hresult = reader.Number<Core::hresult>();
1978
2032
  if (reader.Boolean() == true) {
2033
+ std::vector<string> _pod_param3Object__{};
1979
2034
  uint8_t _pod_param3Size{};
1980
2035
  _pod_param3Size = reader.Number<uint8_t>();
1981
- _pod.param3.Value().reserve(_pod_param3Size);
2036
+ _pod_param3Object__.reserve(_pod_param3Size);
1982
2037
  for (uint8_t i = 0; i < _pod_param3Size; i++) {
1983
2038
  string _pod_param3Item{};
1984
2039
  _pod_param3Item = reader.Text();
1985
- _pod.param3.Value().push_back(std::move(_pod_param3Item));
2040
+ _pod_param3Object__.push_back(std::move(_pod_param3Item));
1986
2041
  }
2042
+ _pod.param3 = std::move(_pod_param3Object__);
2043
+ }
2044
+ else {
2045
+ _pod.param3 = Core::OptionalType<std::vector<string>>();
1987
2046
  }
1988
2047
  if (reader.Boolean() == true) {
2048
+ std::vector<string> _pod_param4Object__{};
1989
2049
  uint8_t _pod_param4Size{};
1990
2050
  _pod_param4Size = reader.Number<uint8_t>();
1991
- _pod.param4.Value().reserve(_pod_param4Size);
2051
+ _pod_param4Object__.reserve(_pod_param4Size);
1992
2052
  for (uint8_t i = 0; i < _pod_param4Size; i++) {
1993
2053
  string _pod_param4Item{};
1994
2054
  _pod_param4Item = reader.Text();
1995
- _pod.param4.Value().push_back(std::move(_pod_param4Item));
2055
+ _pod_param4Object__.push_back(std::move(_pod_param4Item));
1996
2056
  }
2057
+ _pod.param4 = std::move(_pod_param4Object__);
2058
+ }
2059
+ else {
2060
+ _pod.param4 = Core::OptionalType<std::vector<string>>();
1997
2061
  }
1998
2062
  } else {
1999
2063
  ASSERT((hresult & COM_ERROR) != 0);
2000
2064
  }
2001
2065
 
@@ -2014,10 +2078,13 @@
2014
2078
  RPC::Data::Frame::Reader reader(message->Response().Reader());
2015
2079
  hresult = reader.Number<Core::hresult>();
2016
2080
  if (reader.Boolean() == true) {
2017
2081
  _result = reader.Text();
2018
2082
  }
2083
+ else {
2084
+ _result = Core::OptionalType<string>();
2085
+ }
2019
2086
  } else {
2020
2087
  ASSERT((hresult & COM_ERROR) != 0);
2021
2088
  }
2022
2089
 
2023
2090
  return (hresult);
Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_AudioStream.cpp CHANGED
@@ -506,16 +506,22 @@
506
506
  hresult = reader.Number<Core::hresult>();
507
507
  _profile.codec = reader.Number<Exchange::IAudioStream::codectype>();
508
508
  if (reader.Boolean() == true) {
509
509
  _profile.codecParams = reader.Text();
510
510
  }
511
+ else {
512
+ _profile.codecParams = Core::OptionalType<string>();
513
+ }
511
514
  _profile.channels = reader.Number<uint8_t>();
512
515
  _profile.resolution = reader.Number<uint8_t>();
513
516
  _profile.sampleRate = reader.Number<uint32_t>();
514
517
  if (reader.Boolean() == true) {
515
518
  _profile.bitRate = reader.Number<uint32_t>();
516
519
  }
520
+ else {
521
+ _profile.bitRate = Core::OptionalType<uint32_t>();
522
+ }
517
523
  } else {
518
524
  ASSERT((hresult & COM_ERROR) != 0);
519
525
  }
520
526
 
521
527
  return (hresult);
Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_BluetoothRemoteControl.cpp CHANGED
@@ -361,22 +361,37 @@
361
361
  hresult = reader.Number<Core::hresult>();
362
362
  _info.name = reader.Text();
363
363
  if (reader.Boolean() == true) {
364
364
  _info.model = reader.Text();
365
365
  }
366
+ else {
367
+ _info.model = Core::OptionalType<string>();
368
+ }
366
369
  if (reader.Boolean() == true) {
367
370
  _info.serial = reader.Text();
368
371
  }
372
+ else {
373
+ _info.serial = Core::OptionalType<string>();
374
+ }
369
375
  if (reader.Boolean() == true) {
370
376
  _info.firmware = reader.Text();
371
377
  }
378
+ else {
379
+ _info.firmware = Core::OptionalType<string>();
380
+ }
372
381
  if (reader.Boolean() == true) {
373
382
  _info.software = reader.Text();
374
383
  }
384
+ else {
385
+ _info.software = Core::OptionalType<string>();
386
+ }
375
387
  if (reader.Boolean() == true) {
376
388
  _info.manufacturer = reader.Text();
377
389
  }
390
+ else {
391
+ _info.manufacturer = Core::OptionalType<string>();
392
+ }
378
393
  } else {
379
394
  ASSERT((hresult & COM_ERROR) != 0);
380
395
  }
381
396
 
382
397
  return (hresult);
Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_DeviceIdentification.cpp CHANGED
@@ -82,13 +82,19 @@
82
82
  hresult = reader.Number<Core::hresult>();
83
83
  _info.deviceID = reader.Text();
84
84
  if (reader.Boolean() == true) {
85
85
  _info.firmwareVersion = reader.Text();
86
86
  }
87
+ else {
88
+ _info.firmwareVersion = Core::OptionalType<string>();
89
+ }
87
90
  if (reader.Boolean() == true) {
88
91
  _info.chipset = reader.Text();
89
92
  }
93
+ else {
94
+ _info.chipset = Core::OptionalType<string>();
95
+ }
90
96
  } else {
91
97
  ASSERT((hresult & COM_ERROR) != 0);
92
98
  }
93
99
 
94
100
  return (hresult);
Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_LocationSync.cpp CHANGED
@@ -237,22 +237,37 @@
237
237
  RPC::Data::Frame::Reader reader(message->Response().Reader());
238
238
  hresult = reader.Number<Core::hresult>();
239
239
  if (reader.Boolean() == true) {
240
240
  _info.city = reader.Text();
241
241
  }
242
+ else {
243
+ _info.city = Core::OptionalType<string>();
244
+ }
242
245
  if (reader.Boolean() == true) {
243
246
  _info.country = reader.Text();
244
247
  }
248
+ else {
249
+ _info.country = Core::OptionalType<string>();
250
+ }
245
251
  if (reader.Boolean() == true) {
246
252
  _info.region = reader.Text();
247
253
  }
254
+ else {
255
+ _info.region = Core::OptionalType<string>();
256
+ }
248
257
  if (reader.Boolean() == true) {
249
258
  _info.timeZone = reader.Text();
250
259
  }
260
+ else {
261
+ _info.timeZone = Core::OptionalType<string>();
262
+ }
251
263
  if (reader.Boolean() == true) {
252
264
  _info.publicIP = reader.Text();
253
265
  }
266
+ else {
267
+ _info.publicIP = Core::OptionalType<string>();
268
+ }
254
269
  } else {
255
270
  ASSERT((hresult & COM_ERROR) != 0);
256
271
  }
257
272
 
258
273
  return (hresult);
Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_TimeSync.cpp CHANGED
@@ -384,10 +384,13 @@
384
384
  hresult = reader.Number<Core::hresult>();
385
385
  _info.time = reader.Number<Core::Time::microsecondsfromepoch>();
386
386
  if (reader.Boolean() == true) {
387
387
  _info.source = reader.Text();
388
388
  }
389
+ else {
390
+ _info.source = Core::OptionalType<string>();
391
+ }
389
392
  } else {
390
393
  ASSERT((hresult & COM_ERROR) != 0);
391
394
  }
392
395
 
393
396
  return (hresult);
Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_ValuePoint.cpp CHANGED
@@ -887,10 +887,13 @@
887
887
  _value.model = reader.Text();
888
888
  _value.communication = reader.Number<Exchange::IValuePoint::protocol>();
889
889
  if (reader.Boolean() == true) {
890
890
  _value.metadata = reader.Text();
891
891
  }
892
+ else {
893
+ _value.metadata = Core::OptionalType<string>();
894
+ }
892
895
  } else {
893
896
  ASSERT((hresult & COM_ERROR) != 0);
894
897
  }
895
898
 
896
899
  return (hresult);
Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_WifiControl.cpp CHANGED
@@ -705,10 +705,13 @@
705
705
  result = reader.Boolean();
706
706
  _info.method = reader.Number<Exchange::IWifiControl::Security>();
707
707
  if (reader.Boolean() == true) {
708
708
  _info.keys = reader.Number<Exchange::IWifiControl::SecurityInfo::Key>();
709
709
  }
710
+ else {
711
+ _info.keys = Core::OptionalType<Exchange::IWifiControl::SecurityInfo::Key>();
712
+ }
710
713
  } else {
711
714
  ASSERT((hresult & COM_ERROR) != 0);
712
715
  }
713
716
 
714
717
  return (result);
@@ -726,10 +729,13 @@
726
729
  result = reader.Boolean();
727
730
  _info.method = reader.Number<Exchange::IWifiControl::Security>();
728
731
  if (reader.Boolean() == true) {
729
732
  _info.keys = reader.Number<Exchange::IWifiControl::SecurityInfo::Key>();
730
733
  }
734
+ else {
735
+ _info.keys = Core::OptionalType<Exchange::IWifiControl::SecurityInfo::Key>();
736
+ }
731
737
  } else {
732
738
  ASSERT((hresult & COM_ERROR) != 0);
733
739
  }
734
740
 
735
741
  return (result);
@@ -790,10 +796,13 @@
790
796
  RPC::Data::Frame::Reader reader(message->Response().Reader());
791
797
  result.method = reader.Number<Exchange::IWifiControl::Security>();
792
798
  if (reader.Boolean() == true) {
793
799
  result.keys = reader.Number<Exchange::IWifiControl::SecurityInfo::Key>();
794
800
  }
801
+ else {
802
+ result.keys = Core::OptionalType<Exchange::IWifiControl::SecurityInfo::Key>();
803
+ }
795
804
  } else {
796
805
  ASSERT((hresult & COM_ERROR) != 0);
797
806
  }
798
807
 
799
808
  return (result);
@@ -831,10 +840,13 @@
831
840
  RPC::Data::Frame::Reader reader(message->Response().Reader());
832
841
  result = reader.Boolean();
833
842
  if (reader.Boolean() == true) {
834
843
  _info.ssid = reader.Text();
835
844
  }
845
+ else {
846
+ _info.ssid = Core::OptionalType<string>();
847
+ }
836
848
  _info.bssid = reader.Number<uint64_t>();
837
849
  _info.frequency = reader.Number<uint32_t>();
838
850
  _info.signal = reader.Number<int32_t>();
839
851
  _info.security = reader.Number<Exchange::IWifiControl::Security>();
840
852
  } else {
@@ -855,10 +867,13 @@
855
867
  RPC::Data::Frame::Reader reader(message->Response().Reader());
856
868
  result = reader.Boolean();
857
869
  if (reader.Boolean() == true) {
858
870
  _info.ssid = reader.Text();
859
871
  }
872
+ else {
873
+ _info.ssid = Core::OptionalType<string>();
874
+ }
860
875
  _info.bssid = reader.Number<uint64_t>();
861
876
  _info.frequency = reader.Number<uint32_t>();
862
877
  _info.signal = reader.Number<int32_t>();
863
878
  _info.security = reader.Number<Exchange::IWifiControl::Security>();
864
879
  } else {
@@ -922,10 +937,13 @@
922
937
  if (hresult == Core::ERROR_NONE) {
923
938
  RPC::Data::Frame::Reader reader(message->Response().Reader());
924
939
  if (reader.Boolean() == true) {
925
940
  result.ssid = reader.Text();
926
941
  }
942
+ else {
943
+ result.ssid = Core::OptionalType<string>();
944
+ }
927
945
  result.bssid = reader.Number<uint64_t>();
928
946
  result.frequency = reader.Number<uint32_t>();
929
947
  result.signal = reader.Number<int32_t>();
930
948
  result.security = reader.Number<Exchange::IWifiControl::Security>();
931
949
  } else {
@@ -1185,20 +1203,32 @@
1185
1203
  _configInfo.hidden = reader.Boolean();
1186
1204
  _configInfo.accesspoint = reader.Boolean();
1187
1205
  if (reader.Boolean() == true) {
1188
1206
  _configInfo.ssid = reader.Text();
1189
1207
  }
1208
+ else {
1209
+ _configInfo.ssid = Core::OptionalType<string>();
1210
+ }
1190
1211
  if (reader.Boolean() == true) {
1191
1212
  _configInfo.secret = reader.Text();
1192
1213
  }
1214
+ else {
1215
+ _configInfo.secret = Core::OptionalType<string>();
1216
+ }
1193
1217
  if (reader.Boolean() == true) {
1194
1218
  _configInfo.identity = reader.Text();
1195
1219
  }
1220
+ else {
1221
+ _configInfo.identity = Core::OptionalType<string>();
1222
+ }
1196
1223
  _configInfo.method = reader.Number<Exchange::IWifiControl::Security>();
1197
1224
  if (reader.Boolean() == true) {
1198
1225
  _configInfo.key = reader.Number<Exchange::IWifiControl::SecurityInfo::Key>();
1199
1226
  }
1227
+ else {
1228
+ _configInfo.key = Core::OptionalType<Exchange::IWifiControl::SecurityInfo::Key>();
1229
+ }
1200
1230
  } else {
1201
1231
  ASSERT((hresult & COM_ERROR) != 0);
1202
1232
  }
1203
1233
 
1204
1234
  return (hresult);
Debug/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_Benchmark.cpp CHANGED
@@ -422,10 +422,13 @@
422
422
  _info.memory.allocatedAfter = reader.Number<uint64_t>();
423
423
  _info.passed = reader.Boolean();
424
424
  if (reader.Boolean() == true) {
425
425
  _info.failureReason = reader.Number<QualityAssurance::IBenchmark::FailureReason>();
426
426
  }
427
+ else {
428
+ _info.failureReason = Core::OptionalType<QualityAssurance::IBenchmark::FailureReason>();
429
+ }
427
430
  } else {
428
431
  ASSERT((hresult & COM_ERROR) != 0);
429
432
  }
430
433
 
431
434
  return (result);
@@ -453,10 +456,13 @@
453
456
  _info.memory.allocatedAfter = reader.Number<uint64_t>();
454
457
  _info.passed = reader.Boolean();
455
458
  if (reader.Boolean() == true) {
456
459
  _info.failureReason = reader.Number<QualityAssurance::IBenchmark::FailureReason>();
457
460
  }
461
+ else {
462
+ _info.failureReason = Core::OptionalType<QualityAssurance::IBenchmark::FailureReason>();
463
+ }
458
464
  } else {
459
465
  ASSERT((hresult & COM_ERROR) != 0);
460
466
  }
461
467
 
462
468
  return (result);
@@ -527,10 +533,13 @@
527
533
  result.memory.allocatedAfter = reader.Number<uint64_t>();
528
534
  result.passed = reader.Boolean();
529
535
  if (reader.Boolean() == true) {
530
536
  result.failureReason = reader.Number<QualityAssurance::IBenchmark::FailureReason>();
531
537
  }
538
+ else {
539
+ result.failureReason = Core::OptionalType<QualityAssurance::IBenchmark::FailureReason>();
540
+ }
532
541
  } else {
533
542
  ASSERT((hresult & COM_ERROR) != 0);
534
543
  }
535
544
 
536
545
  return (result);
Debug/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_BenchmarkPayload.cpp CHANGED
@@ -1130,10 +1130,11 @@
1130
1130
  if (hresult == Core::ERROR_NONE) {
1131
1131
  RPC::Data::Frame::Reader reader(message->Response().Reader());
1132
1132
  hresult = reader.Number<Core::hresult>();
1133
1133
  uint16_t _outputSize{};
1134
1134
  _outputSize = reader.Number<uint16_t>();
1135
+ _output.clear();
1135
1136
  _output.reserve(_outputSize);
1136
1137
  for (uint16_t i = 0; i < _outputSize; i++) {
1137
1138
  uint32_t _outputItem{};
1138
1139
  _outputItem = reader.Number<uint32_t>();
1139
1140
  _output.push_back(std::move(_outputItem));
Release/Thunder/Source/plugins/generated/ProxyStubs_Controller.cpp CHANGED
@@ -2886,10 +2886,13 @@
2886
2886
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2887
2887
  if (reader.Boolean() == true) {
2888
2888
  if (reader.Length() < (Core::RealSize<Controller::IMetadata::Data::BuildInfo::extensiontype>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2889
2889
  _buildInfo.Extensions = reader.Number<Controller::IMetadata::Data::BuildInfo::extensiontype>();
2890
2890
  }
2891
+ else {
2892
+ _buildInfo.Extensions = Core::OptionalType<Controller::IMetadata::Data::BuildInfo::extensiontype>();
2893
+ }
2891
2894
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2892
2895
  _buildInfo.Messaging = reader.Boolean();
2893
2896
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2894
2897
  _buildInfo.ExceptionCatching = reader.Boolean();
2895
2898
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
@@ -2901,10 +2904,13 @@
2901
2904
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2902
2905
  if (reader.Boolean() == true) {
2903
2906
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2904
2907
  _buildInfo.TraceLevel = reader.Number<uint8_t>();
2905
2908
  }
2909
+ else {
2910
+ _buildInfo.TraceLevel = Core::OptionalType<uint8_t>();
2911
+ }
2906
2912
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2907
2913
  _buildInfo.ThreadPoolCount = reader.Number<uint8_t>();
2908
2914
  if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2909
2915
  _buildInfo.COMRPCTimeOut = reader.Number<uint32_t>();
2910
2916
  }
Release/ThunderInterfaces/example_interfaces/example_generated/ProxyStubs_SimpleAsync.cpp CHANGED
@@ -465,15 +465,15 @@
465
465
  std::vector<uint8_t> _addressObject__{};
466
466
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
467
467
  uint8_t _addressObject__Size = reader.Number<uint8_t>();
468
468
  ASSERT((_addressObject__Size >= 6) && (_addressObject__Size <= 6));
469
469
  if (!((_addressObject__Size >= 6) && (_addressObject__Size <= 6))) { return (COM_ERROR | Core::ERROR_INVALID_RANGE); }
470
- _address.Value().reserve(_addressObject__Size);
470
+ _addressObject__.reserve(_addressObject__Size);
471
471
  for (uint8_t i = 0; i < _addressObject__Size; i++) {
472
472
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
473
473
  uint8_t _addressObject__Item = reader.Number<uint8_t>();
474
- _address.Value().push_back(std::move(_addressObject__Item));
474
+ _addressObject__.push_back(std::move(_addressObject__Item));
475
475
  }
476
476
  _address = std::move(_addressObject__);
477
477
  }
478
478
  Core::OptionalType<uint16_t> _timeout{};
479
479
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
@@ -1624,15 +1624,15 @@
1624
1624
  std::vector<uint8_t> _addressObject__{};
1625
1625
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1626
1626
  uint8_t _addressObject__Size = reader.Number<uint8_t>();
1627
1627
  ASSERT((_addressObject__Size >= 6) && (_addressObject__Size <= 6));
1628
1628
  if (!((_addressObject__Size >= 6) && (_addressObject__Size <= 6))) { return (COM_ERROR | Core::ERROR_INVALID_RANGE); }
1629
- _address.Value().reserve(_addressObject__Size);
1629
+ _addressObject__.reserve(_addressObject__Size);
1630
1630
  for (uint8_t i = 0; i < _addressObject__Size; i++) {
1631
1631
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1632
1632
  uint8_t _addressObject__Item = reader.Number<uint8_t>();
1633
- _address.Value().push_back(std::move(_addressObject__Item));
1633
+ _addressObject__.push_back(std::move(_addressObject__Item));
1634
1634
  }
1635
1635
  _address = std::move(_addressObject__);
1636
1636
  }
1637
1637
  if (reader.Length() < (Core::RealSize<Example::ISimpleAsync::state>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1638
1638
  const Example::ISimpleAsync::state _state = reader.Number<Example::ISimpleAsync::state>();
@@ -2723,10 +2723,11 @@
2723
2723
  hresult = reader.Number<Core::hresult>();
2724
2724
  if ((hresult & COM_ERROR) == 0) {
2725
2725
  uint8_t _stringTablesSize{};
2726
2726
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2727
2727
  _stringTablesSize = reader.Number<uint8_t>();
2728
+ _stringTables.clear();
2728
2729
  _stringTables.reserve(_stringTablesSize);
2729
2730
  for (uint8_t i = 0; i < _stringTablesSize; i++) {
2730
2731
  string _stringTablesItem{};
2731
2732
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2732
2733
  const uint16_t _stringTablesItemPeekedLen__ = reader.PeekNumber<uint16_t>();
@@ -2764,10 +2765,11 @@
2764
2765
  hresult = reader.Number<Core::hresult>();
2765
2766
  if ((hresult & COM_ERROR) == 0) {
2766
2767
  uint8_t _stringTablesSize{};
2767
2768
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2768
2769
  _stringTablesSize = reader.Number<uint8_t>();
2770
+ _stringTables.clear();
2769
2771
  _stringTables.reserve(_stringTablesSize);
2770
2772
  for (uint8_t i = 0; i < _stringTablesSize; i++) {
2771
2773
  string _stringTablesItem{};
2772
2774
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2773
2775
  const uint16_t _stringTablesItemPeekedLen__ = reader.PeekNumber<uint16_t>();
@@ -2776,10 +2778,11 @@
2776
2778
  _stringTables.push_back(std::move(_stringTablesItem));
2777
2779
  }
2778
2780
  uint8_t _intTablesSize{};
2779
2781
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2780
2782
  _intTablesSize = reader.Number<uint8_t>();
2783
+ _intTables.clear();
2781
2784
  _intTables.reserve(_intTablesSize);
2782
2785
  for (uint8_t i = 0; i < _intTablesSize; i++) {
2783
2786
  uint8_t _intTablesItem{};
2784
2787
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2785
2788
  _intTablesItem = reader.Number<uint8_t>();
@@ -2814,22 +2817,27 @@
2814
2817
  if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2815
2818
  hresult = reader.Number<Core::hresult>();
2816
2819
  if ((hresult & COM_ERROR) == 0) {
2817
2820
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2818
2821
  if (reader.Boolean() == true) {
2822
+ std::vector<string> _stringTablesObject__{};
2819
2823
  uint8_t _stringTablesSize{};
2820
2824
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2821
2825
  _stringTablesSize = reader.Number<uint8_t>();
2822
- _stringTables.Value().reserve(_stringTablesSize);
2826
+ _stringTablesObject__.reserve(_stringTablesSize);
2823
2827
  for (uint8_t i = 0; i < _stringTablesSize; i++) {
2824
2828
  string _stringTablesItem{};
2825
2829
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2826
2830
  const uint16_t _stringTablesItemPeekedLen__ = reader.PeekNumber<uint16_t>();
2827
2831
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _stringTablesItemPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2828
2832
  _stringTablesItem = reader.Text();
2829
- _stringTables.Value().push_back(std::move(_stringTablesItem));
2833
+ _stringTablesObject__.push_back(std::move(_stringTablesItem));
2830
2834
  }
2835
+ _stringTables = std::move(_stringTablesObject__);
2836
+ }
2837
+ else {
2838
+ _stringTables = Core::OptionalType<std::vector<string>>();
2831
2839
  }
2832
2840
  }
2833
2841
 
2834
2842
  return (hresult);
2835
2843
  } ();
@@ -2924,10 +2932,11 @@
2924
2932
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _pod_param0PeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2925
2933
  _pod.param0 = reader.Text();
2926
2934
  uint8_t _pod_param1Size{};
2927
2935
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2928
2936
  _pod_param1Size = reader.Number<uint8_t>();
2937
+ _pod.param1.clear();
2929
2938
  _pod.param1.reserve(_pod_param1Size);
2930
2939
  for (uint8_t i = 0; i < _pod_param1Size; i++) {
2931
2940
  string _pod_param1Item{};
2932
2941
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2933
2942
  const uint16_t _pod_param1ItemPeekedLen__ = reader.PeekNumber<uint16_t>();
@@ -2936,10 +2945,11 @@
2936
2945
  _pod.param1.push_back(std::move(_pod_param1Item));
2937
2946
  }
2938
2947
  uint8_t _pod_param2Size{};
2939
2948
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2940
2949
  _pod_param2Size = reader.Number<uint8_t>();
2950
+ _pod.param2.clear();
2941
2951
  _pod.param2.reserve(_pod_param2Size);
2942
2952
  for (uint8_t i = 0; i < _pod_param2Size; i++) {
2943
2953
  string _pod_param2Item{};
2944
2954
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2945
2955
  const uint16_t _pod_param2ItemPeekedLen__ = reader.PeekNumber<uint16_t>();
@@ -2947,37 +2957,47 @@
2947
2957
  _pod_param2Item = reader.Text();
2948
2958
  _pod.param2.push_back(std::move(_pod_param2Item));
2949
2959
  }
2950
2960
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2951
2961
  if (reader.Boolean() == true) {
2962
+ std::vector<string> _pod_param3Object__{};
2952
2963
  uint8_t _pod_param3Size{};
2953
2964
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2954
2965
  _pod_param3Size = reader.Number<uint8_t>();
2955
- _pod.param3.Value().reserve(_pod_param3Size);
2966
+ _pod_param3Object__.reserve(_pod_param3Size);
2956
2967
  for (uint8_t i = 0; i < _pod_param3Size; i++) {
2957
2968
  string _pod_param3Item{};
2958
2969
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2959
2970
  const uint16_t _pod_param3ItemPeekedLen__ = reader.PeekNumber<uint16_t>();
2960
2971
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _pod_param3ItemPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2961
2972
  _pod_param3Item = reader.Text();
2962
- _pod.param3.Value().push_back(std::move(_pod_param3Item));
2973
+ _pod_param3Object__.push_back(std::move(_pod_param3Item));
2963
2974
  }
2975
+ _pod.param3 = std::move(_pod_param3Object__);
2976
+ }
2977
+ else {
2978
+ _pod.param3 = Core::OptionalType<std::vector<string>>();
2964
2979
  }
2965
2980
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2966
2981
  if (reader.Boolean() == true) {
2982
+ std::vector<string> _pod_param4Object__{};
2967
2983
  uint8_t _pod_param4Size{};
2968
2984
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2969
2985
  _pod_param4Size = reader.Number<uint8_t>();
2970
- _pod.param4.Value().reserve(_pod_param4Size);
2986
+ _pod_param4Object__.reserve(_pod_param4Size);
2971
2987
  for (uint8_t i = 0; i < _pod_param4Size; i++) {
2972
2988
  string _pod_param4Item{};
2973
2989
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2974
2990
  const uint16_t _pod_param4ItemPeekedLen__ = reader.PeekNumber<uint16_t>();
2975
2991
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _pod_param4ItemPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2976
2992
  _pod_param4Item = reader.Text();
2977
- _pod.param4.Value().push_back(std::move(_pod_param4Item));
2993
+ _pod_param4Object__.push_back(std::move(_pod_param4Item));
2978
2994
  }
2995
+ _pod.param4 = std::move(_pod_param4Object__);
2996
+ }
2997
+ else {
2998
+ _pod.param4 = Core::OptionalType<std::vector<string>>();
2979
2999
  }
2980
3000
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2981
3001
  const uint16_t _pod_param5_param0PeekedLen__ = reader.PeekNumber<uint16_t>();
2982
3002
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _pod_param5_param0PeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2983
3003
  _pod.param5.param0 = reader.Text();
@@ -2992,10 +3012,13 @@
2992
3012
  _pod_param6Object__.param0 = reader.Text();
2993
3013
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2994
3014
  _pod_param6Object__.param1 = reader.Boolean();
2995
3015
  _pod.param6 = std::move(_pod_param6Object__);
2996
3016
  }
3017
+ else {
3018
+ _pod.param6 = Core::OptionalType<Example::ISimpleAsync::SmallRecord>();
3019
+ }
2997
3020
  }
2998
3021
 
2999
3022
  return (hresult);
3000
3023
  } ();
3001
3024
  } else {
@@ -3031,10 +3054,11 @@
3031
3054
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _podObject___param0PeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3032
3055
  _podObject__.param0 = reader.Text();
3033
3056
  uint8_t _podObject___param1Size{};
3034
3057
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3035
3058
  _podObject___param1Size = reader.Number<uint8_t>();
3059
+ _podObject__.param1.clear();
3036
3060
  _podObject__.param1.reserve(_podObject___param1Size);
3037
3061
  for (uint8_t i = 0; i < _podObject___param1Size; i++) {
3038
3062
  string _podObject___param1Item{};
3039
3063
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3040
3064
  const uint16_t _podObject___param1ItemPeekedLen__ = reader.PeekNumber<uint16_t>();
@@ -3043,10 +3067,11 @@
3043
3067
  _podObject__.param1.push_back(std::move(_podObject___param1Item));
3044
3068
  }
3045
3069
  uint8_t _podObject___param2Size{};
3046
3070
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3047
3071
  _podObject___param2Size = reader.Number<uint8_t>();
3072
+ _podObject__.param2.clear();
3048
3073
  _podObject__.param2.reserve(_podObject___param2Size);
3049
3074
  for (uint8_t i = 0; i < _podObject___param2Size; i++) {
3050
3075
  string _podObject___param2Item{};
3051
3076
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3052
3077
  const uint16_t _podObject___param2ItemPeekedLen__ = reader.PeekNumber<uint16_t>();
@@ -3054,37 +3079,47 @@
3054
3079
  _podObject___param2Item = reader.Text();
3055
3080
  _podObject__.param2.push_back(std::move(_podObject___param2Item));
3056
3081
  }
3057
3082
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3058
3083
  if (reader.Boolean() == true) {
3084
+ std::vector<string> _podObject___param3Object__{};
3059
3085
  uint8_t _podObject___param3Size{};
3060
3086
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3061
3087
  _podObject___param3Size = reader.Number<uint8_t>();
3062
- _podObject__.param3.Value().reserve(_podObject___param3Size);
3088
+ _podObject___param3Object__.reserve(_podObject___param3Size);
3063
3089
  for (uint8_t i = 0; i < _podObject___param3Size; i++) {
3064
3090
  string _podObject___param3Item{};
3065
3091
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3066
3092
  const uint16_t _podObject___param3ItemPeekedLen__ = reader.PeekNumber<uint16_t>();
3067
3093
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _podObject___param3ItemPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3068
3094
  _podObject___param3Item = reader.Text();
3069
- _podObject__.param3.Value().push_back(std::move(_podObject___param3Item));
3095
+ _podObject___param3Object__.push_back(std::move(_podObject___param3Item));
3070
3096
  }
3097
+ _podObject__.param3 = std::move(_podObject___param3Object__);
3098
+ }
3099
+ else {
3100
+ _podObject__.param3 = Core::OptionalType<std::vector<string>>();
3071
3101
  }
3072
3102
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3073
3103
  if (reader.Boolean() == true) {
3104
+ std::vector<string> _podObject___param4Object__{};
3074
3105
  uint8_t _podObject___param4Size{};
3075
3106
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3076
3107
  _podObject___param4Size = reader.Number<uint8_t>();
3077
- _podObject__.param4.Value().reserve(_podObject___param4Size);
3108
+ _podObject___param4Object__.reserve(_podObject___param4Size);
3078
3109
  for (uint8_t i = 0; i < _podObject___param4Size; i++) {
3079
3110
  string _podObject___param4Item{};
3080
3111
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3081
3112
  const uint16_t _podObject___param4ItemPeekedLen__ = reader.PeekNumber<uint16_t>();
3082
3113
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _podObject___param4ItemPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3083
3114
  _podObject___param4Item = reader.Text();
3084
- _podObject__.param4.Value().push_back(std::move(_podObject___param4Item));
3115
+ _podObject___param4Object__.push_back(std::move(_podObject___param4Item));
3085
3116
  }
3117
+ _podObject__.param4 = std::move(_podObject___param4Object__);
3118
+ }
3119
+ else {
3120
+ _podObject__.param4 = Core::OptionalType<std::vector<string>>();
3086
3121
  }
3087
3122
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3088
3123
  const uint16_t _podObject___param5_param0PeekedLen__ = reader.PeekNumber<uint16_t>();
3089
3124
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _podObject___param5_param0PeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3090
3125
  _podObject__.param5.param0 = reader.Text();
@@ -3099,12 +3134,18 @@
3099
3134
  _podObject___param6Object__.param0 = reader.Text();
3100
3135
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3101
3136
  _podObject___param6Object__.param1 = reader.Boolean();
3102
3137
  _podObject__.param6 = std::move(_podObject___param6Object__);
3103
3138
  }
3139
+ else {
3140
+ _podObject__.param6 = Core::OptionalType<Example::ISimpleAsync::SmallRecord>();
3141
+ }
3104
3142
  _pod = std::move(_podObject__);
3105
3143
  }
3144
+ else {
3145
+ _pod = Core::OptionalType<Example::ISimpleAsync::Record>();
3146
+ }
3106
3147
  }
3107
3148
 
3108
3149
  return (hresult);
3109
3150
  } ();
3110
3151
  } else {
@@ -3135,40 +3176,53 @@
3135
3176
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3136
3177
  if (reader.Boolean() == true) {
3137
3178
  Example::ISimpleAsync::Record2 _podObject__{};
3138
3179
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3139
3180
  if (reader.Boolean() == true) {
3181
+ std::vector<string> _podObject___param3Object__{};
3140
3182
  uint8_t _podObject___param3Size{};
3141
3183
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3142
3184
  _podObject___param3Size = reader.Number<uint8_t>();
3143
- _podObject__.param3.Value().reserve(_podObject___param3Size);
3185
+ _podObject___param3Object__.reserve(_podObject___param3Size);
3144
3186
  for (uint8_t i = 0; i < _podObject___param3Size; i++) {
3145
3187
  string _podObject___param3Item{};
3146
3188
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3147
3189
  const uint16_t _podObject___param3ItemPeekedLen__ = reader.PeekNumber<uint16_t>();
3148
3190
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _podObject___param3ItemPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3149
3191
  _podObject___param3Item = reader.Text();
3150
- _podObject__.param3.Value().push_back(std::move(_podObject___param3Item));
3192
+ _podObject___param3Object__.push_back(std::move(_podObject___param3Item));
3151
3193
  }
3194
+ _podObject__.param3 = std::move(_podObject___param3Object__);
3195
+ }
3196
+ else {
3197
+ _podObject__.param3 = Core::OptionalType<std::vector<string>>();
3152
3198
  }
3153
3199
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3154
3200
  if (reader.Boolean() == true) {
3201
+ std::vector<string> _podObject___param4Object__{};
3155
3202
  uint8_t _podObject___param4Size{};
3156
3203
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3157
3204
  _podObject___param4Size = reader.Number<uint8_t>();
3158
- _podObject__.param4.Value().reserve(_podObject___param4Size);
3205
+ _podObject___param4Object__.reserve(_podObject___param4Size);
3159
3206
  for (uint8_t i = 0; i < _podObject___param4Size; i++) {
3160
3207
  string _podObject___param4Item{};
3161
3208
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3162
3209
  const uint16_t _podObject___param4ItemPeekedLen__ = reader.PeekNumber<uint16_t>();
3163
3210
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _podObject___param4ItemPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3164
3211
  _podObject___param4Item = reader.Text();
3165
- _podObject__.param4.Value().push_back(std::move(_podObject___param4Item));
3212
+ _podObject___param4Object__.push_back(std::move(_podObject___param4Item));
3166
3213
  }
3214
+ _podObject__.param4 = std::move(_podObject___param4Object__);
3215
+ }
3216
+ else {
3217
+ _podObject__.param4 = Core::OptionalType<std::vector<string>>();
3167
3218
  }
3168
3219
  _pod = std::move(_podObject__);
3169
3220
  }
3221
+ else {
3222
+ _pod = Core::OptionalType<Example::ISimpleAsync::Record2>();
3223
+ }
3170
3224
  }
3171
3225
 
3172
3226
  return (hresult);
3173
3227
  } ();
3174
3228
  } else {
@@ -3196,37 +3250,47 @@
3196
3250
  if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3197
3251
  hresult = reader.Number<Core::hresult>();
3198
3252
  if ((hresult & COM_ERROR) == 0) {
3199
3253
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3200
3254
  if (reader.Boolean() == true) {
3255
+ std::vector<string> _pod_param3Object__{};
3201
3256
  uint8_t _pod_param3Size{};
3202
3257
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3203
3258
  _pod_param3Size = reader.Number<uint8_t>();
3204
- _pod.param3.Value().reserve(_pod_param3Size);
3259
+ _pod_param3Object__.reserve(_pod_param3Size);
3205
3260
  for (uint8_t i = 0; i < _pod_param3Size; i++) {
3206
3261
  string _pod_param3Item{};
3207
3262
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3208
3263
  const uint16_t _pod_param3ItemPeekedLen__ = reader.PeekNumber<uint16_t>();
3209
3264
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _pod_param3ItemPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3210
3265
  _pod_param3Item = reader.Text();
3211
- _pod.param3.Value().push_back(std::move(_pod_param3Item));
3266
+ _pod_param3Object__.push_back(std::move(_pod_param3Item));
3212
3267
  }
3268
+ _pod.param3 = std::move(_pod_param3Object__);
3269
+ }
3270
+ else {
3271
+ _pod.param3 = Core::OptionalType<std::vector<string>>();
3213
3272
  }
3214
3273
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3215
3274
  if (reader.Boolean() == true) {
3275
+ std::vector<string> _pod_param4Object__{};
3216
3276
  uint8_t _pod_param4Size{};
3217
3277
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3218
3278
  _pod_param4Size = reader.Number<uint8_t>();
3219
- _pod.param4.Value().reserve(_pod_param4Size);
3279
+ _pod_param4Object__.reserve(_pod_param4Size);
3220
3280
  for (uint8_t i = 0; i < _pod_param4Size; i++) {
3221
3281
  string _pod_param4Item{};
3222
3282
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3223
3283
  const uint16_t _pod_param4ItemPeekedLen__ = reader.PeekNumber<uint16_t>();
3224
3284
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _pod_param4ItemPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3225
3285
  _pod_param4Item = reader.Text();
3226
- _pod.param4.Value().push_back(std::move(_pod_param4Item));
3286
+ _pod_param4Object__.push_back(std::move(_pod_param4Item));
3227
3287
  }
3288
+ _pod.param4 = std::move(_pod_param4Object__);
3289
+ }
3290
+ else {
3291
+ _pod.param4 = Core::OptionalType<std::vector<string>>();
3228
3292
  }
3229
3293
  }
3230
3294
 
3231
3295
  return (hresult);
3232
3296
  } ();
@@ -3260,10 +3324,13 @@
3260
3324
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3261
3325
  const uint16_t _resultPeekedLen__ = reader.PeekNumber<uint16_t>();
3262
3326
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _resultPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
3263
3327
  _result = reader.Text();
3264
3328
  }
3329
+ else {
3330
+ _result = Core::OptionalType<string>();
3331
+ }
3265
3332
  }
3266
3333
 
3267
3334
  return (hresult);
3268
3335
  } ();
3269
3336
  } else {
Release/ThunderInterfaces/interfaces/generated/ProxyStubs_AudioStream.cpp CHANGED
@@ -840,10 +840,13 @@
840
840
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
841
841
  const uint16_t _profile_codecParamsPeekedLen__ = reader.PeekNumber<uint16_t>();
842
842
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _profile_codecParamsPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
843
843
  _profile.codecParams = reader.Text();
844
844
  }
845
+ else {
846
+ _profile.codecParams = Core::OptionalType<string>();
847
+ }
845
848
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
846
849
  _profile.channels = reader.Number<uint8_t>();
847
850
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
848
851
  _profile.resolution = reader.Number<uint8_t>();
849
852
  if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
@@ -851,10 +854,13 @@
851
854
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
852
855
  if (reader.Boolean() == true) {
853
856
  if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
854
857
  _profile.bitRate = reader.Number<uint32_t>();
855
858
  }
859
+ else {
860
+ _profile.bitRate = Core::OptionalType<uint32_t>();
861
+ }
856
862
  }
857
863
 
858
864
  return (hresult);
859
865
  } ();
860
866
  } else {
Release/ThunderInterfaces/interfaces/generated/ProxyStubs_BluetoothRemoteControl.cpp CHANGED
@@ -596,38 +596,53 @@
596
596
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
597
597
  const uint16_t _info_modelPeekedLen__ = reader.PeekNumber<uint16_t>();
598
598
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_modelPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
599
599
  _info.model = reader.Text();
600
600
  }
601
+ else {
602
+ _info.model = Core::OptionalType<string>();
603
+ }
601
604
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
602
605
  if (reader.Boolean() == true) {
603
606
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
604
607
  const uint16_t _info_serialPeekedLen__ = reader.PeekNumber<uint16_t>();
605
608
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_serialPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
606
609
  _info.serial = reader.Text();
607
610
  }
611
+ else {
612
+ _info.serial = Core::OptionalType<string>();
613
+ }
608
614
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
609
615
  if (reader.Boolean() == true) {
610
616
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
611
617
  const uint16_t _info_firmwarePeekedLen__ = reader.PeekNumber<uint16_t>();
612
618
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_firmwarePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
613
619
  _info.firmware = reader.Text();
614
620
  }
621
+ else {
622
+ _info.firmware = Core::OptionalType<string>();
623
+ }
615
624
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
616
625
  if (reader.Boolean() == true) {
617
626
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
618
627
  const uint16_t _info_softwarePeekedLen__ = reader.PeekNumber<uint16_t>();
619
628
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_softwarePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
620
629
  _info.software = reader.Text();
621
630
  }
631
+ else {
632
+ _info.software = Core::OptionalType<string>();
633
+ }
622
634
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
623
635
  if (reader.Boolean() == true) {
624
636
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
625
637
  const uint16_t _info_manufacturerPeekedLen__ = reader.PeekNumber<uint16_t>();
626
638
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_manufacturerPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
627
639
  _info.manufacturer = reader.Text();
628
640
  }
641
+ else {
642
+ _info.manufacturer = Core::OptionalType<string>();
643
+ }
629
644
  }
630
645
 
631
646
  return (hresult);
632
647
  } ();
633
648
  } else {
Release/ThunderInterfaces/interfaces/generated/ProxyStubs_DeviceIdentification.cpp CHANGED
@@ -112,17 +112,23 @@
112
112
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
113
113
  const uint16_t _info_firmwareVersionPeekedLen__ = reader.PeekNumber<uint16_t>();
114
114
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_firmwareVersionPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
115
115
  _info.firmwareVersion = reader.Text();
116
116
  }
117
+ else {
118
+ _info.firmwareVersion = Core::OptionalType<string>();
119
+ }
117
120
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
118
121
  if (reader.Boolean() == true) {
119
122
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
120
123
  const uint16_t _info_chipsetPeekedLen__ = reader.PeekNumber<uint16_t>();
121
124
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_chipsetPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
122
125
  _info.chipset = reader.Text();
123
126
  }
127
+ else {
128
+ _info.chipset = Core::OptionalType<string>();
129
+ }
124
130
  }
125
131
 
126
132
  return (hresult);
127
133
  } ();
128
134
  } else {
Release/ThunderInterfaces/interfaces/generated/ProxyStubs_LocationSync.cpp CHANGED
@@ -366,38 +366,53 @@
366
366
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
367
367
  const uint16_t _info_cityPeekedLen__ = reader.PeekNumber<uint16_t>();
368
368
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_cityPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
369
369
  _info.city = reader.Text();
370
370
  }
371
+ else {
372
+ _info.city = Core::OptionalType<string>();
373
+ }
371
374
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
372
375
  if (reader.Boolean() == true) {
373
376
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
374
377
  const uint16_t _info_countryPeekedLen__ = reader.PeekNumber<uint16_t>();
375
378
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_countryPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
376
379
  _info.country = reader.Text();
377
380
  }
381
+ else {
382
+ _info.country = Core::OptionalType<string>();
383
+ }
378
384
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
379
385
  if (reader.Boolean() == true) {
380
386
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
381
387
  const uint16_t _info_regionPeekedLen__ = reader.PeekNumber<uint16_t>();
382
388
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_regionPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
383
389
  _info.region = reader.Text();
384
390
  }
391
+ else {
392
+ _info.region = Core::OptionalType<string>();
393
+ }
385
394
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
386
395
  if (reader.Boolean() == true) {
387
396
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
388
397
  const uint16_t _info_timeZonePeekedLen__ = reader.PeekNumber<uint16_t>();
389
398
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_timeZonePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
390
399
  _info.timeZone = reader.Text();
391
400
  }
401
+ else {
402
+ _info.timeZone = Core::OptionalType<string>();
403
+ }
392
404
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
393
405
  if (reader.Boolean() == true) {
394
406
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
395
407
  const uint16_t _info_publicIPPeekedLen__ = reader.PeekNumber<uint16_t>();
396
408
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_publicIPPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
397
409
  _info.publicIP = reader.Text();
398
410
  }
411
+ else {
412
+ _info.publicIP = Core::OptionalType<string>();
413
+ }
399
414
  }
400
415
 
401
416
  return (hresult);
402
417
  } ();
403
418
  } else {
Release/ThunderInterfaces/interfaces/generated/ProxyStubs_TimeSync.cpp CHANGED
@@ -647,10 +647,13 @@
647
647
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
648
648
  const uint16_t _info_sourcePeekedLen__ = reader.PeekNumber<uint16_t>();
649
649
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_sourcePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
650
650
  _info.source = reader.Text();
651
651
  }
652
+ else {
653
+ _info.source = Core::OptionalType<string>();
654
+ }
652
655
  }
653
656
 
654
657
  return (hresult);
655
658
  } ();
656
659
  } else {
Release/ThunderInterfaces/interfaces/generated/ProxyStubs_ValuePoint.cpp CHANGED
@@ -1494,10 +1494,13 @@
1494
1494
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1495
1495
  const uint16_t _value_metadataPeekedLen__ = reader.PeekNumber<uint16_t>();
1496
1496
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _value_metadataPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1497
1497
  _value.metadata = reader.Text();
1498
1498
  }
1499
+ else {
1500
+ _value.metadata = Core::OptionalType<string>();
1501
+ }
1499
1502
  }
1500
1503
 
1501
1504
  return (hresult);
1502
1505
  } ();
1503
1506
  } else {
Release/ThunderInterfaces/interfaces/generated/ProxyStubs_WifiControl.cpp CHANGED
@@ -1217,10 +1217,13 @@
1217
1217
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1218
1218
  if (reader.Boolean() == true) {
1219
1219
  if (reader.Length() < (Core::RealSize<Exchange::IWifiControl::SecurityInfo::Key>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1220
1220
  _info.keys = reader.Number<Exchange::IWifiControl::SecurityInfo::Key>();
1221
1221
  }
1222
+ else {
1223
+ _info.keys = Core::OptionalType<Exchange::IWifiControl::SecurityInfo::Key>();
1224
+ }
1222
1225
 
1223
1226
  return (Core::ERROR_NONE);
1224
1227
  } ();
1225
1228
  } else {
1226
1229
  ASSERT((hresult & COM_ERROR) != 0);
@@ -1251,10 +1254,13 @@
1251
1254
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1252
1255
  if (reader.Boolean() == true) {
1253
1256
  if (reader.Length() < (Core::RealSize<Exchange::IWifiControl::SecurityInfo::Key>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1254
1257
  _info.keys = reader.Number<Exchange::IWifiControl::SecurityInfo::Key>();
1255
1258
  }
1259
+ else {
1260
+ _info.keys = Core::OptionalType<Exchange::IWifiControl::SecurityInfo::Key>();
1261
+ }
1256
1262
 
1257
1263
  return (Core::ERROR_NONE);
1258
1264
  } ();
1259
1265
  } else {
1260
1266
  ASSERT((hresult & COM_ERROR) != 0);
@@ -1360,10 +1366,13 @@
1360
1366
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1361
1367
  if (reader.Boolean() == true) {
1362
1368
  if (reader.Length() < (Core::RealSize<Exchange::IWifiControl::SecurityInfo::Key>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1363
1369
  result.keys = reader.Number<Exchange::IWifiControl::SecurityInfo::Key>();
1364
1370
  }
1371
+ else {
1372
+ result.keys = Core::OptionalType<Exchange::IWifiControl::SecurityInfo::Key>();
1373
+ }
1365
1374
 
1366
1375
  return (Core::ERROR_NONE);
1367
1376
  } ();
1368
1377
  } else {
1369
1378
  ASSERT((hresult & COM_ERROR) != 0);
@@ -1415,10 +1424,13 @@
1415
1424
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1416
1425
  const uint16_t _info_ssidPeekedLen__ = reader.PeekNumber<uint16_t>();
1417
1426
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_ssidPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1418
1427
  _info.ssid = reader.Text();
1419
1428
  }
1429
+ else {
1430
+ _info.ssid = Core::OptionalType<string>();
1431
+ }
1420
1432
  if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1421
1433
  _info.bssid = reader.Number<uint64_t>();
1422
1434
  if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1423
1435
  _info.frequency = reader.Number<uint32_t>();
1424
1436
  if (reader.Length() < (Core::RealSize<int32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
@@ -1457,10 +1469,13 @@
1457
1469
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1458
1470
  const uint16_t _info_ssidPeekedLen__ = reader.PeekNumber<uint16_t>();
1459
1471
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_ssidPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1460
1472
  _info.ssid = reader.Text();
1461
1473
  }
1474
+ else {
1475
+ _info.ssid = Core::OptionalType<string>();
1476
+ }
1462
1477
  if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1463
1478
  _info.bssid = reader.Number<uint64_t>();
1464
1479
  if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1465
1480
  _info.frequency = reader.Number<uint32_t>();
1466
1481
  if (reader.Length() < (Core::RealSize<int32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
@@ -1574,10 +1589,13 @@
1574
1589
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1575
1590
  const uint16_t result_ssidPeekedLen__ = reader.PeekNumber<uint16_t>();
1576
1591
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + result_ssidPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1577
1592
  result.ssid = reader.Text();
1578
1593
  }
1594
+ else {
1595
+ result.ssid = Core::OptionalType<string>();
1596
+ }
1579
1597
  if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1580
1598
  result.bssid = reader.Number<uint64_t>();
1581
1599
  if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1582
1600
  result.frequency = reader.Number<uint32_t>();
1583
1601
  if (reader.Length() < (Core::RealSize<int32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
@@ -1992,31 +2010,43 @@
1992
2010
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1993
2011
  const uint16_t _configInfo_ssidPeekedLen__ = reader.PeekNumber<uint16_t>();
1994
2012
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _configInfo_ssidPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1995
2013
  _configInfo.ssid = reader.Text();
1996
2014
  }
2015
+ else {
2016
+ _configInfo.ssid = Core::OptionalType<string>();
2017
+ }
1997
2018
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1998
2019
  if (reader.Boolean() == true) {
1999
2020
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2000
2021
  const uint16_t _configInfo_secretPeekedLen__ = reader.PeekNumber<uint16_t>();
2001
2022
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _configInfo_secretPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2002
2023
  _configInfo.secret = reader.Text();
2003
2024
  }
2025
+ else {
2026
+ _configInfo.secret = Core::OptionalType<string>();
2027
+ }
2004
2028
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2005
2029
  if (reader.Boolean() == true) {
2006
2030
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2007
2031
  const uint16_t _configInfo_identityPeekedLen__ = reader.PeekNumber<uint16_t>();
2008
2032
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _configInfo_identityPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2009
2033
  _configInfo.identity = reader.Text();
2010
2034
  }
2035
+ else {
2036
+ _configInfo.identity = Core::OptionalType<string>();
2037
+ }
2011
2038
  if (reader.Length() < (Core::RealSize<Exchange::IWifiControl::Security>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2012
2039
  _configInfo.method = reader.Number<Exchange::IWifiControl::Security>();
2013
2040
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2014
2041
  if (reader.Boolean() == true) {
2015
2042
  if (reader.Length() < (Core::RealSize<Exchange::IWifiControl::SecurityInfo::Key>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
2016
2043
  _configInfo.key = reader.Number<Exchange::IWifiControl::SecurityInfo::Key>();
2017
2044
  }
2045
+ else {
2046
+ _configInfo.key = Core::OptionalType<Exchange::IWifiControl::SecurityInfo::Key>();
2047
+ }
2018
2048
  }
2019
2049
 
2020
2050
  return (hresult);
2021
2051
  } ();
2022
2052
  } else {
Release/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_Benchmark.cpp CHANGED
@@ -687,10 +687,13 @@
687
687
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
688
688
  if (reader.Boolean() == true) {
689
689
  if (reader.Length() < (Core::RealSize<QualityAssurance::IBenchmark::FailureReason>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
690
690
  _info.failureReason = reader.Number<QualityAssurance::IBenchmark::FailureReason>();
691
691
  }
692
+ else {
693
+ _info.failureReason = Core::OptionalType<QualityAssurance::IBenchmark::FailureReason>();
694
+ }
692
695
 
693
696
  return (Core::ERROR_NONE);
694
697
  } ();
695
698
  } else {
696
699
  ASSERT((hresult & COM_ERROR) != 0);
@@ -743,10 +746,13 @@
743
746
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
744
747
  if (reader.Boolean() == true) {
745
748
  if (reader.Length() < (Core::RealSize<QualityAssurance::IBenchmark::FailureReason>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
746
749
  _info.failureReason = reader.Number<QualityAssurance::IBenchmark::FailureReason>();
747
750
  }
751
+ else {
752
+ _info.failureReason = Core::OptionalType<QualityAssurance::IBenchmark::FailureReason>();
753
+ }
748
754
 
749
755
  return (Core::ERROR_NONE);
750
756
  } ();
751
757
  } else {
752
758
  ASSERT((hresult & COM_ERROR) != 0);
@@ -874,10 +880,13 @@
874
880
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
875
881
  if (reader.Boolean() == true) {
876
882
  if (reader.Length() < (Core::RealSize<QualityAssurance::IBenchmark::FailureReason>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
877
883
  result.failureReason = reader.Number<QualityAssurance::IBenchmark::FailureReason>();
878
884
  }
885
+ else {
886
+ result.failureReason = Core::OptionalType<QualityAssurance::IBenchmark::FailureReason>();
887
+ }
879
888
 
880
889
  return (Core::ERROR_NONE);
881
890
  } ();
882
891
  } else {
883
892
  ASSERT((hresult & COM_ERROR) != 0);
Release/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_BenchmarkPayload.cpp CHANGED
@@ -1903,10 +1903,11 @@
1903
1903
  hresult = reader.Number<Core::hresult>();
1904
1904
  if ((hresult & COM_ERROR) == 0) {
1905
1905
  uint16_t _outputSize{};
1906
1906
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1907
1907
  _outputSize = reader.Number<uint16_t>();
1908
+ _output.clear();
1908
1909
  _output.reserve(_outputSize);
1909
1910
  for (uint16_t i = 0; i < _outputSize; i++) {
1910
1911
  uint32_t _outputItem{};
1911
1912
  if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1912
1913
  _outputItem = reader.Number<uint32_t>();