[Chore] Convert chip::Optional to std::optional for dnssd/types.h (#33179)

andy31415 · andreilitvin · pull[bot] · commit 6004917a5c75 · 2024-04-30T02:00:42.000Z
* Replace some chip Optional with std::optional

* Restyle

* a few more updates

* Also fix RemoteDataLogger.cpp

* Code review feedback: added some bracketing

* Re-do the bracketing

* Fix some of the unchecked optional access warnings

* Also fix TestIncrementalResolve

* Fix Commissionable script binding

* Fix more files

* Restyle

---------

Co-authored-by: Andrei Litvin &lt;andreilitvin@google.com&gt;
diff --git a/examples/chip-tool/commands/common/RemoteDataModelLogger.cpp b/examples/chip-tool/commands/common/RemoteDataModelLogger.cpp
@@ -245,24 +245,24 @@ CHIP_ERROR LogDiscoveredNodeData(const chip::Dnssd::CommissionNodeData & nodeDat
     value["port"]               = resolutionData.port;
     value["numIPs"]             = static_cast<uint8_t>(resolutionData.numIPs);
 
-    if (resolutionData.mrpRetryIntervalIdle.HasValue())
+    if (resolutionData.mrpRetryIntervalIdle.has_value())
     {
-        value["mrpRetryIntervalIdle"] = resolutionData.mrpRetryIntervalIdle.Value().count();
+        value["mrpRetryIntervalIdle"] = resolutionData.mrpRetryIntervalIdle->count();
     }
 
-    if (resolutionData.mrpRetryIntervalActive.HasValue())
+    if (resolutionData.mrpRetryIntervalActive.has_value())
     {
-        value["mrpRetryIntervalActive"] = resolutionData.mrpRetryIntervalActive.Value().count();
+        value["mrpRetryIntervalActive"] = resolutionData.mrpRetryIntervalActive->count();
     }
 
-    if (resolutionData.mrpRetryActiveThreshold.HasValue())
+    if (resolutionData.mrpRetryActiveThreshold.has_value())
     {
-        value["mrpRetryActiveThreshold"] = resolutionData.mrpRetryActiveThreshold.Value().count();
+        value["mrpRetryActiveThreshold"] = resolutionData.mrpRetryActiveThreshold->count();
     }
 
-    if (resolutionData.isICDOperatingAsLIT.HasValue())
+    if (resolutionData.isICDOperatingAsLIT.has_value())
     {
-        value["isICDOperatingAsLIT"] = resolutionData.isICDOperatingAsLIT.Value();
+        value["isICDOperatingAsLIT"] = *(resolutionData.isICDOperatingAsLIT);
     }
 
     Json::Value rootValue;
diff --git a/src/controller/SetUpCodePairer.cpp b/src/controller/SetUpCodePairer.cpp
@@ -620,14 +620,14 @@ SetUpCodePairerParameters::SetUpCodePairerParameters(const Dnssd::CommonResoluti
     auto & ip = data.ipAddress[index];
     SetPeerAddress(Transport::PeerAddress::UDP(ip, data.port, ip.IsIPv6LinkLocal() ? data.interfaceId : Inet::InterfaceId::Null()));
 
-    if (data.mrpRetryIntervalIdle.HasValue())
+    if (data.mrpRetryIntervalIdle.has_value())
     {
-        SetIdleInterval(data.mrpRetryIntervalIdle.Value());
+        SetIdleInterval(*data.mrpRetryIntervalIdle);
     }
 
-    if (data.mrpRetryIntervalActive.HasValue())
+    if (data.mrpRetryIntervalActive.has_value())
     {
-        SetActiveInterval(data.mrpRetryIntervalActive.Value());
+        SetActiveInterval(*data.mrpRetryIntervalActive);
     }
 }
 
diff --git a/src/controller/python/ChipCommissionableNodeController-ScriptBinding.cpp b/src/controller/python/ChipCommissionableNodeController-ScriptBinding.cpp
@@ -97,27 +97,31 @@ void pychip_CommissionableNodeController_PrintDiscoveredCommissioners(
         ChipLogProgress(Discovery, "\tRotating Id\t\t%s", rotatingId);
         ChipLogProgress(Discovery, "\tPairing Instruction\t%s", dnsSdInfo->pairingInstruction);
         ChipLogProgress(Discovery, "\tPairing Hint\t\t%u", dnsSdInfo->pairingHint);
-        if (dnsSdInfo->GetMrpRetryIntervalIdle().HasValue())
+
+        auto idleInterval = dnsSdInfo->GetMrpRetryIntervalIdle();
+        if (idleInterval.has_value())
         {
-            ChipLogProgress(Discovery, "\tMrp Interval idle\t%u", dnsSdInfo->GetMrpRetryIntervalIdle().Value().count());
+            ChipLogProgress(Discovery, "\tMrp Interval idle\t%u", idleInterval->count());
         }
         else
         {
             ChipLogProgress(Discovery, "\tMrp Interval idle\tNot present");
         }
-        if (dnsSdInfo->GetMrpRetryIntervalActive().HasValue())
+
+        auto activeInterval = dnsSdInfo->GetMrpRetryIntervalIdle();
+        if (activeInterval.has_value())
         {
-            ChipLogProgress(Discovery, "\tMrp Interval active\t%u", dnsSdInfo->GetMrpRetryIntervalActive().Value().count());
+            ChipLogProgress(Discovery, "\tMrp Interval active\t%u", activeInterval->count());
         }
         else
         {
             ChipLogProgress(Discovery, "\tMrp Interval active\tNot present");
         }
         ChipLogProgress(Discovery, "\tSupports TCP\t\t%d", dnsSdInfo->supportsTcp);
 
-        if (dnsSdInfo->isICDOperatingAsLIT.HasValue())
+        if (dnsSdInfo->isICDOperatingAsLIT.has_value())
         {
-            ChipLogProgress(Discovery, "\tICD is operating as a\t%s", dnsSdInfo->isICDOperatingAsLIT.Value() ? "LIT" : "SIT");
+            ChipLogProgress(Discovery, "\tICD is operating as a\t%s", *(dnsSdInfo->isICDOperatingAsLIT) ? "LIT" : "SIT");
         }
 
         for (unsigned j = 0; j < dnsSdInfo->numIPs; ++j)
diff --git a/src/controller/python/ChipDeviceController-Discovery.cpp b/src/controller/python/ChipDeviceController-Discovery.cpp
@@ -124,17 +124,23 @@ void pychip_DeviceController_IterateDiscoveredCommissionableNodes(Controller::De
         jsonVal["deviceName"]         = dnsSdInfo->deviceName;
         jsonVal["pairingInstruction"] = dnsSdInfo->pairingInstruction;
         jsonVal["pairingHint"]        = dnsSdInfo->pairingHint;
-        if (dnsSdInfo->GetMrpRetryIntervalIdle().HasValue())
+
+        auto idleInterval = dnsSdInfo->GetMrpRetryIntervalIdle();
+        if (idleInterval.has_value())
         {
-            jsonVal["mrpRetryIntervalIdle"] = dnsSdInfo->GetMrpRetryIntervalIdle().Value().count();
+            jsonVal["mrpRetryIntervalIdle"] = idleInterval->count();
         }
-        if (dnsSdInfo->GetMrpRetryIntervalActive().HasValue())
+
+        auto activeInterval = dnsSdInfo->GetMrpRetryIntervalActive();
+        if (activeInterval.has_value())
         {
-            jsonVal["mrpRetryIntervalActive"] = dnsSdInfo->GetMrpRetryIntervalActive().Value().count();
+            jsonVal["mrpRetryIntervalActive"] = activeInterval->count();
         }
-        if (dnsSdInfo->GetMrpRetryActiveThreshold().HasValue())
+
+        auto activeThreshold = dnsSdInfo->GetMrpRetryActiveThreshold();
+        if (activeThreshold.has_value())
         {
-            jsonVal["mrpRetryActiveThreshold"] = dnsSdInfo->GetMrpRetryActiveThreshold().Value().count();
+            jsonVal["mrpRetryActiveThreshold"] = activeThreshold->count();
         }
         jsonVal["supportsTcp"] = dnsSdInfo->supportsTcp;
         {
@@ -147,9 +153,9 @@ void pychip_DeviceController_IterateDiscoveredCommissionableNodes(Controller::De
             }
             jsonVal["addresses"] = addresses;
         }
-        if (dnsSdInfo->isICDOperatingAsLIT.HasValue())
+        if (dnsSdInfo->isICDOperatingAsLIT.has_value())
         {
-            jsonVal["isICDOperatingAsLIT"] = dnsSdInfo->isICDOperatingAsLIT.Value();
+            jsonVal["isICDOperatingAsLIT"] = *(dnsSdInfo->isICDOperatingAsLIT);
         }
         if (dnsSdInfo->rotatingIdLen > 0)
         {
@@ -188,26 +194,31 @@ void pychip_DeviceController_PrintDiscoveredDevices(Controller::DeviceCommission
         ChipLogProgress(Discovery, "\tRotating Id\t\t%s", rotatingId);
         ChipLogProgress(Discovery, "\tPairing Instruction\t%s", dnsSdInfo->pairingInstruction);
         ChipLogProgress(Discovery, "\tPairing Hint\t\t%u", dnsSdInfo->pairingHint);
-        if (dnsSdInfo->GetMrpRetryIntervalIdle().HasValue())
+
+        auto idleInterval = dnsSdInfo->GetMrpRetryIntervalIdle();
+        if (idleInterval.has_value())
         {
-            ChipLogProgress(Discovery, "\tMrp Interval idle\t%u", dnsSdInfo->GetMrpRetryIntervalIdle().Value().count());
+            ChipLogProgress(Discovery, "\tMrp Interval idle\t%u", idleInterval->count());
         }
         else
         {
             ChipLogProgress(Discovery, "\tMrp Interval idle\tNot present");
         }
-        if (dnsSdInfo->GetMrpRetryIntervalActive().HasValue())
+
+        auto activeInterval = dnsSdInfo->GetMrpRetryIntervalActive();
+        if (activeInterval.has_value())
         {
-            ChipLogProgress(Discovery, "\tMrp Interval active\t%u", dnsSdInfo->GetMrpRetryIntervalActive().Value().count());
+            ChipLogProgress(Discovery, "\tMrp Interval active\t%u", activeInterval->count());
         }
         else
         {
             ChipLogProgress(Discovery, "\tMrp Interval active\tNot present");
         }
+
         ChipLogProgress(Discovery, "\tSupports TCP\t\t%d", dnsSdInfo->supportsTcp);
-        if (dnsSdInfo->isICDOperatingAsLIT.HasValue())
+        if (dnsSdInfo->isICDOperatingAsLIT.has_value())
         {
-            ChipLogProgress(Discovery, "\tICD is operating as a\t%s", dnsSdInfo->isICDOperatingAsLIT.Value() ? "LIT" : "SIT");
+            ChipLogProgress(Discovery, "\tICD is operating as a\t%s", *(dnsSdInfo->isICDOperatingAsLIT) ? "LIT" : "SIT");
         }
         for (unsigned j = 0; j < dnsSdInfo->numIPs; ++j)
         {
diff --git a/src/lib/address_resolve/AddressResolve_DefaultImpl.cpp b/src/lib/address_resolve/AddressResolve_DefaultImpl.cpp
@@ -290,9 +290,9 @@ void Resolver::OnOperationalNodeResolved(const Dnssd::ResolvedNodeData & nodeDat
         result.mrpRemoteConfig = nodeData.resolutionData.GetRemoteMRPConfig();
         result.supportsTcp     = nodeData.resolutionData.supportsTcp;
 
-        if (nodeData.resolutionData.isICDOperatingAsLIT.HasValue())
+        if (nodeData.resolutionData.isICDOperatingAsLIT.has_value())
         {
-            result.isICDOperatingAsLIT = nodeData.resolutionData.isICDOperatingAsLIT.Value();
+            result.isICDOperatingAsLIT = *(nodeData.resolutionData.isICDOperatingAsLIT);
         }
 
         for (size_t i = 0; i < nodeData.resolutionData.numIPs; i++)
diff --git a/src/lib/dnssd/TxtFields.cpp b/src/lib/dnssd/TxtFields.cpp
@@ -105,14 +105,14 @@ bool MakeBoolFromAsciiDecimal(const ByteSpan & val)
     return val.size() == 1 && static_cast<char>(*val.data()) == '1';
 }
 
-Optional<bool> MakeOptionalBoolFromAsciiDecimal(const ByteSpan & val)
+std::optional<bool> MakeOptionalBoolFromAsciiDecimal(const ByteSpan & val)
 {
     char character = static_cast<char>(*val.data());
     if (val.size() == 1 && ((character == '1') || (character == '0')))
     {
-        return MakeOptional(character == '1');
+        return std::make_optional(character == '1');
     }
-    return NullOptional;
+    return std::nullopt;
 }
 
 size_t GetPlusSignIdx(const ByteSpan & value)
@@ -188,27 +188,27 @@ uint8_t GetCommissionerPasscode(const ByteSpan & value)
     return MakeBoolFromAsciiDecimal(value);
 }
 
-Optional<System::Clock::Milliseconds32> GetRetryInterval(const ByteSpan & value)
+std::optional<System::Clock::Milliseconds32> GetRetryInterval(const ByteSpan & value)
 {
     const auto undefined     = std::numeric_limits<uint32_t>::max();
     const auto retryInterval = MakeU32FromAsciiDecimal(value, undefined);
 
     if (retryInterval != undefined && retryInterval <= kMaxRetryInterval.count())
-        return MakeOptional(System::Clock::Milliseconds32(retryInterval));
+        return std::make_optional(System::Clock::Milliseconds32(retryInterval));
 
-    return NullOptional;
+    return std::nullopt;
 }
 
-Optional<System::Clock::Milliseconds16> GetRetryActiveThreshold(const ByteSpan & value)
+std::optional<System::Clock::Milliseconds16> GetRetryActiveThreshold(const ByteSpan & value)
 {
     const auto retryInterval = MakeU16FromAsciiDecimal(value);
 
     if (retryInterval == 0)
     {
-        return NullOptional;
+        return std::nullopt;
     }
 
-    return MakeOptional(System::Clock::Milliseconds16(retryInterval));
+    return std::make_optional(System::Clock::Milliseconds16(retryInterval));
 }
 
 TxtFieldKey GetTxtFieldKey(const ByteSpan & key)
diff --git a/src/lib/dnssd/Types.h b/src/lib/dnssd/Types.h
@@ -19,10 +19,10 @@
 
 #include <cstdint>
 #include <cstring>
+#include <optional>
 
 #include <inet/InetInterface.h>
 #include <lib/core/CHIPError.h>
-#include <lib/core/Optional.h>
 #include <lib/core/PeerId.h>
 #include <lib/dnssd/Constants.h>
 #include <lib/support/BytesToHex.h>
@@ -91,10 +91,10 @@ struct CommonResolutionData
     uint16_t port                         = 0;
     char hostName[kHostNameMaxLength + 1] = {};
     bool supportsTcp                      = false;
-    Optional<bool> isICDOperatingAsLIT;
-    Optional<System::Clock::Milliseconds32> mrpRetryIntervalIdle;
-    Optional<System::Clock::Milliseconds32> mrpRetryIntervalActive;
-    Optional<System::Clock::Milliseconds16> mrpRetryActiveThreshold;
+    std::optional<bool> isICDOperatingAsLIT;
+    std::optional<System::Clock::Milliseconds32> mrpRetryIntervalIdle;
+    std::optional<System::Clock::Milliseconds32> mrpRetryIntervalActive;
+    std::optional<System::Clock::Milliseconds16> mrpRetryActiveThreshold;
 
     CommonResolutionData() { Reset(); }
 
@@ -103,32 +103,32 @@ struct CommonResolutionData
     ReliableMessageProtocolConfig GetRemoteMRPConfig() const
     {
         const ReliableMessageProtocolConfig defaultConfig = GetDefaultMRPConfig();
-        return ReliableMessageProtocolConfig(GetMrpRetryIntervalIdle().ValueOr(defaultConfig.mIdleRetransTimeout),
-                                             GetMrpRetryIntervalActive().ValueOr(defaultConfig.mActiveRetransTimeout),
-                                             GetMrpRetryActiveThreshold().ValueOr(defaultConfig.mActiveThresholdTime));
+        return ReliableMessageProtocolConfig(GetMrpRetryIntervalIdle().value_or(defaultConfig.mIdleRetransTimeout),
+                                             GetMrpRetryIntervalActive().value_or(defaultConfig.mActiveRetransTimeout),
+                                             GetMrpRetryActiveThreshold().value_or(defaultConfig.mActiveThresholdTime));
     }
-    Optional<System::Clock::Milliseconds32> GetMrpRetryIntervalIdle() const { return mrpRetryIntervalIdle; }
-    Optional<System::Clock::Milliseconds32> GetMrpRetryIntervalActive() const { return mrpRetryIntervalActive; }
-    Optional<System::Clock::Milliseconds16> GetMrpRetryActiveThreshold() const { return mrpRetryActiveThreshold; }
+    std::optional<System::Clock::Milliseconds32> GetMrpRetryIntervalIdle() const { return mrpRetryIntervalIdle; }
+    std::optional<System::Clock::Milliseconds32> GetMrpRetryIntervalActive() const { return mrpRetryIntervalActive; }
+    std::optional<System::Clock::Milliseconds16> GetMrpRetryActiveThreshold() const { return mrpRetryActiveThreshold; }
 
     bool IsDeviceTreatedAsSleepy(const ReliableMessageProtocolConfig * defaultMRPConfig) const
     {
         // If either session interval (Idle - SII, Active - SAI) has a value and that value is greater
         // than the value passed to this function, then the peer device will be treated as if it is
         // a Sleepy End Device (SED)
-        return (mrpRetryIntervalIdle.HasValue() && (mrpRetryIntervalIdle.Value() > defaultMRPConfig->mIdleRetransTimeout)) ||
-            (mrpRetryIntervalActive.HasValue() && (mrpRetryIntervalActive.Value() > defaultMRPConfig->mActiveRetransTimeout));
+        return (mrpRetryIntervalIdle.has_value() && (*mrpRetryIntervalIdle > defaultMRPConfig->mIdleRetransTimeout)) ||
+            (mrpRetryIntervalActive.has_value() && (*mrpRetryIntervalActive > defaultMRPConfig->mActiveRetransTimeout));
     }
 
     bool IsHost(const char * host) const { return strcmp(host, hostName) == 0; }
 
     void Reset()
     {
         memset(hostName, 0, sizeof(hostName));
-        mrpRetryIntervalIdle    = NullOptional;
-        mrpRetryIntervalActive  = NullOptional;
-        mrpRetryActiveThreshold = NullOptional;
-        isICDOperatingAsLIT     = NullOptional;
+        mrpRetryIntervalIdle    = std::nullopt;
+        mrpRetryIntervalActive  = std::nullopt;
+        mrpRetryActiveThreshold = std::nullopt;
+        isICDOperatingAsLIT     = std::nullopt;
         numIPs                  = 0;
         port                    = 0;
         supportsTcp             = false;
@@ -157,34 +157,34 @@ struct CommonResolutionData
         {
             ChipLogDetail(Discovery, "\tPort: %u", port);
         }
-        if (mrpRetryIntervalIdle.HasValue())
+        if (mrpRetryIntervalIdle.has_value())
         {
-            ChipLogDetail(Discovery, "\tMrp Interval idle: %" PRIu32 " ms", mrpRetryIntervalIdle.Value().count());
+            ChipLogDetail(Discovery, "\tMrp Interval idle: %" PRIu32 " ms", mrpRetryIntervalIdle->count());
         }
         else
         {
             ChipLogDetail(Discovery, "\tMrp Interval idle: not present");
         }
-        if (mrpRetryIntervalActive.HasValue())
+        if (mrpRetryIntervalActive.has_value())
         {
-            ChipLogDetail(Discovery, "\tMrp Interval active: %" PRIu32 " ms", mrpRetryIntervalActive.Value().count());
+            ChipLogDetail(Discovery, "\tMrp Interval active: %" PRIu32 " ms", mrpRetryIntervalActive->count());
         }
         else
         {
             ChipLogDetail(Discovery, "\tMrp Interval active: not present");
         }
-        if (mrpRetryActiveThreshold.HasValue())
+        if (mrpRetryActiveThreshold.has_value())
         {
-            ChipLogDetail(Discovery, "\tMrp Active Threshold: %u ms", mrpRetryActiveThreshold.Value().count());
+            ChipLogDetail(Discovery, "\tMrp Active Threshold: %u ms", mrpRetryActiveThreshold->count());
         }
         else
         {
             ChipLogDetail(Discovery, "\tMrp Active Threshold: not present");
         }
         ChipLogDetail(Discovery, "\tTCP Supported: %d", supportsTcp);
-        if (isICDOperatingAsLIT.HasValue())
+        if (isICDOperatingAsLIT.has_value())
         {
-            ChipLogDetail(Discovery, "\tThe ICD operates in %s", isICDOperatingAsLIT.Value() ? "LIT" : "SIT");
+            ChipLogDetail(Discovery, "\tThe ICD operates in %s", *isICDOperatingAsLIT ? "LIT" : "SIT");
         }
         else
         {
diff --git a/src/lib/dnssd/tests/TestIncrementalResolve.cpp b/src/lib/dnssd/tests/TestIncrementalResolve.cpp
@@ -307,9 +307,8 @@ TEST(TestIncrementalResolve, TestParseOperational)
     EXPECT_EQ(nodeData.resolutionData.numIPs, 1u);
     EXPECT_EQ(nodeData.resolutionData.port, 0x1234);
     EXPECT_FALSE(nodeData.resolutionData.supportsTcp);
-    EXPECT_FALSE(nodeData.resolutionData.GetMrpRetryIntervalActive().HasValue());
-    EXPECT_TRUE(nodeData.resolutionData.GetMrpRetryIntervalIdle().HasValue());
-    EXPECT_EQ(nodeData.resolutionData.GetMrpRetryIntervalIdle().Value(), chip::System::Clock::Milliseconds32(23));
+    EXPECT_FALSE(nodeData.resolutionData.GetMrpRetryIntervalActive().has_value());
+    EXPECT_EQ(nodeData.resolutionData.GetMrpRetryIntervalIdle(), std::make_optional(chip::System::Clock::Milliseconds32(23)));
 
     Inet::IPAddress addr;
     EXPECT_TRUE(Inet::IPAddress::FromString("fe80::abcd:ef11:2233:4455", addr));
@@ -396,9 +395,8 @@ TEST(TestIncrementalResolve, TestParseCommissionable)
     EXPECT_EQ(nodeData.numIPs, 2u);
     EXPECT_EQ(nodeData.port, 0x1234);
     EXPECT_FALSE(nodeData.supportsTcp);
-    EXPECT_TRUE(nodeData.GetMrpRetryIntervalActive().HasValue());
-    EXPECT_EQ(nodeData.GetMrpRetryIntervalActive().Value(), chip::System::Clock::Milliseconds32(321));
-    EXPECT_FALSE(nodeData.GetMrpRetryIntervalIdle().HasValue());
+    EXPECT_EQ(nodeData.GetMrpRetryIntervalActive(), std::make_optional(chip::System::Clock::Milliseconds32(321)));
+    EXPECT_FALSE(nodeData.GetMrpRetryIntervalIdle().has_value());
 
     Inet::IPAddress addr;
     EXPECT_TRUE(Inet::IPAddress::FromString("fe80::abcd:ef11:2233:4455", addr));
diff --git a/src/lib/dnssd/tests/TestTxtFields.cpp b/src/lib/dnssd/tests/TestTxtFields.cpp
diff --git a/src/lib/shell/commands/Dns.cpp b/src/lib/shell/commands/Dns.cpp

Original file line number	Diff line number	Diff line change
`@@ -245,24 +245,24 @@ CHIP_ERROR LogDiscoveredNodeData(const chip::Dnssd::CommissionNodeData & nodeDat`
`245`	`245`	`value["port"] = resolutionData.port;`
`246`	`246`	`value["numIPs"] = static_cast<uint8_t>(resolutionData.numIPs);`
`247`	`247`
`248`		`- if (resolutionData.mrpRetryIntervalIdle.HasValue())`
	`248`	`+ if (resolutionData.mrpRetryIntervalIdle.has_value())`
`249`	`249`	`{`
`250`		`- value["mrpRetryIntervalIdle"] = resolutionData.mrpRetryIntervalIdle.Value().count();`
	`250`	`+ value["mrpRetryIntervalIdle"] = resolutionData.mrpRetryIntervalIdle->count();`
`251`	`251`	`}`
`252`	`252`
`253`		`- if (resolutionData.mrpRetryIntervalActive.HasValue())`
	`253`	`+ if (resolutionData.mrpRetryIntervalActive.has_value())`
`254`	`254`	`{`
`255`		`- value["mrpRetryIntervalActive"] = resolutionData.mrpRetryIntervalActive.Value().count();`
	`255`	`+ value["mrpRetryIntervalActive"] = resolutionData.mrpRetryIntervalActive->count();`
`256`	`256`	`}`
`257`	`257`
`258`		`- if (resolutionData.mrpRetryActiveThreshold.HasValue())`
	`258`	`+ if (resolutionData.mrpRetryActiveThreshold.has_value())`
`259`	`259`	`{`
`260`		`- value["mrpRetryActiveThreshold"] = resolutionData.mrpRetryActiveThreshold.Value().count();`
	`260`	`+ value["mrpRetryActiveThreshold"] = resolutionData.mrpRetryActiveThreshold->count();`
`261`	`261`	`}`
`262`	`262`
`263`		`- if (resolutionData.isICDOperatingAsLIT.HasValue())`
	`263`	`+ if (resolutionData.isICDOperatingAsLIT.has_value())`
`264`	`264`	`{`
`265`		`- value["isICDOperatingAsLIT"] = resolutionData.isICDOperatingAsLIT.Value();`
	`265`	`+ value["isICDOperatingAsLIT"] = *(resolutionData.isICDOperatingAsLIT);`
`266`	`266`	`}`
`267`	`267`
`268`	`268`	`Json::Value rootValue;`
Original file line number	Diff line number	Diff line change
`@@ -620,14 +620,14 @@ SetUpCodePairerParameters::SetUpCodePairerParameters(const Dnssd::CommonResoluti`
`620`	`620`	`auto & ip = data.ipAddress[index];`
`621`	`621`	`SetPeerAddress(Transport::PeerAddress::UDP(ip, data.port, ip.IsIPv6LinkLocal() ? data.interfaceId : Inet::InterfaceId::Null()));`
`622`	`622`
`623`		`- if (data.mrpRetryIntervalIdle.HasValue())`
	`623`	`+ if (data.mrpRetryIntervalIdle.has_value())`
`624`	`624`	`{`
`625`		`- SetIdleInterval(data.mrpRetryIntervalIdle.Value());`
	`625`	`+ SetIdleInterval(*data.mrpRetryIntervalIdle);`
`626`	`626`	`}`
`627`	`627`
`628`		`- if (data.mrpRetryIntervalActive.HasValue())`
	`628`	`+ if (data.mrpRetryIntervalActive.has_value())`
`629`	`629`	`{`
`630`		`- SetActiveInterval(data.mrpRetryIntervalActive.Value());`
	`630`	`+ SetActiveInterval(*data.mrpRetryIntervalActive);`
`631`	`631`	`}`
`632`	`632`	`}`
`633`	`633`
Original file line number	Diff line number	Diff line change
`@@ -97,27 +97,31 @@ void pychip_CommissionableNodeController_PrintDiscoveredCommissioners(`
`97`	`97`	`ChipLogProgress(Discovery, "\tRotating Id\t\t%s", rotatingId);`
`98`	`98`	`ChipLogProgress(Discovery, "\tPairing Instruction\t%s", dnsSdInfo->pairingInstruction);`
`99`	`99`	`ChipLogProgress(Discovery, "\tPairing Hint\t\t%u", dnsSdInfo->pairingHint);`
`100`		`- if (dnsSdInfo->GetMrpRetryIntervalIdle().HasValue())`
	`100`	`+`
	`101`	`+ auto idleInterval = dnsSdInfo->GetMrpRetryIntervalIdle();`
	`102`	`+ if (idleInterval.has_value())`
`101`	`103`	`{`
`102`		`- ChipLogProgress(Discovery, "\tMrp Interval idle\t%u", dnsSdInfo->GetMrpRetryIntervalIdle().Value().count());`
	`104`	`+ ChipLogProgress(Discovery, "\tMrp Interval idle\t%u", idleInterval->count());`
`103`	`105`	`}`
`104`	`106`	`else`
`105`	`107`	`{`
`106`	`108`	`ChipLogProgress(Discovery, "\tMrp Interval idle\tNot present");`
`107`	`109`	`}`
`108`		`- if (dnsSdInfo->GetMrpRetryIntervalActive().HasValue())`
	`110`	`+`
	`111`	`+ auto activeInterval = dnsSdInfo->GetMrpRetryIntervalIdle();`
	`112`	`+ if (activeInterval.has_value())`
`109`	`113`	`{`
`110`		`- ChipLogProgress(Discovery, "\tMrp Interval active\t%u", dnsSdInfo->GetMrpRetryIntervalActive().Value().count());`
	`114`	`+ ChipLogProgress(Discovery, "\tMrp Interval active\t%u", activeInterval->count());`
`111`	`115`	`}`
`112`	`116`	`else`
`113`	`117`	`{`
`114`	`118`	`ChipLogProgress(Discovery, "\tMrp Interval active\tNot present");`
`115`	`119`	`}`
`116`	`120`	`ChipLogProgress(Discovery, "\tSupports TCP\t\t%d", dnsSdInfo->supportsTcp);`
`117`	`121`
`118`		`- if (dnsSdInfo->isICDOperatingAsLIT.HasValue())`
	`122`	`+ if (dnsSdInfo->isICDOperatingAsLIT.has_value())`
`119`	`123`	`{`
`120`		`- ChipLogProgress(Discovery, "\tICD is operating as a\t%s", dnsSdInfo->isICDOperatingAsLIT.Value() ? "LIT" : "SIT");`
	`124`	`+ ChipLogProgress(Discovery, "\tICD is operating as a\t%s", *(dnsSdInfo->isICDOperatingAsLIT) ? "LIT" : "SIT");`
`121`	`125`	`}`
`122`	`126`
`123`	`127`	`for (unsigned j = 0; j < dnsSdInfo->numIPs; ++j)`
Original file line number	Diff line number	Diff line change
`@@ -124,17 +124,23 @@ void pychip_DeviceController_IterateDiscoveredCommissionableNodes(Controller::De`
`124`	`124`	`jsonVal["deviceName"] = dnsSdInfo->deviceName;`
`125`	`125`	`jsonVal["pairingInstruction"] = dnsSdInfo->pairingInstruction;`
`126`	`126`	`jsonVal["pairingHint"] = dnsSdInfo->pairingHint;`
`127`		`- if (dnsSdInfo->GetMrpRetryIntervalIdle().HasValue())`
	`127`	`+`
	`128`	`+ auto idleInterval = dnsSdInfo->GetMrpRetryIntervalIdle();`
	`129`	`+ if (idleInterval.has_value())`
`128`	`130`	`{`
`129`		`- jsonVal["mrpRetryIntervalIdle"] = dnsSdInfo->GetMrpRetryIntervalIdle().Value().count();`
	`131`	`+ jsonVal["mrpRetryIntervalIdle"] = idleInterval->count();`
`130`	`132`	`}`
`131`		`- if (dnsSdInfo->GetMrpRetryIntervalActive().HasValue())`
	`133`	`+`
	`134`	`+ auto activeInterval = dnsSdInfo->GetMrpRetryIntervalActive();`
	`135`	`+ if (activeInterval.has_value())`
`132`	`136`	`{`
`133`		`- jsonVal["mrpRetryIntervalActive"] = dnsSdInfo->GetMrpRetryIntervalActive().Value().count();`
	`137`	`+ jsonVal["mrpRetryIntervalActive"] = activeInterval->count();`
`134`	`138`	`}`
`135`		`- if (dnsSdInfo->GetMrpRetryActiveThreshold().HasValue())`
	`139`	`+`
	`140`	`+ auto activeThreshold = dnsSdInfo->GetMrpRetryActiveThreshold();`
	`141`	`+ if (activeThreshold.has_value())`
`136`	`142`	`{`
`137`		`- jsonVal["mrpRetryActiveThreshold"] = dnsSdInfo->GetMrpRetryActiveThreshold().Value().count();`
	`143`	`+ jsonVal["mrpRetryActiveThreshold"] = activeThreshold->count();`
`138`	`144`	`}`
`139`	`145`	`jsonVal["supportsTcp"] = dnsSdInfo->supportsTcp;`
`140`	`146`	`{`
`@@ -147,9 +153,9 @@ void pychip_DeviceController_IterateDiscoveredCommissionableNodes(Controller::De`
`147`	`153`	`}`
`148`	`154`	`jsonVal["addresses"] = addresses;`
`149`	`155`	`}`
`150`		`- if (dnsSdInfo->isICDOperatingAsLIT.HasValue())`
	`156`	`+ if (dnsSdInfo->isICDOperatingAsLIT.has_value())`
`151`	`157`	`{`
`152`		`- jsonVal["isICDOperatingAsLIT"] = dnsSdInfo->isICDOperatingAsLIT.Value();`
	`158`	`+ jsonVal["isICDOperatingAsLIT"] = *(dnsSdInfo->isICDOperatingAsLIT);`
`153`	`159`	`}`
`154`	`160`	`if (dnsSdInfo->rotatingIdLen > 0)`
`155`	`161`	`{`
`@@ -188,26 +194,31 @@ void pychip_DeviceController_PrintDiscoveredDevices(Controller::DeviceCommission`
`188`	`194`	`ChipLogProgress(Discovery, "\tRotating Id\t\t%s", rotatingId);`
`189`	`195`	`ChipLogProgress(Discovery, "\tPairing Instruction\t%s", dnsSdInfo->pairingInstruction);`
`190`	`196`	`ChipLogProgress(Discovery, "\tPairing Hint\t\t%u", dnsSdInfo->pairingHint);`
`191`		`- if (dnsSdInfo->GetMrpRetryIntervalIdle().HasValue())`
	`197`	`+`
	`198`	`+ auto idleInterval = dnsSdInfo->GetMrpRetryIntervalIdle();`
	`199`	`+ if (idleInterval.has_value())`
`192`	`200`	`{`
`193`		`- ChipLogProgress(Discovery, "\tMrp Interval idle\t%u", dnsSdInfo->GetMrpRetryIntervalIdle().Value().count());`
	`201`	`+ ChipLogProgress(Discovery, "\tMrp Interval idle\t%u", idleInterval->count());`
`194`	`202`	`}`
`195`	`203`	`else`
`196`	`204`	`{`
`197`	`205`	`ChipLogProgress(Discovery, "\tMrp Interval idle\tNot present");`
`198`	`206`	`}`
`199`		`- if (dnsSdInfo->GetMrpRetryIntervalActive().HasValue())`
	`207`	`+`
	`208`	`+ auto activeInterval = dnsSdInfo->GetMrpRetryIntervalActive();`
	`209`	`+ if (activeInterval.has_value())`
`200`	`210`	`{`
`201`		`- ChipLogProgress(Discovery, "\tMrp Interval active\t%u", dnsSdInfo->GetMrpRetryIntervalActive().Value().count());`
	`211`	`+ ChipLogProgress(Discovery, "\tMrp Interval active\t%u", activeInterval->count());`
`202`	`212`	`}`
`203`	`213`	`else`
`204`	`214`	`{`
`205`	`215`	`ChipLogProgress(Discovery, "\tMrp Interval active\tNot present");`
`206`	`216`	`}`
	`217`	`+`
`207`	`218`	`ChipLogProgress(Discovery, "\tSupports TCP\t\t%d", dnsSdInfo->supportsTcp);`
`208`		`- if (dnsSdInfo->isICDOperatingAsLIT.HasValue())`
	`219`	`+ if (dnsSdInfo->isICDOperatingAsLIT.has_value())`
`209`	`220`	`{`
`210`		`- ChipLogProgress(Discovery, "\tICD is operating as a\t%s", dnsSdInfo->isICDOperatingAsLIT.Value() ? "LIT" : "SIT");`
	`221`	`+ ChipLogProgress(Discovery, "\tICD is operating as a\t%s", *(dnsSdInfo->isICDOperatingAsLIT) ? "LIT" : "SIT");`
`211`	`222`	`}`
`212`	`223`	`for (unsigned j = 0; j < dnsSdInfo->numIPs; ++j)`
`213`	`224`	`{`
Original file line number	Diff line number	Diff line change
`@@ -290,9 +290,9 @@ void Resolver::OnOperationalNodeResolved(const Dnssd::ResolvedNodeData & nodeDat`
`290`	`290`	`result.mrpRemoteConfig = nodeData.resolutionData.GetRemoteMRPConfig();`
`291`	`291`	`result.supportsTcp = nodeData.resolutionData.supportsTcp;`
`292`	`292`
`293`		`- if (nodeData.resolutionData.isICDOperatingAsLIT.HasValue())`
	`293`	`+ if (nodeData.resolutionData.isICDOperatingAsLIT.has_value())`
`294`	`294`	`{`
`295`		`- result.isICDOperatingAsLIT = nodeData.resolutionData.isICDOperatingAsLIT.Value();`
	`295`	`+ result.isICDOperatingAsLIT = *(nodeData.resolutionData.isICDOperatingAsLIT);`
`296`	`296`	`}`
`297`	`297`
`298`	`298`	`for (size_t i = 0; i < nodeData.resolutionData.numIPs; i++)`
Original file line number	Diff line number	Diff line change
`@@ -105,14 +105,14 @@ bool MakeBoolFromAsciiDecimal(const ByteSpan & val)`
`105`	`105`	`return val.size() == 1 && static_cast<char>(*val.data()) == '1';`
`106`	`106`	`}`
`107`	`107`
`108`		`-Optional<bool> MakeOptionalBoolFromAsciiDecimal(const ByteSpan & val)`
	`108`	`+std::optional<bool> MakeOptionalBoolFromAsciiDecimal(const ByteSpan & val)`
`109`	`109`	`{`
`110`	`110`	`char character = static_cast<char>(*val.data());`
`111`	`111`	`if (val.size() == 1 && ((character == '1') \|\| (character == '0')))`
`112`	`112`	`{`
`113`		`- return MakeOptional(character == '1');`
	`113`	`+ return std::make_optional(character == '1');`
`114`	`114`	`}`
`115`		`- return NullOptional;`
	`115`	`+ return std::nullopt;`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`size_t GetPlusSignIdx(const ByteSpan & value)`
`@@ -188,27 +188,27 @@ uint8_t GetCommissionerPasscode(const ByteSpan & value)`
`188`	`188`	`return MakeBoolFromAsciiDecimal(value);`
`189`	`189`	`}`
`190`	`190`
`191`		`-Optional<System::Clock::Milliseconds32> GetRetryInterval(const ByteSpan & value)`
	`191`	`+std::optional<System::Clock::Milliseconds32> GetRetryInterval(const ByteSpan & value)`
`192`	`192`	`{`
`193`	`193`	`const auto undefined = std::numeric_limits<uint32_t>::max();`
`194`	`194`	`const auto retryInterval = MakeU32FromAsciiDecimal(value, undefined);`
`195`	`195`
`196`	`196`	`if (retryInterval != undefined && retryInterval <= kMaxRetryInterval.count())`
`197`		`- return MakeOptional(System::Clock::Milliseconds32(retryInterval));`
	`197`	`+ return std::make_optional(System::Clock::Milliseconds32(retryInterval));`
`198`	`198`
`199`		`- return NullOptional;`
	`199`	`+ return std::nullopt;`
`200`	`200`	`}`
`201`	`201`
`202`		`-Optional<System::Clock::Milliseconds16> GetRetryActiveThreshold(const ByteSpan & value)`
	`202`	`+std::optional<System::Clock::Milliseconds16> GetRetryActiveThreshold(const ByteSpan & value)`
`203`	`203`	`{`
`204`	`204`	`const auto retryInterval = MakeU16FromAsciiDecimal(value);`
`205`	`205`
`206`	`206`	`if (retryInterval == 0)`
`207`	`207`	`{`
`208`		`- return NullOptional;`
	`208`	`+ return std::nullopt;`
`209`	`209`	`}`
`210`	`210`
`211`		`- return MakeOptional(System::Clock::Milliseconds16(retryInterval));`
	`211`	`+ return std::make_optional(System::Clock::Milliseconds16(retryInterval));`
`212`	`212`	`}`
`213`	`213`
`214`	`214`	`TxtFieldKey GetTxtFieldKey(const ByteSpan & key)`
Original file line number	Diff line number	Diff line change
`@@ -19,10 +19,10 @@`
`19`	`19`
`20`	`20`	`#include <cstdint>`
`21`	`21`	`#include <cstring>`
	`22`	`+#include <optional>`
`22`	`23`
`23`	`24`	`#include <inet/InetInterface.h>`
`24`	`25`	`#include <lib/core/CHIPError.h>`
`25`		`-#include <lib/core/Optional.h>`
`26`	`26`	`#include <lib/core/PeerId.h>`
`27`	`27`	`#include <lib/dnssd/Constants.h>`
`28`	`28`	`#include <lib/support/BytesToHex.h>`
`@@ -91,10 +91,10 @@ struct CommonResolutionData`
`91`	`91`	`uint16_t port = 0;`
`92`	`92`	`char hostName[kHostNameMaxLength + 1] = {};`
`93`	`93`	`bool supportsTcp = false;`
`94`		`- Optional<bool> isICDOperatingAsLIT;`
`95`		`- Optional<System::Clock::Milliseconds32> mrpRetryIntervalIdle;`
`96`		`- Optional<System::Clock::Milliseconds32> mrpRetryIntervalActive;`
`97`		`- Optional<System::Clock::Milliseconds16> mrpRetryActiveThreshold;`
	`94`	`+ std::optional<bool> isICDOperatingAsLIT;`
	`95`	`+ std::optional<System::Clock::Milliseconds32> mrpRetryIntervalIdle;`
	`96`	`+ std::optional<System::Clock::Milliseconds32> mrpRetryIntervalActive;`
	`97`	`+ std::optional<System::Clock::Milliseconds16> mrpRetryActiveThreshold;`
`98`	`98`
`99`	`99`	`CommonResolutionData() { Reset(); }`
`100`	`100`
`@@ -103,32 +103,32 @@ struct CommonResolutionData`
`103`	`103`	`ReliableMessageProtocolConfig GetRemoteMRPConfig() const`
`104`	`104`	`{`
`105`	`105`	`const ReliableMessageProtocolConfig defaultConfig = GetDefaultMRPConfig();`
`106`		`- return ReliableMessageProtocolConfig(GetMrpRetryIntervalIdle().ValueOr(defaultConfig.mIdleRetransTimeout),`
`107`		`- GetMrpRetryIntervalActive().ValueOr(defaultConfig.mActiveRetransTimeout),`
`108`		`- GetMrpRetryActiveThreshold().ValueOr(defaultConfig.mActiveThresholdTime));`
	`106`	`+ return ReliableMessageProtocolConfig(GetMrpRetryIntervalIdle().value_or(defaultConfig.mIdleRetransTimeout),`
	`107`	`+ GetMrpRetryIntervalActive().value_or(defaultConfig.mActiveRetransTimeout),`
	`108`	`+ GetMrpRetryActiveThreshold().value_or(defaultConfig.mActiveThresholdTime));`
`109`	`109`	`}`
`110`		`- Optional<System::Clock::Milliseconds32> GetMrpRetryIntervalIdle() const { return mrpRetryIntervalIdle; }`
`111`		`- Optional<System::Clock::Milliseconds32> GetMrpRetryIntervalActive() const { return mrpRetryIntervalActive; }`
`112`		`- Optional<System::Clock::Milliseconds16> GetMrpRetryActiveThreshold() const { return mrpRetryActiveThreshold; }`
	`110`	`+ std::optional<System::Clock::Milliseconds32> GetMrpRetryIntervalIdle() const { return mrpRetryIntervalIdle; }`
	`111`	`+ std::optional<System::Clock::Milliseconds32> GetMrpRetryIntervalActive() const { return mrpRetryIntervalActive; }`
	`112`	`+ std::optional<System::Clock::Milliseconds16> GetMrpRetryActiveThreshold() const { return mrpRetryActiveThreshold; }`
`113`	`113`
`114`	`114`	`bool IsDeviceTreatedAsSleepy(const ReliableMessageProtocolConfig * defaultMRPConfig) const`
`115`	`115`	`{`
`116`	`116`	`// If either session interval (Idle - SII, Active - SAI) has a value and that value is greater`
`117`	`117`	`// than the value passed to this function, then the peer device will be treated as if it is`
`118`	`118`	`// a Sleepy End Device (SED)`
`119`		`- return (mrpRetryIntervalIdle.HasValue() && (mrpRetryIntervalIdle.Value() > defaultMRPConfig->mIdleRetransTimeout)) \|\|`
`120`		`- (mrpRetryIntervalActive.HasValue() && (mrpRetryIntervalActive.Value() > defaultMRPConfig->mActiveRetransTimeout));`
	`119`	`+ return (mrpRetryIntervalIdle.has_value() && (*mrpRetryIntervalIdle > defaultMRPConfig->mIdleRetransTimeout)) \|\|`
	`120`	`+ (mrpRetryIntervalActive.has_value() && (*mrpRetryIntervalActive > defaultMRPConfig->mActiveRetransTimeout));`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`bool IsHost(const char * host) const { return strcmp(host, hostName) == 0; }`
`124`	`124`
`125`	`125`	`void Reset()`
`126`	`126`	`{`
`127`	`127`	`memset(hostName, 0, sizeof(hostName));`
`128`		`- mrpRetryIntervalIdle = NullOptional;`
`129`		`- mrpRetryIntervalActive = NullOptional;`
`130`		`- mrpRetryActiveThreshold = NullOptional;`
`131`		`- isICDOperatingAsLIT = NullOptional;`
	`128`	`+ mrpRetryIntervalIdle = std::nullopt;`
	`129`	`+ mrpRetryIntervalActive = std::nullopt;`
	`130`	`+ mrpRetryActiveThreshold = std::nullopt;`
	`131`	`+ isICDOperatingAsLIT = std::nullopt;`
`132`	`132`	`numIPs = 0;`
`133`	`133`	`port = 0;`
`134`	`134`	`supportsTcp = false;`
`@@ -157,34 +157,34 @@ struct CommonResolutionData`
`157`	`157`	`{`
`158`	`158`	`ChipLogDetail(Discovery, "\tPort: %u", port);`
`159`	`159`	`}`
`160`		`- if (mrpRetryIntervalIdle.HasValue())`
	`160`	`+ if (mrpRetryIntervalIdle.has_value())`
`161`	`161`	`{`
`162`		`- ChipLogDetail(Discovery, "\tMrp Interval idle: %" PRIu32 " ms", mrpRetryIntervalIdle.Value().count());`
	`162`	`+ ChipLogDetail(Discovery, "\tMrp Interval idle: %" PRIu32 " ms", mrpRetryIntervalIdle->count());`
`163`	`163`	`}`
`164`	`164`	`else`
`165`	`165`	`{`
`166`	`166`	`ChipLogDetail(Discovery, "\tMrp Interval idle: not present");`
`167`	`167`	`}`
`168`		`- if (mrpRetryIntervalActive.HasValue())`
	`168`	`+ if (mrpRetryIntervalActive.has_value())`
`169`	`169`	`{`
`170`		`- ChipLogDetail(Discovery, "\tMrp Interval active: %" PRIu32 " ms", mrpRetryIntervalActive.Value().count());`
	`170`	`+ ChipLogDetail(Discovery, "\tMrp Interval active: %" PRIu32 " ms", mrpRetryIntervalActive->count());`
`171`	`171`	`}`
`172`	`172`	`else`
`173`	`173`	`{`
`174`	`174`	`ChipLogDetail(Discovery, "\tMrp Interval active: not present");`
`175`	`175`	`}`
`176`		`- if (mrpRetryActiveThreshold.HasValue())`
	`176`	`+ if (mrpRetryActiveThreshold.has_value())`
`177`	`177`	`{`
`178`		`- ChipLogDetail(Discovery, "\tMrp Active Threshold: %u ms", mrpRetryActiveThreshold.Value().count());`
	`178`	`+ ChipLogDetail(Discovery, "\tMrp Active Threshold: %u ms", mrpRetryActiveThreshold->count());`
`179`	`179`	`}`
`180`	`180`	`else`
`181`	`181`	`{`
`182`	`182`	`ChipLogDetail(Discovery, "\tMrp Active Threshold: not present");`
`183`	`183`	`}`
`184`	`184`	`ChipLogDetail(Discovery, "\tTCP Supported: %d", supportsTcp);`
`185`		`- if (isICDOperatingAsLIT.HasValue())`
	`185`	`+ if (isICDOperatingAsLIT.has_value())`
`186`	`186`	`{`
`187`		`- ChipLogDetail(Discovery, "\tThe ICD operates in %s", isICDOperatingAsLIT.Value() ? "LIT" : "SIT");`
	`187`	`+ ChipLogDetail(Discovery, "\tThe ICD operates in %s", *isICDOperatingAsLIT ? "LIT" : "SIT");`
`188`	`188`	`}`
`189`	`189`	`else`
`190`	`190`	`{`