src/core/thread/peer_table.cpp

/*
 *  Copyright (c) 2025, The OpenThread Authors.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the copyright holder nor the
 *     names of its contributors may be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */

/**
 * @file
 *   This file includes definitions for the Thread Peer table.
 */

#include "peer_table.hpp"

#if OPENTHREAD_CONFIG_P2P_ENABLE

#include "instance/instance.hpp"

namespace ot {

PeerTable::Iterator::Iterator(Instance &aInstance, Peer::StateFilter aFilter)
    : InstanceLocator(aInstance)
    , ItemPtrIterator(nullptr)
    , mFilter(aFilter)
{
    Reset();
}

void PeerTable::Iterator::Reset(void)
{
    mItem = &Get<PeerTable>().mPeers[0];

    if (!mItem->MatchesFilter(mFilter))
    {
        Advance();
    }
}

void PeerTable::Iterator::Advance(void)
{
    VerifyOrExit(mItem != nullptr);

    do
    {
        mItem++;
        VerifyOrExit(mItem < &Get<PeerTable>().mPeers[Get<PeerTable>().kMaxPeers], mItem = nullptr);
    } while (!mItem->MatchesFilter(mFilter));

exit:
    return;
}

PeerTable::PeerTable(Instance &aInstance)
    : InstanceLocator(aInstance)
{
    for (Peer &peer : mPeers)
    {
        peer.Init(aInstance);
        peer.Clear();
    }
}

void PeerTable::Clear(void)
{
    for (Peer &peer : mPeers)
    {
        peer.Clear();
    }
}

Peer *PeerTable::GetNewPeer(void)
{
    Peer *peer = FindPeer(Peer::AddressMatcher(Peer::kInStateInvalid));

    VerifyOrExit(peer != nullptr);
    peer->Clear();

exit:
    return peer;
}

const Peer *PeerTable::FindPeer(const Peer::AddressMatcher &aMatcher) const
{
    const Peer *peer = mPeers;

    for (uint16_t num = kMaxPeers; num != 0; num--, peer++)
    {
        if (peer->Matches(aMatcher))
        {
            ExitNow();
        }
    }

    peer = nullptr;

exit:
    return peer;
}

Peer *PeerTable::FindPeer(const Mac::ExtAddress &aExtAddress, Peer::StateFilter aFilter)
{
    return FindPeer(Peer::AddressMatcher(aExtAddress, aFilter));
}

bool PeerTable::HasPeers(Peer::StateFilter aFilter) const
{
    return (FindPeer(Peer::AddressMatcher(aFilter)) != nullptr);
}

bool PeerTable::IsFull(void) const { return FindPeer(Peer::AddressMatcher(Peer::kInStateInvalid)) == nullptr; }

} // namespace ot

#endif // OPENTHREAD_CONFIG_P2P_ENABLE