espressif/openthread
1
0
Fork 0
mirror of https://github.com/espressif/openthread.git synced 2026-08-18 16:39:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

[core] update enum checks to use compile-time static counter utility (#10852)

Browse Source 
This commit updates the `static_assert` checks for `enum` values within
all core modules to use the recently added compile-time static counter
and its related helper utility macros.
This commit is contained in:
Abtin Keshavarzian
2024-10-24 11:34:22 +01:00
committed by GitHub
parent 6827344e08
commit 2935435261
26 changed files with 421 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/backbone_router/bbr_leader.cpp
+18 -10
View File
@@ -106,12 +106,16 @@ const char *Leader::StateToString(State aState)
"Unchanged", // (5) kStateUnchanged
};
static_assert(0 == kStateNone, "kStateNone value is incorrect");
static_assert(1 == kStateAdded, "kStateAdded value is incorrect");
static_assert(2 == kStateRemoved, "kStateRemoved value is incorrect");
static_assert(3 == kStateToTriggerRereg, "kStateToTriggerRereg value is incorrect");
static_assert(4 == kStateRefreshed, "kStateRefreshed value is incorrect");
static_assert(5 == kStateUnchanged, "kStateUnchanged value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kStateNone);
ValidateNextEnum(kStateAdded);
ValidateNextEnum(kStateRemoved);
ValidateNextEnum(kStateToTriggerRereg);
ValidateNextEnum(kStateRefreshed);
ValidateNextEnum(kStateUnchanged);
};
return kStateStrings[aState];
}
@@ -125,10 +129,14 @@ const char *Leader::DomainPrefixEventToString(DomainPrefixEvent aEvent)
"Unchanged", // (3) kDomainPrefixUnchanged
};
static_assert(0 == kDomainPrefixAdded, "kDomainPrefixAdded value is incorrect");
static_assert(1 == kDomainPrefixRemoved, "kDomainPrefixRemoved value is incorrect");
static_assert(2 == kDomainPrefixRefreshed, "kDomainPrefixRefreshed value is incorrect");
static_assert(3 == kDomainPrefixUnchanged, "kDomainPrefixUnchanged value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kDomainPrefixAdded);
ValidateNextEnum(kDomainPrefixRemoved);
ValidateNextEnum(kDomainPrefixRefreshed);
ValidateNextEnum(kDomainPrefixUnchanged);
};
return kEventStrings[aEvent];
}
src/core/backbone_router/bbr_local.cpp
+7 -3
View File
@@ -449,9 +449,13 @@ const char *Local::ActionToString(Action aAction)
"Remove", // (2) kActionRemove
};
static_assert(0 == kActionSet, "kActionSet value is incorrect");
static_assert(1 == kActionAdd, "kActionAdd value is incorrect");
static_assert(2 == kActionRemove, "kActionRemove value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kActionSet);
ValidateNextEnum(kActionAdd);
ValidateNextEnum(kActionRemove);
};
return kActionStrings[aAction];
}
src/core/backbone_router/multicast_listeners_table.cpp
+7 -3
View File
@@ -142,9 +142,13 @@ void MulticastListenersTable::Log(Action aAction,
"Expire", // (2) kExpire
};
static_assert(0 == kAdd, "kAdd value is incorrect");
static_assert(1 == kRemove, "kRemove value is incorrect");
static_assert(2 == kExpire, "kExpire value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kAdd);
ValidateNextEnum(kRemove);
ValidateNextEnum(kExpire);
};
LogDebg("%s %s expire %lu: %s", kActionStrings[aAction], aAddress.ToString().AsCString(),
ToUlong(aExpireTime.GetValue()), ErrorToString(aError));
src/core/border_router/routing_manager.cpp
+30 -14
View File
@@ -893,9 +893,13 @@ const char *RoutingManager::RouterAdvOriginToString(RouterAdvOrigin aRaOrigin)
"(this BR other sw entity)", // (2) kThisBrOtherEntity
};
static_assert(0 == kAnotherRouter, "kAnotherRouter value is incorrect");
static_assert(1 == kThisBrRoutingManager, "kThisBrRoutingManager value is incorrect");
static_assert(2 == kThisBrOtherEntity, "kThisBrOtherEntity value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kAnotherRouter);
ValidateNextEnum(kThisBrRoutingManager);
ValidateNextEnum(kThisBrOtherEntity);
};
return kOriginStrings[aRaOrigin];
}
@@ -3010,10 +3014,14 @@ const char *RoutingManager::OnLinkPrefixManager::StateToString(State aState)
"Deprecating", // (3) kDeprecating
};
static_assert(0 == kIdle, "kIdle value is incorrect");
static_assert(1 == kPublishing, "kPublishing value is incorrect");
static_assert(2 == kAdvertising, "kAdvertising value is incorrect");
static_assert(3 == kDeprecating, "kDeprecating value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kIdle);
ValidateNextEnum(kPublishing);
ValidateNextEnum(kAdvertising);
ValidateNextEnum(kDeprecating);
};
return kStateStrings[aState];
}
@@ -3493,9 +3501,13 @@ const char *RoutingManager::RoutePublisher::StateToString(State aState)
"ula", // (2) kPublishUla
};
static_assert(0 == kDoNotPublish, "kDoNotPublish value is incorrect");
static_assert(1 == kPublishDefault, "kPublishDefault value is incorrect");
static_assert(2 == kPublishUla, "kPublishUla value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kDoNotPublish);
ValidateNextEnum(kPublishDefault);
ValidateNextEnum(kPublishUla);
};
return kStateStrings[aState];
}
@@ -4204,10 +4216,14 @@ const char *RoutingManager::PdPrefixManager::StateToString(State aState)
"Idle", // (3) kIdle
};
static_assert(0 == kDhcp6PdStateDisabled, "kDhcp6PdStateDisabled value is incorrect");
static_assert(1 == kDhcp6PdStateStopped, "kDhcp6PdStateStopped value is incorrect");
static_assert(2 == kDhcp6PdStateRunning, "kDhcp6PdStateRunning value is incorrect");
static_assert(3 == kDhcp6PdStateIdle, "kDhcp6PdStateIdle value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kDhcp6PdStateDisabled);
ValidateNextEnum(kDhcp6PdStateStopped);
ValidateNextEnum(kDhcp6PdStateRunning);
ValidateNextEnum(kDhcp6PdStateIdle);
};
return kStateStrings[aState];
}
src/core/common/message.cpp
+8 -4
View File
@@ -363,10 +363,14 @@ const char *Message::PriorityToString(Priority aPriority)
"net", // (3) kPriorityNet
};
static_assert(kPriorityLow == 0, "kPriorityLow value is incorrect");
static_assert(kPriorityNormal == 1, "kPriorityNormal value is incorrect");
static_assert(kPriorityHigh == 2, "kPriorityHigh value is incorrect");
static_assert(kPriorityNet == 3, "kPriorityNet value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kPriorityLow);
ValidateNextEnum(kPriorityNormal);
ValidateNextEnum(kPriorityHigh);
ValidateNextEnum(kPriorityNet);
};
return kPriorityStrings[aPriority];
}
src/core/common/settings.cpp
+33 -20
View File
@@ -129,15 +129,19 @@ const char *SettingsBase::ActionToString(Action aAction)
#endif
};
static_assert(0 == kActionRead, "kActionRead value is incorrect");
static_assert(1 == kActionSave, "kActionSave value is incorrect");
static_assert(2 == kActionResave, "kActionResave value is incorrect");
static_assert(3 == kActionDelete, "kActionDelete value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kActionRead);
ValidateNextEnum(kActionSave);
ValidateNextEnum(kActionResave);
ValidateNextEnum(kActionDelete);
#if OPENTHREAD_FTD
static_assert(4 == kActionAdd, "kActionAdd value is incorrect");
static_assert(5 == kActionRemove, "kActionRemove value is incorrect");
static_assert(6 == kActionDeleteAll, "kActionDeleteAll value is incorrect");
ValidateNextEnum(kActionAdd);
ValidateNextEnum(kActionRemove);
ValidateNextEnum(kActionDeleteAll);
#endif
};
return kActionStrings[aAction];
}
@@ -167,19 +171,28 @@ const char *SettingsBase::KeyToString(Key aKey)
"BorderAgentId" // (17) kKeyBorderAgentId
};
static_assert(1 == kKeyActiveDataset, "kKeyActiveDataset value is incorrect");
static_assert(2 == kKeyPendingDataset, "kKeyPendingDataset value is incorrect");
static_assert(3 == kKeyNetworkInfo, "kKeyNetworkInfo value is incorrect");
static_assert(4 == kKeyParentInfo, "kKeyParentInfo value is incorrect");
static_assert(5 == kKeyChildInfo, "kKeyChildInfo value is incorrect");
static_assert(7 == kKeySlaacIidSecretKey, "kKeySlaacIidSecretKey value is incorrect");
static_assert(8 == kKeyDadInfo, "kKeyDadInfo value is incorrect");
static_assert(11 == kKeySrpEcdsaKey, "kKeySrpEcdsaKey value is incorrect");
static_assert(12 == kKeySrpClientInfo, "kKeySrpClientInfo value is incorrect");
static_assert(13 == kKeySrpServerInfo, "kKeySrpServerInfo value is incorrect");
static_assert(15 == kKeyBrUlaPrefix, "kKeyBrUlaPrefix value is incorrect");
static_assert(16 == kKeyBrOnLinkPrefixes, "kKeyBrOnLinkPrefixes is incorrect");
static_assert(17 == kKeyBorderAgentId, "kKeyBorderAgentId is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
SkipNextEnum();
ValidateNextEnum(kKeyActiveDataset);
ValidateNextEnum(kKeyPendingDataset);
ValidateNextEnum(kKeyNetworkInfo);
ValidateNextEnum(kKeyParentInfo);
ValidateNextEnum(kKeyChildInfo);
SkipNextEnum();
ValidateNextEnum(kKeySlaacIidSecretKey);
ValidateNextEnum(kKeyDadInfo);
SkipNextEnum();
SkipNextEnum();
ValidateNextEnum(kKeySrpEcdsaKey);
ValidateNextEnum(kKeySrpClientInfo);
ValidateNextEnum(kKeySrpServerInfo);
SkipNextEnum();
ValidateNextEnum(kKeyBrUlaPrefix);
ValidateNextEnum(kKeyBrOnLinkPrefixes);
ValidateNextEnum(kKeyBorderAgentId);
};
static_assert(kLastKey == kKeyBorderAgentId, "kLastKey is not valid");
src/core/instance/instance.hpp
+1
View File
@@ -66,6 +66,7 @@
#include "radio/radio.hpp"
#include "utils/otns.hpp"
#include "utils/power_calibration.hpp"
#include "utils/static_counter.hpp"
#if OPENTHREAD_FTD || OPENTHREAD_MTD
#include "backbone_router/backbone_tmf.hpp"
src/core/meshcop/commissioner.cpp
+7 -3
View File
@@ -1117,9 +1117,13 @@ const char *Commissioner::StateToString(State aState)
"active", // (2) kStateActive
};
static_assert(kStateDisabled == 0, "kStateDisabled value is incorrect");
static_assert(kStatePetition == 1, "kStatePetition value is incorrect");
static_assert(kStateActive == 2, "kStateActive value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kStateDisabled);
ValidateNextEnum(kStatePetition);
ValidateNextEnum(kStateActive);
};
return kStateStrings[aState];
}
src/core/meshcop/joiner.cpp
+10 -6
View File
@@ -597,12 +597,16 @@ const char *Joiner::StateToString(State aState)
"Joined", // (5) kStateJoined
};
static_assert(kStateIdle == 0, "kStateIdle value is incorrect");
static_assert(kStateDiscover == 1, "kStateDiscover value is incorrect");
static_assert(kStateConnect == 2, "kStateConnect value is incorrect");
static_assert(kStateConnected == 3, "kStateConnected value is incorrect");
static_assert(kStateEntrust == 4, "kStateEntrust value is incorrect");
static_assert(kStateJoined == 5, "kStateJoined value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kStateIdle);
ValidateNextEnum(kStateDiscover);
ValidateNextEnum(kStateConnect);
ValidateNextEnum(kStateConnected);
ValidateNextEnum(kStateEntrust);
ValidateNextEnum(kStateJoined);
};
return kStateStrings[aState];
}
src/core/meshcop/secure_transport.cpp
+10 -6
View File
@@ -1215,12 +1215,16 @@ const char *SecureTransport::StateToString(State aState)
"CloseNotify", // (5) kStateCloseNotify
};
static_assert(0 == kStateClosed, "kStateClosed valid is incorrect");
static_assert(1 == kStateOpen, "kStateOpen valid is incorrect");
static_assert(2 == kStateInitializing, "kStateInitializing valid is incorrect");
static_assert(3 == kStateConnecting, "kStateConnecting valid is incorrect");
static_assert(4 == kStateConnected, "kStateConnected valid is incorrect");
static_assert(5 == kStateCloseNotify, "kStateCloseNotify valid is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kStateClosed);
ValidateNextEnum(kStateOpen);
ValidateNextEnum(kStateInitializing);
ValidateNextEnum(kStateConnecting);
ValidateNextEnum(kStateConnected);
ValidateNextEnum(kStateCloseNotify);
};
return kStateStrings[aState];
}
src/core/net/dns_dso.cpp
+30 -18
View File
@@ -1303,11 +1303,15 @@ const char *Dso::Connection::StateToString(State aState)
"SessionEstablished", // (4) kStateSessionEstablished,
};
static_assert(0 == kStateDisconnected, "kStateDisconnected value is incorrect");
static_assert(1 == kStateConnecting, "kStateConnecting value is incorrect");
static_assert(2 == kStateConnectedButSessionless, "kStateConnectedButSessionless value is incorrect");
static_assert(3 == kStateEstablishingSession, "kStateEstablishingSession value is incorrect");
static_assert(4 == kStateSessionEstablished, "kStateSessionEstablished value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kStateDisconnected);
ValidateNextEnum(kStateConnecting);
ValidateNextEnum(kStateConnectedButSessionless);
ValidateNextEnum(kStateEstablishingSession);
ValidateNextEnum(kStateSessionEstablished);
};
return kStateStrings[aState];
}
@@ -1320,9 +1324,13 @@ const char *Dso::Connection::MessageTypeToString(MessageType aMessageType)
"Unidirectional", // (2) kUnidirectionalMessage
};
static_assert(0 == kRequestMessage, "kRequestMessage value is incorrect");
static_assert(1 == kResponseMessage, "kResponseMessage value is incorrect");
static_assert(2 == kUnidirectionalMessage, "kUnidirectionalMessage value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kRequestMessage);
ValidateNextEnum(kResponseMessage);
ValidateNextEnum(kUnidirectionalMessage);
};
return kMessageTypeStrings[aMessageType];
}
@@ -1342,16 +1350,20 @@ const char *Dso::Connection::DisconnectReasonToString(DisconnectReason aReason)
"Unknown", // (9) kReasonUnknown
};
static_assert(0 == kReasonFailedToConnect, "kReasonFailedToConnect value is incorrect");
static_assert(1 == kReasonResponseTimeout, "kReasonResponseTimeout value is incorrect");
static_assert(2 == kReasonPeerDoesNotSupportDso, "kReasonPeerDoesNotSupportDso value is incorrect");
static_assert(3 == kReasonPeerClosed, "kReasonPeerClosed value is incorrect");
static_assert(4 == kReasonPeerAborted, "kReasonPeerAborted value is incorrect");
static_assert(5 == kReasonInactivityTimeout, "kReasonInactivityTimeout value is incorrect");
static_assert(6 == kReasonKeepAliveTimeout, "kReasonKeepAliveTimeout value is incorrect");
static_assert(7 == kReasonServerRetryDelayRequest, "kReasonServerRetryDelayRequest value is incorrect");
static_assert(8 == kReasonPeerMisbehavior, "kReasonPeerMisbehavior value is incorrect");
static_assert(9 == kReasonUnknown, "kReasonUnknown value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kReasonFailedToConnect);
ValidateNextEnum(kReasonResponseTimeout);
ValidateNextEnum(kReasonPeerDoesNotSupportDso);
ValidateNextEnum(kReasonPeerClosed);
ValidateNextEnum(kReasonPeerAborted);
ValidateNextEnum(kReasonInactivityTimeout);
ValidateNextEnum(kReasonKeepAliveTimeout);
ValidateNextEnum(kReasonServerRetryDelayRequest);
ValidateNextEnum(kReasonPeerMisbehavior);
ValidateNextEnum(kReasonUnknown);
};
return kDisconnectReasonStrings[aReason];
}
src/core/net/dnssd_server.cpp
+10 -6
View File
@@ -737,12 +737,16 @@ const char *Server::Response::QueryTypeToString(QueryType aType)
"A", // (5) kAQuery
};
static_assert(0 == kPtrQuery, "kPtrQuery value is incorrect");
static_assert(1 == kSrvQuery, "kSrvQuery value is incorrect");
static_assert(2 == kTxtQuery, "kTxtQuery value is incorrect");
static_assert(3 == kSrvTxtQuery, "kSrvTxtQuery value is incorrect");
static_assert(4 == kAaaaQuery, "kAaaaQuery value is incorrect");
static_assert(5 == kAQuery, "kAQuery value is incorrect");
struct EumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kPtrQuery);
ValidateNextEnum(kSrvQuery);
ValidateNextEnum(kTxtQuery);
ValidateNextEnum(kSrvTxtQuery);
ValidateNextEnum(kAaaaQuery);
ValidateNextEnum(kAQuery);
};
return kTypeNames[aType];
}
src/core/net/ip6.cpp
+8 -4
View File
@@ -1488,10 +1488,14 @@ const char *Ip6::EcnToString(Ecn aEcn)
"ce", // (3) kEcnMarked (Congestion Encountered)
};
static_assert(0 == kEcnNotCapable, "kEcnNotCapable value is incorrect");
static_assert(1 == kEcnCapable1, "kEcnCapable1 value is incorrect");
static_assert(2 == kEcnCapable0, "kEcnCapable0 value is incorrect");
static_assert(3 == kEcnMarked, "kEcnMarked value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kEcnNotCapable);
ValidateNextEnum(kEcnCapable1);
ValidateNextEnum(kEcnCapable0);
ValidateNextEnum(kEcnMarked);
};
return kEcnStrings[aEcn];
}
src/core/net/nat64_translator.cpp
+8 -4
View File
@@ -51,10 +51,14 @@ const char *StateToString(State aState)
"Active",
};
static_assert(0 == kStateDisabled, "kStateDisabled value is incorrect");
static_assert(1 == kStateNotRunning, "kStateNotRunning value is incorrect");
static_assert(2 == kStateIdle, "kStateIdle value is incorrect");
static_assert(3 == kStateActive, "kStateActive value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kStateDisabled);
ValidateNextEnum(kStateNotRunning);
ValidateNextEnum(kStateIdle);
ValidateNextEnum(kStateActive);
};
return kStateString[aState];
}
src/core/net/srp_client.cpp
+54 -34
View File
@@ -181,12 +181,16 @@ const uint32_t Client::TxJitter::kMaxJitters[] = {
void Client::TxJitter::Request(Reason aReason)
{
static_assert(0 == kOnDeviceReboot, "kOnDeviceReboot value is incorrect");
static_assert(1 == kOnServerStart, "kOnServerStart value is incorrect");
static_assert(2 == kOnServerRestart, "kOnServerRestart value is incorrect");
static_assert(3 == kOnServerSwitch, "kOnServerSwitch value is incorrect");
static_assert(4 == kOnSlaacAddrAdd, "kOnSlaacAddrAdd value is incorrect");
static_assert(5 == kOnSlaacAddrRemove, "kOnSlaacAddrRemove value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kOnDeviceReboot);
ValidateNextEnum(kOnServerStart);
ValidateNextEnum(kOnServerRestart);
ValidateNextEnum(kOnServerSwitch);
ValidateNextEnum(kOnSlaacAddrAdd);
ValidateNextEnum(kOnSlaacAddrRemove);
};
uint32_t maxJitter = kMaxJitters[aReason];
@@ -246,12 +250,16 @@ const char *Client::TxJitter::ReasonToString(Reason aReason)
"OnSlaacAddrRemove", // (5) kOnSlaacAddrRemove
};
static_assert(0 == kOnDeviceReboot, "kOnDeviceReboot value is incorrect");
static_assert(1 == kOnServerStart, "kOnServerStart value is incorrect");
static_assert(2 == kOnServerRestart, "kOnServerRestart value is incorrect");
static_assert(3 == kOnServerSwitch, "kOnServerSwitch value is incorrect");
static_assert(4 == kOnSlaacAddrAdd, "kOnSlaacAddrAdd value is incorrect");
static_assert(5 == kOnSlaacAddrRemove, "kOnSlaacAddrRemove value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kOnDeviceReboot);
ValidateNextEnum(kOnServerStart);
ValidateNextEnum(kOnServerRestart);
ValidateNextEnum(kOnServerSwitch);
ValidateNextEnum(kOnSlaacAddrAdd);
ValidateNextEnum(kOnSlaacAddrRemove);
};
return kReasonStrings[aReason];
}
@@ -315,12 +323,16 @@ const char *Client::AutoStart::StateToString(State aState)
"Unicast", // (5) kSelectedUnicast
};
static_assert(0 == kDisabled, "kDisabled value is incorrect");
static_assert(1 == kFirstTimeSelecting, "kFirstTimeSelecting value is incorrect");
static_assert(2 == kReselecting, "kReselecting value is incorrect");
static_assert(3 == kSelectedUnicastPreferred, "kSelectedUnicastPreferred value is incorrect");
static_assert(4 == kSelectedAnycast, "kSelectedAnycast value is incorrect");
static_assert(5 == kSelectedUnicast, "kSelectedUnicast value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kDisabled);
ValidateNextEnum(kFirstTimeSelecting);
ValidateNextEnum(kReselecting);
ValidateNextEnum(kSelectedUnicastPreferred);
ValidateNextEnum(kSelectedAnycast);
ValidateNextEnum(kSelectedUnicast);
};
return kStateStrings[aState];
}
@@ -359,22 +371,26 @@ Client::Client(Instance &aInstance)
, mGuardTimer(aInstance)
#endif
{
mHostInfo.Init();
// The `Client` implementation uses different constant array of
// `ItemState` to define transitions between states in `Pause()`,
// `Stop()`, `SendUpdate`, and `ProcessResponse()`, or to convert
// an `ItemState` to string. Here, we assert that the enumeration
// values are correct.
static_assert(kToAdd == 0, "kToAdd value is not correct");
static_assert(kAdding == 1, "kAdding value is not correct");
static_assert(kToRefresh == 2, "kToRefresh value is not correct");
static_assert(kRefreshing == 3, "kRefreshing value is not correct");
static_assert(kToRemove == 4, "kToRemove value is not correct");
static_assert(kRemoving == 5, "kRemoving value is not correct");
static_assert(kRegistered == 6, "kRegistered value is not correct");
static_assert(kRemoved == 7, "kRemoved value is not correct");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kToAdd);
ValidateNextEnum(kAdding);
ValidateNextEnum(kToRefresh);
ValidateNextEnum(kRefreshing);
ValidateNextEnum(kToRemove);
ValidateNextEnum(kRemoving);
ValidateNextEnum(kRegistered);
ValidateNextEnum(kRemoved);
};
mHostInfo.Init();
}
Error Client::Start(const Ip6::SockAddr &aServerSockAddr, Requester aRequester)
@@ -2554,12 +2570,16 @@ const char *Client::StateToString(State aState)
"ToRetry", // kStateToRetry (5)
};
static_assert(kStateStopped == 0, "kStateStopped value is not correct");
static_assert(kStatePaused == 1, "kStatePaused value is not correct");
static_assert(kStateToUpdate == 2, "kStateToUpdate value is not correct");
static_assert(kStateUpdating == 3, "kStateUpdating value is not correct");
static_assert(kStateUpdated == 4, "kStateUpdated value is not correct");
static_assert(kStateToRetry == 5, "kStateToRetry value is not correct");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kStateStopped);
ValidateNextEnum(kStatePaused);
ValidateNextEnum(kStateToUpdate);
ValidateNextEnum(kStateUpdating);
ValidateNextEnum(kStateUpdated);
ValidateNextEnum(kStateToRetry);
};
return kStateStrings[aState];
}
src/core/net/srp_server.cpp
+17 -9
View File
@@ -1719,8 +1719,12 @@ const char *Server::AddressModeToString(AddressMode aMode)
"anycast", // (1) kAddressModeAnycast
};
static_assert(kAddressModeUnicast == 0, "kAddressModeUnicast value is incorrect");
static_assert(kAddressModeAnycast == 1, "kAddressModeAnycast value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kAddressModeUnicast);
ValidateNextEnum(kAddressModeAnycast);
};
return kAddressModeStrings[aMode];
}
@@ -1931,13 +1935,17 @@ void Server::Service::Log(Action aAction) const
"KEY LEASE expired for", // (6) kKeyLeaseExpired
};
static_assert(0 == kAddNew, "kAddNew value is incorrect");
static_assert(1 == kUpdateExisting, "kUpdateExisting value is incorrect");
static_assert(2 == kKeepUnchanged, "kKeepUnchanged value is incorrect");
static_assert(3 == kRemoveButRetainName, "kRemoveButRetainName value is incorrect");
static_assert(4 == kFullyRemove, "kFullyRemove value is incorrect");
static_assert(5 == kLeaseExpired, "kLeaseExpired value is incorrect");
static_assert(6 == kKeyLeaseExpired, "kKeyLeaseExpired value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kAddNew);
ValidateNextEnum(kUpdateExisting);
ValidateNextEnum(kKeepUnchanged);
ValidateNextEnum(kRemoveButRetainName);
ValidateNextEnum(kFullyRemove);
ValidateNextEnum(kLeaseExpired);
ValidateNextEnum(kKeyLeaseExpired);
};
// We only log if the `Service` is marked as committed. This
// ensures that temporary `Service` entries associated with a
src/core/radio/trel_link.cpp
+8 -4
View File
@@ -471,10 +471,14 @@ const char *Link::StateToString(State aState)
"Transmit", // (3) kStateTransmit
};
static_assert(0 == kStateDisabled, "kStateDisabled value is incorrect");
static_assert(1 == kStateSleep, "kStateSleep value is incorrect");
static_assert(2 == kStateReceive, "kStateReceive value is incorrect");
static_assert(3 == kStateTransmit, "kStateTransmit value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kStateDisabled);
ValidateNextEnum(kStateSleep);
ValidateNextEnum(kStateReceive);
ValidateNextEnum(kStateTransmit);
};
return kStateStrings[aState];
}
src/core/thread/address_resolver.cpp
+19 -11
View File
@@ -1091,18 +1091,26 @@ void AddressResolver::LogCacheEntryChange(EntryChange aChange,
"removing eid", // (7) kReasonRemovingEid
};
static_assert(0 == kEntryAdded, "kEntryAdded value is incorrect");
static_assert(1 == kEntryUpdated, "kEntryUpdated value is incorrect");
static_assert(2 == kEntryRemoved, "kEntryRemoved value is incorrect");
struct ChangeEnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kEntryAdded);
ValidateNextEnum(kEntryUpdated);
ValidateNextEnum(kEntryRemoved);
};
static_assert(0 == kReasonQueryRequest, "kReasonQueryRequest value is incorrect");
static_assert(1 == kReasonSnoop, "kReasonSnoop value is incorrect");
static_assert(2 == kReasonReceivedNotification, "kReasonReceivedNotification value is incorrect");
static_assert(3 == kReasonRemovingRouterId, "kReasonRemovingRouterId value is incorrect");
static_assert(4 == kReasonRemovingRloc16, "kReasonRemovingRloc16 value is incorrect");
static_assert(5 == kReasonReceivedIcmpDstUnreachNoRoute, "kReasonReceivedIcmpDstUnreachNoRoute value is incorrect");
static_assert(6 == kReasonEvictingForNewEntry, "kReasonEvictingForNewEntry value is incorrect");
static_assert(7 == kReasonRemovingEid, "kReasonRemovingEid value is incorrect");
struct ReasonEnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kReasonQueryRequest);
ValidateNextEnum(kReasonSnoop);
ValidateNextEnum(kReasonReceivedNotification);
ValidateNextEnum(kReasonRemovingRouterId);
ValidateNextEnum(kReasonRemovingRloc16);
ValidateNextEnum(kReasonReceivedIcmpDstUnreachNoRoute);
ValidateNextEnum(kReasonEvictingForNewEntry);
ValidateNextEnum(kReasonRemovingEid);
};
LogInfo("Cache entry %s: %s, 0x%04x%s%s - %s", kChangeStrings[aChange], aEntry.GetTarget().ToString().AsCString(),
aEntry.GetRloc16(), (aList == nullptr) ? "" : ", list:", ListToString(aList), kReasonStrings[aReason]);
src/core/thread/link_quality.cpp
+8 -4
View File
@@ -225,10 +225,14 @@ uint8_t CostForLinkQuality(LinkQuality aLinkQuality)
kCostForLinkQuality3, // Link cost for `kLinkQuality3` (3).
};
static_assert(kLinkQuality0 == 0, "kLinkQuality0 is invalid");
static_assert(kLinkQuality1 == 1, "kLinkQuality1 is invalid");
static_assert(kLinkQuality2 == 2, "kLinkQuality2 is invalid");
static_assert(kLinkQuality3 == 3, "kLinkQuality3 is invalid");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kLinkQuality0);
ValidateNextEnum(kLinkQuality1);
ValidateNextEnum(kLinkQuality2);
ValidateNextEnum(kLinkQuality3);
};
uint8_t cost = Mle::kMaxRouteCost;
src/core/thread/mle.cpp
+36 -21
View File
@@ -3979,10 +3979,14 @@ const char *Mle::MessageActionToString(MessageAction aAction)
"Remove Delayed", // (3) kMessageRemoveDelayed
};
static_assert(kMessageSend == 0, "kMessageSend value is incorrect");
static_assert(kMessageReceive == 1, "kMessageReceive value is incorrect");
static_assert(kMessageDelay == 2, "kMessageDelay value is incorrect");
static_assert(kMessageRemoveDelayed == 3, "kMessageRemoveDelayed value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kMessageSend);
ValidateNextEnum(kMessageReceive);
ValidateNextEnum(kMessageDelay);
ValidateNextEnum(kMessageRemoveDelayed);
};
return kMessageActionStrings[aAction];
}
@@ -4030,10 +4034,9 @@ const char *Mle::MessageTypeToString(MessageType aType)
#endif
};
struct MessageTypeChecker
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kTypeAdvertisement);
ValidateNextEnum(kTypeAnnounce);
ValidateNextEnum(kTypeChildIdRequest);
@@ -4130,11 +4133,15 @@ const char *Mle::AttachModeToString(AttachMode aMode)
"BetterParent", // (4) kBetterParent
};
static_assert(kAnyPartition == 0, "kAnyPartition value is incorrect");
static_assert(kSamePartition == 1, "kSamePartition value is incorrect");
static_assert(kBetterPartition == 2, "kBetterPartition value is incorrect");
static_assert(kDowngradeToReed == 3, "kDowngradeToReed value is incorrect");
static_assert(kBetterParent == 4, "kBetterParent value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kAnyPartition);
ValidateNextEnum(kSamePartition);
ValidateNextEnum(kBetterPartition);
ValidateNextEnum(kDowngradeToReed);
ValidateNextEnum(kBetterParent);
};
return kAttachModeStrings[aMode];
}
@@ -4150,12 +4157,16 @@ const char *Mle::AttachStateToString(AttachState aState)
"ChildIdReq", // (5) kAttachStateChildIdRequest
};
static_assert(kAttachStateIdle == 0, "kAttachStateIdle value is incorrect");
static_assert(kAttachStateProcessAnnounce == 1, "kAttachStateProcessAnnounce value is incorrect");
static_assert(kAttachStateStart == 2, "kAttachStateStart value is incorrect");
static_assert(kAttachStateParentRequest == 3, "kAttachStateParentRequest value is incorrect");
static_assert(kAttachStateAnnounce == 4, "kAttachStateAnnounce value is incorrect");
static_assert(kAttachStateChildIdRequest == 5, "kAttachStateChildIdRequest value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kAttachStateIdle);
ValidateNextEnum(kAttachStateProcessAnnounce);
ValidateNextEnum(kAttachStateStart);
ValidateNextEnum(kAttachStateParentRequest);
ValidateNextEnum(kAttachStateAnnounce);
ValidateNextEnum(kAttachStateChildIdRequest);
};
return kAttachStateStrings[aState];
}
@@ -4169,10 +4180,14 @@ const char *Mle::ReattachStateToString(ReattachState aState)
"reattaching with Pending Dataset", // (3) kReattachPending
};
static_assert(kReattachStop == 0, "kReattachStop value is incorrect");
static_assert(kReattachStart == 1, "kReattachStart value is incorrect");
static_assert(kReattachActive == 2, "kReattachActive value is incorrect");
static_assert(kReattachPending == 3, "kReattachPending value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kReattachStop);
ValidateNextEnum(kReattachStart);
ValidateNextEnum(kReattachActive);
ValidateNextEnum(kReattachPending);
};
return kReattachStateStrings[aState];
}
src/core/thread/mle_types.cpp
+18 -9
View File
@@ -37,6 +37,7 @@
#include "common/code_utils.hpp"
#include "common/message.hpp"
#include "common/random.hpp"
#include "utils/static_counter.hpp"
namespace ot {
namespace Mle {
@@ -99,10 +100,14 @@ uint8_t DeviceProperties::CalculateLeaderWeight(void) const
kPowerExternalUnstableInc, // (3) kPowerSupplyExternalUnstable
};
static_assert(0 == kPowerSupplyBattery, "kPowerSupplyBattery value is incorrect");
static_assert(1 == kPowerSupplyExternal, "kPowerSupplyExternal value is incorrect");
static_assert(2 == kPowerSupplyExternalStable, "kPowerSupplyExternalStable value is incorrect");
static_assert(3 == kPowerSupplyExternalUnstable, "kPowerSupplyExternalUnstable value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kPowerSupplyBattery);
ValidateNextEnum(kPowerSupplyExternal);
ValidateNextEnum(kPowerSupplyExternalStable);
ValidateNextEnum(kPowerSupplyExternalUnstable);
};
uint8_t weight = kBaseWeight;
PowerSupply powerSupply = MapEnum(mPowerSupply);
@@ -195,11 +200,15 @@ const char *RoleToString(DeviceRole aRole)
"leader", // (4) kRoleLeader
};
static_assert(kRoleDisabled == 0, "kRoleDisabled value is incorrect");
static_assert(kRoleDetached == 1, "kRoleDetached value is incorrect");
static_assert(kRoleChild == 2, "kRoleChild value is incorrect");
static_assert(kRoleRouter == 3, "kRoleRouter value is incorrect");
static_assert(kRoleLeader == 4, "kRoleLeader value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kRoleDisabled);
ValidateNextEnum(kRoleDetached);
ValidateNextEnum(kRoleChild);
ValidateNextEnum(kRoleRouter);
ValidateNextEnum(kRoleLeader);
};
return (aRole < GetArrayLength(kRoleStrings)) ? kRoleStrings[aRole] : "invalid";
}
src/core/thread/neighbor.cpp
+12 -8
View File
@@ -241,14 +241,18 @@ const char *Neighbor::StateToString(State aState)
"Valid", // (7) kStateValid
};
static_assert(0 == kStateInvalid, "kStateInvalid value is incorrect");
static_assert(1 == kStateRestored, "kStateRestored value is incorrect");
static_assert(2 == kStateParentRequest, "kStateParentRequest value is incorrect");
static_assert(3 == kStateParentResponse, "kStateParentResponse value is incorrect");
static_assert(4 == kStateChildIdRequest, "kStateChildIdRequest value is incorrect");
static_assert(5 == kStateLinkRequest, "kStateLinkRequest value is incorrect");
static_assert(6 == kStateChildUpdateRequest, "kStateChildUpdateRequest value is incorrect");
static_assert(7 == kStateValid, "kStateValid value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kStateInvalid);
ValidateNextEnum(kStateRestored);
ValidateNextEnum(kStateParentRequest);
ValidateNextEnum(kStateParentResponse);
ValidateNextEnum(kStateChildIdRequest);
ValidateNextEnum(kStateLinkRequest);
ValidateNextEnum(kStateChildUpdateRequest);
ValidateNextEnum(kStateValid);
};
return kStateStrings[aState];
}
src/core/thread/network_data_publisher.cpp
+9 -5
View File
@@ -470,11 +470,15 @@ const char *Publisher::Entry::StateToString(State aState)
"Removing", // (4) kRemoving
};
static_assert(0 == kNoEntry, "kNoEntry value is not correct");
static_assert(1 == kToAdd, "kToAdd value is not correct");
static_assert(2 == kAdding, "kAdding value is not correct");
static_assert(3 == kAdded, "kAdded value is not correct");
static_assert(4 == kRemoving, "kRemoving value is not correct");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kNoEntry);
ValidateNextEnum(kToAdd);
ValidateNextEnum(kAdding);
ValidateNextEnum(kAdded);
ValidateNextEnum(kRemoving);
};
return kStateStrings[aState];
}
src/core/thread/uri_paths.cpp
+44 -40
View File
@@ -97,46 +97,50 @@ static constexpr Entry kEntries[] = {
static_assert(BinarySearch::IsSorted(kEntries), "kEntries is not sorted");
static_assert(0 == kUriAddressError, "kUriAddressError (`a/ae`) is invalid");
static_assert(1 == kUriAddressNotify, "kUriAddressNotify (`a/an`) is invalid");
static_assert(2 == kUriAddressQuery, "kUriAddressQuery (`a/aq`) is invalid");
static_assert(3 == kUriAddressRelease, "kUriAddressRelease (`a/ar`) is invalid");
static_assert(4 == kUriAddressSolicit, "kUriAddressSolicit (`a/as`) is invalid");
static_assert(5 == kUriServerData, "kUriServerData (`a/sd`) is invalid");
static_assert(6 == kUriAnycastLocate, "kUriAnycastLocate (`a/yl`) is invalid");
static_assert(7 == kUriBackboneAnswer, "kUriBackboneAnswer (`b/ba`) is invalid");
static_assert(8 == kUriBackboneMlr, "kUriBackboneMlr (`b/bmr`) is invalid");
static_assert(9 == kUriBackboneQuery, "kUriBackboneQuery (`b/bq`) is invalid");
static_assert(10 == kUriAnnounceBegin, "kUriAnnounceBegin (`c/ab`) is invalid");
static_assert(11 == kUriActiveGet, "kUriActiveGet (`c/ag`) is invalid");
static_assert(12 == kUriActiveReplace, "kUriActiveReplace (`c/ar`) is invalid");
static_assert(13 == kUriActiveSet, "kUriActiveSet (`c/as`) is invalid");
static_assert(14 == kUriCommissionerKeepAlive, "kUriCommissionerKeepAlive (`c/ca`) is invalid");
static_assert(15 == kUriCommissionerGet, "kUriCommissionerGet (`c/cg`) is invalid");
static_assert(16 == kUriCommissionerPetition, "kUriCommissionerPetition (`c/cp`) is invalid");
static_assert(17 == kUriCommissionerSet, "kUriCommissionerSet (`c/cs`) is invalid");
static_assert(18 == kUriDatasetChanged, "kUriDatasetChanged (`c/dc`) is invalid");
static_assert(19 == kUriEnergyReport, "kUriEnergyReport (`c/er`) is invalid");
static_assert(20 == kUriEnergyScan, "kUriEnergyScan (`c/es`) is invalid");
static_assert(21 == kUriJoinerEntrust, "kUriJoinerEntrust (`c/je`) is invalid");
static_assert(22 == kUriJoinerFinalize, "kUriJoinerFinalize (`c/jf`) is invalid");
static_assert(23 == kUriLeaderKeepAlive, "kUriLeaderKeepAlive (`c/la`) is invalid");
static_assert(24 == kUriLeaderPetition, "kUriLeaderPetition (`c/lp`) is invalid");
static_assert(25 == kUriPanIdConflict, "kUriPanIdConflict (`c/pc`) is invalid");
static_assert(26 == kUriPendingGet, "kUriPendingGet (`c/pg`) is invalid");
static_assert(27 == kUriPanIdQuery, "kUriPanIdQuery (`c/pq`) is invalid");
static_assert(28 == kUriPendingSet, "kUriPendingSet (`c/ps`) is invalid");
static_assert(29 == kUriRelayRx, "kUriRelayRx (`c/rx`) is invalid");
static_assert(30 == kUriRelayTx, "kUriRelayTx (`c/tx`) is invalid");
static_assert(31 == kUriProxyRx, "kUriProxyRx (`c/ur`) is invalid");
static_assert(32 == kUriProxyTx, "kUriProxyTx (`c/ut`) is invalid");
static_assert(33 == kUriDiagnosticGetAnswer, "kUriDiagnosticGetAnswer (`d/da`) is invalid");
static_assert(34 == kUriDiagnosticGetRequest, "kUriDiagnosticGetRequest (`d/dg`) is invalid");
static_assert(35 == kUriDiagnosticGetQuery, "kUriDiagnosticGetQuery (`d/dq`) is invalid");
static_assert(36 == kUriDiagnosticReset, "kUriDiagnosticReset (`d/dr`) is invalid");
static_assert(37 == kUriDuaRegistrationNotify, "kUriDuaRegistrationNotify (`n/dn`) is invalid");
static_assert(38 == kUriDuaRegistrationRequest, "kUriDuaRegistrationRequest (`n/dr`) is invalid");
static_assert(39 == kUriMlr, "kUriMlr (`n/mr`) is invalid");
struct UriEnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kUriAddressError);
ValidateNextEnum(kUriAddressNotify);
ValidateNextEnum(kUriAddressQuery);
ValidateNextEnum(kUriAddressRelease);
ValidateNextEnum(kUriAddressSolicit);
ValidateNextEnum(kUriServerData);
ValidateNextEnum(kUriAnycastLocate);
ValidateNextEnum(kUriBackboneAnswer);
ValidateNextEnum(kUriBackboneMlr);
ValidateNextEnum(kUriBackboneQuery);
ValidateNextEnum(kUriAnnounceBegin);
ValidateNextEnum(kUriActiveGet);
ValidateNextEnum(kUriActiveReplace);
ValidateNextEnum(kUriActiveSet);
ValidateNextEnum(kUriCommissionerKeepAlive);
ValidateNextEnum(kUriCommissionerGet);
ValidateNextEnum(kUriCommissionerPetition);
ValidateNextEnum(kUriCommissionerSet);
ValidateNextEnum(kUriDatasetChanged);
ValidateNextEnum(kUriEnergyReport);
ValidateNextEnum(kUriEnergyScan);
ValidateNextEnum(kUriJoinerEntrust);
ValidateNextEnum(kUriJoinerFinalize);
ValidateNextEnum(kUriLeaderKeepAlive);
ValidateNextEnum(kUriLeaderPetition);
ValidateNextEnum(kUriPanIdConflict);
ValidateNextEnum(kUriPendingGet);
ValidateNextEnum(kUriPanIdQuery);
ValidateNextEnum(kUriPendingSet);
ValidateNextEnum(kUriRelayRx);
ValidateNextEnum(kUriRelayTx);
ValidateNextEnum(kUriProxyRx);
ValidateNextEnum(kUriProxyTx);
ValidateNextEnum(kUriDiagnosticGetAnswer);
ValidateNextEnum(kUriDiagnosticGetRequest);
ValidateNextEnum(kUriDiagnosticGetQuery);
ValidateNextEnum(kUriDiagnosticReset);
ValidateNextEnum(kUriDuaRegistrationNotify);
ValidateNextEnum(kUriDuaRegistrationRequest);
ValidateNextEnum(kUriMlr);
};
} // namespace UriList
src/core/utils/slaac_address.cpp
+7 -3
View File
@@ -467,9 +467,13 @@ void Slaac::LogAddress(Action aAction, const SlaacAddress &aAddress)
"Deprecating", // (2) kDeprecating
};
static_assert(kAdding == 0, "kAdding value is incorrect");
static_assert(kRemoving == 1, "kRemoving value is incorrect");
static_assert(kDeprecating == 2, "kDeprecating value is incorrect");
struct EnumCheck
{
InitEnumValidatorCounter();
ValidateNextEnum(kAdding);
ValidateNextEnum(kRemoving);
ValidateNextEnum(kDeprecating);
};
LogInfo("%s %s", kActionStrings[aAction], aAddress.GetAddress().ToString().AsCString());
}
src/core/utils/static_counter.hpp
+2
View File
@@ -61,6 +61,8 @@ public:
static_assert(kEnumartor == StaticCounterValue(), #kEnumartor " value is incorrect"); \
StaticCounterIncr()
#define SkipNextEnum() StaticCounterIncr()
} // namespace ot
#endif // OT_UTILS_STATIC_COUNTER_HPP_