From a44970bdb438970c3ad4f81002fe505bad703272 Mon Sep 17 00:00:00 2001
From: Abtin Keshavarzian <abtink@google.com>
Date: Tue, 7 Apr 2026 11:23:25 -0700
Subject: [PATCH] [nexus] simplify node lookup using `LinkedList` matching
 methods (#12849)

This commit updates the address-based node lookup methods in `Core`
to use the `FindMatching()` and `ContainsMatching()` methods provided
by the `LinkedList` class. This replaces manual `for` loops with
cleaner, built-in list operations.

To facilitate this, a new `AddressNetif` enum and a `Matches()` method
are added to the `Node` class. The `Matches()` method accepts an
`Ip6::Address` and an `AddressNetif` indicator, allowing it to check
if the node has the specified address on its Thread interface, its
Infrastructure interface, or any.

Additionally, a `const` overload for the `Get()` template method is
added to the `Node` class to ensure proper const-correctness.
---
 tests/nexus/platform/nexus_core.cpp | 40 +++++------------------------
 tests/nexus/platform/nexus_node.cpp | 22 ++++++++++++++++
 tests/nexus/platform/nexus_node.hpp | 12 ++++++++-
 3 files changed, 40 insertions(+), 34 deletions(-)

diff --git a/tests/nexus/platform/nexus_core.cpp b/tests/nexus/platform/nexus_core.cpp
index f5de1e2df..99d5fbb3d 100644
--- a/tests/nexus/platform/nexus_core.cpp
+++ b/tests/nexus/platform/nexus_core.cpp
@@ -667,48 +667,22 @@ void Core::ProcessInfraIf(Node &aNode)
 
 Node *Core::FindNodeByAddress(const Ip6::Address &aAddress)
 {
-    Node *matchedNode = FindNodeByThreadAddress(aAddress);
-
-    if (matchedNode == nullptr)
-    {
-        matchedNode = FindNodeByInfraIfAddress(aAddress);
-    }
-
-    return matchedNode;
+    return mNodes.FindMatching(aAddress, Node::kAnyNetifAddress);
 }
 
-bool Core::IsThreadAddress(const Ip6::Address &aAddress) { return FindNodeByThreadAddress(aAddress) != nullptr; }
+bool Core::IsThreadAddress(const Ip6::Address &aAddress)
+{
+    return mNodes.ContainsMatching(aAddress, Node::kThreadNetifAddress);
+}
 
 Node *Core::FindNodeByThreadAddress(const Ip6::Address &aAddress)
 {
-    Node *matchedNode = nullptr;
-
-    for (Node &node : mNodes)
-    {
-        if (node.Get<ThreadNetif>().HasUnicastAddress(aAddress))
-        {
-            matchedNode = &node;
-            break;
-        }
-    }
-
-    return matchedNode;
+    return mNodes.FindMatching(aAddress, Node::kThreadNetifAddress);
 }
 
 Node *Core::FindNodeByInfraIfAddress(const Ip6::Address &aAddress)
 {
-    Node *matchedNode = nullptr;
-
-    for (Node &node : mNodes)
-    {
-        if (node.mInfraIf.HasAddress(aAddress))
-        {
-            matchedNode = &node;
-            break;
-        }
-    }
-
-    return matchedNode;
+    return mNodes.FindMatching(aAddress, Node::kInfraNetifAddress);
 }
 
 //---------------------------------------------------------------------------------------------------------------------
diff --git a/tests/nexus/platform/nexus_node.cpp b/tests/nexus/platform/nexus_node.cpp
index 1fe7a1451..a4eb8fa1f 100644
--- a/tests/nexus/platform/nexus_node.cpp
+++ b/tests/nexus/platform/nexus_node.cpp
@@ -229,5 +229,27 @@ const Ip6::Address &Node::FindGlobalAddress(void)
     return *matchedAddress;
 }
 
+bool Node::Matches(const Ip6::Address &aAddress, AddressNetif aNetif) const
+{
+    bool matches = false;
+
+    switch (aNetif)
+    {
+    case kThreadNetifAddress:
+        matches = Get<ThreadNetif>().HasUnicastAddress(aAddress);
+        break;
+
+    case kInfraNetifAddress:
+        matches = mInfraIf.HasAddress(aAddress);
+        break;
+
+    case kAnyNetifAddress:
+        matches = Get<ThreadNetif>().HasUnicastAddress(aAddress) || mInfraIf.HasAddress(aAddress);
+        break;
+    }
+
+    return matches;
+}
+
 } // namespace Nexus
 } // namespace ot
diff --git a/tests/nexus/platform/nexus_node.hpp b/tests/nexus/platform/nexus_node.hpp
index 2959150ba..4b8b25ad3 100644
--- a/tests/nexus/platform/nexus_node.hpp
+++ b/tests/nexus/platform/nexus_node.hpp
@@ -120,13 +120,23 @@ public:
      */
     const Ip6::Address &FindGlobalAddress(void);
 
+    enum AddressNetif : uint8_t
+    {
+        kThreadNetifAddress,
+        kInfraNetifAddress,
+        kAnyNetifAddress,
+    };
+
+    bool Matches(const Ip6::Address &aAddress, AddressNetif aNetif) const;
+
     void        SetName(const char *aName) { mName.Clear().Append("%s", aName); }
     void        SetName(const char *aPrefix, uint16_t aIndex);
     const char *GetName(void) const { return mName.AsCString(); }
 
     //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-    template <typename Type> Type &Get(void) { return Instance::Get<Type>(); }
+    template <typename Type> Type       &Get(void) { return Instance::Get<Type>(); }
+    template <typename Type> const Type &Get(void) const { return AsConst(AsNonConst(this)->Get<Type>()); }
 
     Instance &GetInstance(void) { return *this; }