espressif/openthread
1
0
Fork 0
mirror of https://github.com/espressif/openthread.git synced 2026-07-24 13:04:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

[common] adding AsCoreType() to covert from public to core types (#6993)

Browse Source 
This commit adds header file `common/as_core_type.hpp` which adds
helper functions `AsCoreType()` which help convert from a
public C OpenThread type to its corresponding C++ core type (e.g.,
`otIp6Address` to `Ip6::Address`). This commit also adds `MapEnum()`
function to convert between public and core `enum` definitions (e.g.,
`otMacFilterAddressMode` and `Mac::Filter::Mode`). These helper
function act as syntactic sugar helping simplify the implementations
of OT API functions (in `api/{module}_api.cpp` files).
This commit is contained in:
Abtin Keshavarzian
2021-09-16 21:15:37 -07:00
committed by GitHub
parent 7d91dd19c6
commit 961fd9ae95
49 changed files with 1141 additions and 1714 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/api/thread_api.cpp
+78 -164
View File
@@ -37,39 +37,32 @@
#include <openthread/thread.h>
#include "common/as_core_type.hpp"
#include "common/debug.hpp"
#include "common/instance.hpp"
#include "common/locator_getters.hpp"
#include "common/settings.hpp"
using namespace ot;
uint32_t otThreadGetChildTimeout(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<Mle::MleRouter>().GetTimeout();
return AsCoreType(aInstance).Get<Mle::MleRouter>().GetTimeout();
}
void otThreadSetChildTimeout(otInstance *aInstance, uint32_t aTimeout)
{
Instance &instance = *static_cast<Instance *>(aInstance);
instance.Get<Mle::MleRouter>().SetTimeout(aTimeout);
AsCoreType(aInstance).Get<Mle::MleRouter>().SetTimeout(aTimeout);
}
const otExtendedPanId *otThreadGetExtendedPanId(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return &instance.Get<Mac::Mac>().GetExtendedPanId();
return &AsCoreType(aInstance).Get<Mac::Mac>().GetExtendedPanId();
}
otError otThreadSetExtendedPanId(otInstance *aInstance, const otExtendedPanId *aExtendedPanId)
{
Error error = kErrorNone;
Instance & instance = *static_cast<Instance *>(aInstance);
const Mac::ExtendedPanId &extPanId = *static_cast<const Mac::ExtendedPanId *>(aExtendedPanId);
Instance & instance = AsCoreType(aInstance);
const Mac::ExtendedPanId &extPanId = AsCoreType(aExtendedPanId);
Mle::MeshLocalPrefix prefix;
VerifyOrExit(instance.Get<Mle::MleRouter>().IsDisabled(), error = kErrorInvalidState);
@@ -88,56 +81,47 @@ exit:
otError otThreadGetLeaderRloc(otInstance *aInstance, otIp6Address *aLeaderRloc)
{
Instance &instance = *static_cast<Instance *>(aInstance);
OT_ASSERT(aLeaderRloc != nullptr);
return instance.Get<Mle::MleRouter>().GetLeaderAddress(*static_cast<Ip6::Address *>(aLeaderRloc));
return AsCoreType(aInstance).Get<Mle::MleRouter>().GetLeaderAddress(AsCoreType(aLeaderRloc));
}
otLinkModeConfig otThreadGetLinkMode(otInstance *aInstance)
{
otLinkModeConfig config;
Instance & instance = *static_cast<Instance *>(aInstance);
instance.Get<Mle::MleRouter>().GetDeviceMode().Get(config);
AsCoreType(aInstance).Get<Mle::MleRouter>().GetDeviceMode().Get(config);
return config;
}
otError otThreadSetLinkMode(otInstance *aInstance, otLinkModeConfig aConfig)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<Mle::MleRouter>().SetDeviceMode(Mle::DeviceMode(aConfig));
return AsCoreType(aInstance).Get<Mle::MleRouter>().SetDeviceMode(Mle::DeviceMode(aConfig));
}
void otThreadGetNetworkKey(otInstance *aInstance, otNetworkKey *aNetworkKey)
{
Instance &instance = *static_cast<Instance *>(aInstance);
instance.Get<KeyManager>().GetNetworkKey(*static_cast<NetworkKey *>(aNetworkKey));
AsCoreType(aInstance).Get<KeyManager>().GetNetworkKey(AsCoreType(aNetworkKey));
}
#if OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE
otNetworkKeyRef otThreadGetNetworkKeyRef(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<KeyManager>().GetNetworkKeyRef();
return AsCoreType(aInstance).Get<KeyManager>().GetNetworkKeyRef();
}
#endif
otError otThreadSetNetworkKey(otInstance *aInstance, const otNetworkKey *aKey)
{
Error error = kErrorNone;
Instance &instance = *static_cast<Instance *>(aInstance);
Instance &instance = AsCoreType(aInstance);
OT_ASSERT(aKey != nullptr);
VerifyOrExit(instance.Get<Mle::MleRouter>().IsDisabled(), error = kErrorInvalidState);
instance.Get<KeyManager>().SetNetworkKey(*static_cast<const NetworkKey *>(aKey));
instance.Get<KeyManager>().SetNetworkKey(AsCoreType(aKey));
instance.Get<MeshCoP::ActiveDataset>().Clear();
instance.Get<MeshCoP::PendingDataset>().Clear();
@@ -150,13 +134,13 @@ exit:
otError otThreadSetNetworkKeyRef(otInstance *aInstance, otNetworkKeyRef aKeyRef)
{
Error error = kErrorNone;
Instance &instance = *static_cast<Instance *>(aInstance);
Instance &instance = AsCoreType(aInstance);
VerifyOrExit(aKeyRef != 0, error = kErrorInvalidArgs);
VerifyOrExit(instance.Get<Mle::MleRouter>().IsDisabled(), error = kErrorInvalidState);
instance.Get<KeyManager>().SetNetworkKeyRef(static_cast<NetworkKeyRef>(aKeyRef));
instance.Get<KeyManager>().SetNetworkKeyRef((aKeyRef));
instance.Get<MeshCoP::ActiveDataset>().Clear();
instance.Get<MeshCoP::PendingDataset>().Clear();
@@ -167,35 +151,28 @@ exit:
const otIp6Address *otThreadGetRloc(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return &instance.Get<Mle::MleRouter>().GetMeshLocal16();
return &AsCoreType(aInstance).Get<Mle::MleRouter>().GetMeshLocal16();
}
const otIp6Address *otThreadGetMeshLocalEid(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return &instance.Get<Mle::MleRouter>().GetMeshLocal64();
return &AsCoreType(aInstance).Get<Mle::MleRouter>().GetMeshLocal64();
}
const otMeshLocalPrefix *otThreadGetMeshLocalPrefix(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return &instance.Get<Mle::MleRouter>().GetMeshLocalPrefix();
return &AsCoreType(aInstance).Get<Mle::MleRouter>().GetMeshLocalPrefix();
}
otError otThreadSetMeshLocalPrefix(otInstance *aInstance, const otMeshLocalPrefix *aMeshLocalPrefix)
{
Error error = kErrorNone;
Instance &instance = *static_cast<Instance *>(aInstance);
Error error = kErrorNone;
VerifyOrExit(instance.Get<Mle::MleRouter>().IsDisabled(), error = kErrorInvalidState);
VerifyOrExit(AsCoreType(aInstance).Get<Mle::MleRouter>().IsDisabled(), error = kErrorInvalidState);
instance.Get<Mle::MleRouter>().SetMeshLocalPrefix(*static_cast<const Mle::MeshLocalPrefix *>(aMeshLocalPrefix));
instance.Get<MeshCoP::ActiveDataset>().Clear();
instance.Get<MeshCoP::PendingDataset>().Clear();
AsCoreType(aInstance).Get<Mle::MleRouter>().SetMeshLocalPrefix(AsCoreType(aMeshLocalPrefix));
AsCoreType(aInstance).Get<MeshCoP::ActiveDataset>().Clear();
AsCoreType(aInstance).Get<MeshCoP::PendingDataset>().Clear();
exit:
return error;
@@ -203,49 +180,38 @@ exit:
const otIp6Address *otThreadGetLinkLocalIp6Address(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return &instance.Get<Mle::MleRouter>().GetLinkLocalAddress();
return &AsCoreType(aInstance).Get<Mle::MleRouter>().GetLinkLocalAddress();
}
const otIp6Address *otThreadGetLinkLocalAllThreadNodesMulticastAddress(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return &instance.Get<Mle::MleRouter>().GetLinkLocalAllThreadNodesAddress();
return &AsCoreType(aInstance).Get<Mle::MleRouter>().GetLinkLocalAllThreadNodesAddress();
}
const otIp6Address *otThreadGetRealmLocalAllThreadNodesMulticastAddress(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return &instance.Get<Mle::MleRouter>().GetRealmLocalAllThreadNodesAddress();
return &AsCoreType(aInstance).Get<Mle::MleRouter>().GetRealmLocalAllThreadNodesAddress();
}
otError otThreadGetServiceAloc(otInstance *aInstance, uint8_t aServiceId, otIp6Address *aServiceAloc)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<Mle::MleRouter>().GetServiceAloc(aServiceId, *static_cast<Ip6::Address *>(aServiceAloc));
return AsCoreType(aInstance).Get<Mle::MleRouter>().GetServiceAloc(aServiceId, AsCoreType(aServiceAloc));
}
const char *otThreadGetNetworkName(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<Mac::Mac>().GetNetworkName().GetAsCString();
return AsCoreType(aInstance).Get<Mac::Mac>().GetNetworkName().GetAsCString();
}
otError otThreadSetNetworkName(otInstance *aInstance, const char *aNetworkName)
{
Error error = kErrorNone;
Instance &instance = *static_cast<Instance *>(aInstance);
Error error = kErrorNone;
VerifyOrExit(instance.Get<Mle::MleRouter>().IsDisabled(), error = kErrorInvalidState);
VerifyOrExit(AsCoreType(aInstance).Get<Mle::MleRouter>().IsDisabled(), error = kErrorInvalidState);
error = instance.Get<Mac::Mac>().SetNetworkName(aNetworkName);
instance.Get<MeshCoP::ActiveDataset>().Clear();
instance.Get<MeshCoP::PendingDataset>().Clear();
error = AsCoreType(aInstance).Get<Mac::Mac>().SetNetworkName(aNetworkName);
AsCoreType(aInstance).Get<MeshCoP::ActiveDataset>().Clear();
AsCoreType(aInstance).Get<MeshCoP::PendingDataset>().Clear();
exit:
return error;
@@ -254,19 +220,16 @@ exit:
#if (OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2)
const char *otThreadGetDomainName(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<Mac::Mac>().GetDomainName().GetAsCString();
return AsCoreType(aInstance).Get<Mac::Mac>().GetDomainName().GetAsCString();
}
otError otThreadSetDomainName(otInstance *aInstance, const char *aDomainName)
{
Error error = kErrorNone;
Instance &instance = *static_cast<Instance *>(aInstance);
Error error = kErrorNone;
VerifyOrExit(instance.Get<Mle::MleRouter>().IsDisabled(), error = kErrorInvalidState);
VerifyOrExit(AsCoreType(aInstance).Get<Mle::MleRouter>().IsDisabled(), error = kErrorInvalidState);
error = instance.Get<Mac::Mac>().SetDomainName(aDomainName);
error = AsCoreType(aInstance).Get<Mac::Mac>().SetDomainName(aDomainName);
exit:
return error;
@@ -275,17 +238,15 @@ exit:
#if OPENTHREAD_CONFIG_DUA_ENABLE
otError otThreadSetFixedDuaInterfaceIdentifier(otInstance *aInstance, const otIp6InterfaceIdentifier *aIid)
{
Instance &instance = *static_cast<Instance *>(aInstance);
Error error = kErrorNone;
Error error = kErrorNone;
if (aIid)
{
error = instance.Get<DuaManager>().SetFixedDuaInterfaceIdentifier(
*static_cast<const Ip6::InterfaceIdentifier *>(aIid));
error = AsCoreType(aInstance).Get<DuaManager>().SetFixedDuaInterfaceIdentifier(AsCoreType(aIid));
}
else
{
instance.Get<DuaManager>().ClearFixedDuaInterfaceIdentifier();
AsCoreType(aInstance).Get<DuaManager>().ClearFixedDuaInterfaceIdentifier();
}
return error;
@@ -293,7 +254,7 @@ otError otThreadSetFixedDuaInterfaceIdentifier(otInstance *aInstance, const otIp
const otIp6InterfaceIdentifier *otThreadGetFixedDuaInterfaceIdentifier(otInstance *aInstance)
{
Instance & instance = *static_cast<Instance *>(aInstance);
Instance & instance = AsCoreType(aInstance);
const otIp6InterfaceIdentifier *iid = nullptr;
if (instance.Get<DuaManager>().IsFixedDuaInterfaceIdentifierSet())
@@ -309,76 +270,59 @@ const otIp6InterfaceIdentifier *otThreadGetFixedDuaInterfaceIdentifier(otInstanc
uint32_t otThreadGetKeySequenceCounter(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<KeyManager>().GetCurrentKeySequence();
return AsCoreType(aInstance).Get<KeyManager>().GetCurrentKeySequence();
}
void otThreadSetKeySequenceCounter(otInstance *aInstance, uint32_t aKeySequenceCounter)
{
Instance &instance = *static_cast<Instance *>(aInstance);
instance.Get<KeyManager>().SetCurrentKeySequence(aKeySequenceCounter);
AsCoreType(aInstance).Get<KeyManager>().SetCurrentKeySequence(aKeySequenceCounter);
}
uint32_t otThreadGetKeySwitchGuardTime(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<KeyManager>().GetKeySwitchGuardTime();
return AsCoreType(aInstance).Get<KeyManager>().GetKeySwitchGuardTime();
}
void otThreadSetKeySwitchGuardTime(otInstance *aInstance, uint32_t aKeySwitchGuardTime)
{
Instance &instance = *static_cast<Instance *>(aInstance);
instance.Get<KeyManager>().SetKeySwitchGuardTime(aKeySwitchGuardTime);
AsCoreType(aInstance).Get<KeyManager>().SetKeySwitchGuardTime(aKeySwitchGuardTime);
}
otError otThreadBecomeDetached(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<Mle::MleRouter>().BecomeDetached();
return AsCoreType(aInstance).Get<Mle::MleRouter>().BecomeDetached();
}
otError otThreadBecomeChild(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<Mle::MleRouter>().BecomeChild(Mle::kAttachAny);
return AsCoreType(aInstance).Get<Mle::MleRouter>().BecomeChild(Mle::kAttachAny);
}
otError otThreadGetNextNeighborInfo(otInstance *aInstance, otNeighborInfoIterator *aIterator, otNeighborInfo *aInfo)
{
Instance &instance = *static_cast<Instance *>(aInstance);
OT_ASSERT((aInfo != nullptr) && (aIterator != nullptr));
return instance.Get<NeighborTable>().GetNextNeighborInfo(*aIterator, *static_cast<Neighbor::Info *>(aInfo));
return AsCoreType(aInstance).Get<NeighborTable>().GetNextNeighborInfo(*aIterator, AsCoreType(aInfo));
}
otDeviceRole otThreadGetDeviceRole(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return static_cast<otDeviceRole>(instance.Get<Mle::MleRouter>().GetRole());
return MapEnum(AsCoreType(aInstance).Get<Mle::MleRouter>().GetRole());
}
const char *otThreadDeviceRoleToString(otDeviceRole aRole)
{
return Mle::Mle::RoleToString(static_cast<Mle::DeviceRole>(aRole));
return Mle::Mle::RoleToString(MapEnum(aRole));
}
otError otThreadGetLeaderData(otInstance *aInstance, otLeaderData *aLeaderData)
{
Instance &instance = *static_cast<Instance *>(aInstance);
Error error = kErrorNone;
Error error = kErrorNone;
OT_ASSERT(aLeaderData != nullptr);
VerifyOrExit(instance.Get<Mle::MleRouter>().IsAttached(), error = kErrorDetached);
*aLeaderData = instance.Get<Mle::MleRouter>().GetLeaderData();
VerifyOrExit(AsCoreType(aInstance).Get<Mle::MleRouter>().IsAttached(), error = kErrorDetached);
*aLeaderData = AsCoreType(aInstance).Get<Mle::MleRouter>().GetLeaderData();
exit:
return error;
@@ -386,46 +330,37 @@ exit:
uint8_t otThreadGetLeaderRouterId(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<Mle::MleRouter>().GetLeaderId();
return AsCoreType(aInstance).Get<Mle::MleRouter>().GetLeaderId();
}
uint8_t otThreadGetLeaderWeight(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<Mle::MleRouter>().GetLeaderData().GetWeighting();
return AsCoreType(aInstance).Get<Mle::MleRouter>().GetLeaderData().GetWeighting();
}
uint32_t otThreadGetPartitionId(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<Mle::MleRouter>().GetLeaderData().GetPartitionId();
return AsCoreType(aInstance).Get<Mle::MleRouter>().GetLeaderData().GetPartitionId();
}
uint16_t otThreadGetRloc16(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<Mle::MleRouter>().GetRloc16();
return AsCoreType(aInstance).Get<Mle::MleRouter>().GetRloc16();
}
otError otThreadGetParentInfo(otInstance *aInstance, otRouterInfo *aParentInfo)
{
Instance &instance = *static_cast<Instance *>(aInstance);
Error error = kErrorNone;
Router * parent;
Error error = kErrorNone;
Router *parent;
OT_ASSERT(aParentInfo != nullptr);
// Reference device needs get the original parent's info even after the node state changed.
#if !OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE
VerifyOrExit(instance.Get<Mle::MleRouter>().IsChild(), error = kErrorInvalidState);
VerifyOrExit(AsCoreType(aInstance).Get<Mle::MleRouter>().IsChild(), error = kErrorInvalidState);
#endif
parent = &instance.Get<Mle::MleRouter>().GetParent();
parent = &AsCoreType(aInstance).Get<Mle::MleRouter>().GetParent();
aParentInfo->mExtAddress = parent->GetExtAddress();
aParentInfo->mRloc16 = parent->GetRloc16();
@@ -446,12 +381,11 @@ exit:
otError otThreadGetParentAverageRssi(otInstance *aInstance, int8_t *aParentRssi)
{
Error error = kErrorNone;
Instance &instance = *static_cast<Instance *>(aInstance);
Error error = kErrorNone;
OT_ASSERT(aParentRssi != nullptr);
*aParentRssi = instance.Get<Mle::MleRouter>().GetParent().GetLinkInfo().GetAverageRss();
*aParentRssi = AsCoreType(aInstance).Get<Mle::MleRouter>().GetParent().GetLinkInfo().GetAverageRss();
VerifyOrExit(*aParentRssi != OT_RADIO_RSSI_INVALID, error = kErrorFailed);
@@ -461,12 +395,11 @@ exit:
otError otThreadGetParentLastRssi(otInstance *aInstance, int8_t *aLastRssi)
{
Error error = kErrorNone;
Instance &instance = *static_cast<Instance *>(aInstance);
Error error = kErrorNone;
OT_ASSERT(aLastRssi != nullptr);
*aLastRssi = instance.Get<Mle::MleRouter>().GetParent().GetLinkInfo().GetLastRss();
*aLastRssi = AsCoreType(aInstance).Get<Mle::MleRouter>().GetParent().GetLinkInfo().GetLastRss();
VerifyOrExit(*aLastRssi != OT_RADIO_RSSI_INVALID, error = kErrorFailed);
@@ -476,16 +409,15 @@ exit:
otError otThreadSetEnabled(otInstance *aInstance, bool aEnabled)
{
Error error = kErrorNone;
Instance &instance = *static_cast<Instance *>(aInstance);
Error error = kErrorNone;
if (aEnabled)
{
error = instance.Get<Mle::MleRouter>().Start();
error = AsCoreType(aInstance).Get<Mle::MleRouter>().Start();
}
else
{
instance.Get<Mle::MleRouter>().Stop();
AsCoreType(aInstance).Get<Mle::MleRouter>().Stop();
}
return error;
@@ -498,9 +430,7 @@ uint16_t otThreadGetVersion(void)
bool otThreadIsSingleton(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<Mle::MleRouter>().IsSingleton();
return AsCoreType(aInstance).Get<Mle::MleRouter>().IsSingleton();
}
otError otThreadDiscover(otInstance * aInstance,
@@ -511,10 +441,8 @@ otError otThreadDiscover(otInstance * aInstance,
otHandleActiveScanResult aCallback,
void * aCallbackContext)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<Mle::DiscoverScanner>().Discover(
static_cast<Mac::ChannelMask>(aScanChannels), aPanId, aJoiner, aEnableEui64Filtering,
return AsCoreType(aInstance).Get<Mle::DiscoverScanner>().Discover(
Mac::ChannelMask(aScanChannels), aPanId, aJoiner, aEnableEui64Filtering,
/* aFilterIndexes (use hash of factory EUI64) */ nullptr, aCallback, aCallbackContext);
}
@@ -523,53 +451,39 @@ otError otThreadSetJoinerAdvertisement(otInstance * aInstance,
const uint8_t *aAdvData,
uint8_t aAdvDataLength)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<Mle::DiscoverScanner>().SetJoinerAdvertisement(aOui, aAdvData, aAdvDataLength);
return AsCoreType(aInstance).Get<Mle::DiscoverScanner>().SetJoinerAdvertisement(aOui, aAdvData, aAdvDataLength);
}
bool otThreadIsDiscoverInProgress(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.Get<Mle::DiscoverScanner>().IsInProgress();
return AsCoreType(aInstance).Get<Mle::DiscoverScanner>().IsInProgress();
}
const otIpCounters *otThreadGetIp6Counters(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return &instance.Get<MeshForwarder>().GetCounters();
return &AsCoreType(aInstance).Get<MeshForwarder>().GetCounters();
}
void otThreadResetIp6Counters(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
instance.Get<MeshForwarder>().ResetCounters();
AsCoreType(aInstance).Get<MeshForwarder>().ResetCounters();
}
const otMleCounters *otThreadGetMleCounters(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
return &instance.Get<Mle::MleRouter>().GetCounters();
return &AsCoreType(aInstance).Get<Mle::MleRouter>().GetCounters();
}
void otThreadResetMleCounters(otInstance *aInstance)
{
Instance &instance = *static_cast<Instance *>(aInstance);
instance.Get<Mle::MleRouter>().ResetCounters();
AsCoreType(aInstance).Get<Mle::MleRouter>().ResetCounters();
}
void otThreadRegisterParentResponseCallback(otInstance * aInstance,
otThreadParentResponseCallback aCallback,
void * aContext)
{
Instance &instance = *static_cast<Instance *>(aInstance);
instance.Get<Mle::MleRouter>().RegisterParentResponseStatsCallback(aCallback, aContext);
AsCoreType(aInstance).Get<Mle::MleRouter>().RegisterParentResponseStatsCallback(aCallback, aContext);
}
#endif // OPENTHREAD_FTD || OPENTHREAD_MTD