Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 123456]

C__ac_buffer
C__ac_buffer_builder
C__ac_istream
C__ac_ostream
C__ndef_msg
C__nfc_a_info
C__nfc_b_info
C__nfc_f_info
C__nfc_info
C__nfc_task
C__nfc_tech
C__pn512
C__pn512_registers
C__polling_options
C__QCBORDecodeNesting
C__QCBORTrackNesting
C__scheduler
C__transceiver
C__transceiver_impl
C__transport
C_mbed_error_ctx	Mbed_error_ctx struct
CCallbackBase::_model_function_object
C_QCBORDecodeContext
C_QCBOREncodeContext
C_QCBORItem	QCBORItem holds the type, value and other info for a decoded item returned by GetNextItem()
Cadv_data_flags_t	Set of advertising flags
CAdvertisingDataBuilder	Build advertising data
CAdvertisingDataParser	Parse and iterate over advertising data
CAdvertisingDataSimpleBuilder< DataSize >	Build advertising data
CAdvertisingEndEvent	Event produced when advertising ends
CAdvertisingParameters	Parameters defining the advertising process
CAdvertisingReportEvent	Event generated when an advertising packet is seen during passive scanning or a scan response is received during active scanning
CAdvertisingStartEvent	Event produced when advertising start
CAllArgs< B0, B1, B2, B3, B4, B5 >
CAllArgs< B0 >
CAllArgs< B0, B1 >
CAllArgs< B0, B1, B2 >
CAllArgs< B0, B1, B2, B3 >
CAllArgs< B0, B1, B2, B3, B4 >
CAllArgs< mbed::Callback< R()> >
CAllArgs< mbed::Callback< R(ARG0)>, ARG0 >
CAllArgs< mbed::Callback< R(ARG0, ARG1)>, ARG0, ARG1 >
CAnalogIn	An analog input, used for reading the voltage on a pin
CAnalogOut	An analog output, used for setting the voltage on a pin
Cargs_t	Flash algo argument structure Contains all registers that should be preserved
CATHandler	Class for sending AT commands and parsing AT responses
Cattest_token_ctx	The context for creating an attestation token
Cattribute_handle_range_t	Inclusive range of GATT attributes handles
Cband_t	Default user application maximum data size for transmission
►Cbase	Base class of all SafeBool instances
►CSafeBool< CallChainOfFunctionPointersWithContext< ContextType > >
CCallChainOfFunctionPointersWithContext< ContextType >	Function like object hosting a list of FunctionPointerWithContext
►CSafeBool< FunctionPointerWithContext< ContextType > >
CFunctionPointerWithContext< ContextType >	Function like object adapter over freestanding and member functions
CSafeBool< FunctionPointerWithContext< GattReadAuthCallbackParams * > >
CSafeBool< FunctionPointerWithContext< GattWriteAuthCallbackParams * > >
CSafeBool< FunctionPointerWithContext< const DiscoveredService * > >
CSafeBool< FunctionPointerWithContext< const DiscoveredCharacteristic * > >
CSafeBool< FunctionPointerWithContext< OnEventsToProcessCallbackContext * > >
►CSafeBool< T >	Safe conversion of objects in boolean context
CFunctionPointerWithContext< GattReadAuthCallbackParams * >
CFunctionPointerWithContext< GattWriteAuthCallbackParams * >
CFunctionPointerWithContext< const DiscoveredService * >
CFunctionPointerWithContext< const DiscoveredCharacteristic * >
CFunctionPointerWithContext< OnEventsToProcessCallbackContext * >
CBatteryService	BLE Battery service
CBLE	Abstract away BLE-capable radio transceivers or SOCs
►CBlockDevice	A hardware device capable of writing and reading blocks
CDataFlashBlockDevice	BlockDevice for DataFlash flash devices
CFlashIAPBlockDevice	BlockDevice using the FlashIAP API
CI2CEEBlockDevice	BlockDevice for I2C based flash device such as Microchip's 24LC or ATMEL's AT24C ranges
COSPIFBlockDevice	BlockDevice for SFDP based flash devices over OSPI bus
CQSPIFBlockDevice	BlockDevice for SFDP based flash devices over QSPI bus
CSDBlockDevice	SDBlockDevice class
CSPIFBlockDevice	BlockDevice for SFDP based flash devices over SPI bus
CBufferedBlockDevice	Block device which allows minimal read and program sizes (of 1) for the underlying BD using a buffer on the heap
CChainingBlockDevice	Block device for chaining multiple block devices with the similar block sizes at sequential addresses
CExhaustibleBlockDevice	Heap backed block device which simulates failures
CFlashSimBlockDevice	Flash simulating block device
CHeapBlockDevice	Lazily allocated heap-backed block device
CMBRBlockDevice	Block device for managing a Master Boot Record https://en.wikipedia.org/wiki/Master_boot_record
CObservingBlockDevice
CProfilingBlockDevice	Block device for measuring storage operations of another block device
CReadOnlyBlockDevice
CSlicingBlockDevice	Block device for mapping to a slice of another block device
CBounded< Rep, Min, Max >	Restrict values of an integer type to a defined range
Cbuf_pool_desc_t	Contain description of the memory pool used by the Cordio stack
Cbuffer_s	Generic buffer structure
Cbyte_array_t< array_size >	Model fixed size array values
►Cbyte_array_t< 6 >
Caddress_t	MAC address data type
CByteBuffer
CC_APDU	APDU Command structure
CC_APDU::C_APDUBody_t
CC_APDU::C_APDUHeader_t
►CCacheAlignedBuffer< DataT >	CacheAlignedBuffer is used by Mbed in locations where we need a cache-aligned buffer
CStaticCacheAlignedBuffer< uint8_t, _block_size >
CDynamicCacheAlignedBuffer< DataT >	CacheAlignedBuffer type which allocates its backing buffer on the heap
CStaticCacheAlignedBuffer< DataT, BufferSize >	CacheAlignedBuffer type designed for static allocation
CCacheAlignedBuffer< uint8_t >
Ccaliberation_params_t	Represents a calibration configuration
Ccalibration_params_t	Represents a calibration configuration
CCallback< Signature >	Callback class based on template specialization
CCallback< R()>
CCallback< R(ARG0)>
CCallback< R(ARG0, ARG1)>
CCallback< uint8_t(void)>
CCallback< void()>
CCallback< void(AudioEvent)>
CCallback< void(bool channel_busy)>
CCallback< void(bool, uint16_t)>
CCallback< void(CIoT_Supported_Opt)>
CCallback< void(const uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr)>
CCallback< void(int)>
CCallback< void(lorawan_event_t)>
CCallback< void(mbed::BlockDevice *)>
CCallback< void(nsapi_event_t, intptr_t)>
CCallback< void(uint8_t current_channel)>
CCallback< void(uint8_t up, int8_t device_id)>
CCallback< void(uint8_t, uint8_t)>
►CCallbackBase
CCallback< R(ArgTs...)>	Callback class based on template specialization
CM24srDriver::Callbacks	Object that contains all the callbacks fired by this class, each command has its own callback
►Ccan
►CCAN	A can bus client, used for communicating with can devices
CRawCAN	Creates an unlocked CAN interface connected to specific pins
►CCAN_Message	Holder for single CAN message
CCANMessage	CANMessage class
Ccan_pinmap_t
Ccc_ecc_25519_keygen_params
Ccc_ecc_ws_comp_shared_params
Ccc_ecc_ws_keygen_params
Ccc_ecc_ws_sign_params
Ccc_ecc_ws_verify_params
Ccell_callback_data_t
Ccell_signal_quality_t
►CCellularDevice	Class CellularDevice
►CAT_CellularDevice	Class AT_CellularDevice
CALT1250_PPP
CGEMALTO_CINTERION
CGENERIC_AT3GPP	Generic Cellular module which can be used as a default module when porting new cellular module
CRM1000_AT
►CSARA4_PPP
CONBOARD_SARA4_PPP
►CTELIT_HE910
CONBOARD_TELIT_HE910
CONBOARD_TELIT_HE910
►CTELIT_ME310
CONBOARD_TELIT_ME310
►CTELIT_ME910
CONBOARD_TELIT_ME910
►CCellularInformation	Class CellularInformation
►CAT_CellularInformation	Class AT_CellularInformation
CGEMALTO_CINTERION_CellularInformation
CCellularList< T >	Class CellularList
CCellularList< packet_t >
►CCellularNetwork	An abstract interface for connecting to a network and getting information from it
►CAT_CellularNetwork	Class AT_CellularNetwork
CALT1250_PPP_CellularNetwork
CRM1000_AT_CellularNetwork
CSARA4_PPP_CellularNetwork
CTELIT_ME310_CellularNetwork
CTELIT_ME910_CellularNetwork
CAT_CellularStack::CellularSocket
CCellularStateMachine	CellularStateMachine class
CChainableEventHandler< T >	Base class for chainable EventHandlers
►CChainableEventHandler< ble::Gap::EventHandler >
CChainableGapEventHandler	Gap::EventHandler implementation that allows the application to register multiple separate EventHandlers to be called when Gap events happen
►CChainableEventHandler< ble::GattServer::EventHandler >
CChainableGattServerEventHandler	GattServer::EventHandler implementation that allows the application to register multiple separate EventHandlers to be called when GattServer events happen
Cchannel_params_t	DO NOT MODIFY, WILL BREAK THE API!
CCharacteristicDescriptorDiscovery	Definitions of events and event handlers that the characteristic descriptor discovery procedure uses
CCircularBuffer< T, BufferSize, CounterType >	Templated Circular buffer class
CCircularBuffer< char, 256 >
CClock	A C++11 chrono TrivialClock for the kernel millisecond tick count
CCommandData_t	User parameter used to invoke a command, it is used to provide the data back with the response
CConnectionCompleteEvent	Event generated when a connection initiation ends (successfully or not)
CConnectionParameters	Parameters defining the connection initiation process
CConnectionParametersUpdateCompleteEvent	Event received when connection parameters have been updated
►CControlPlane_netif	Implements support for data transfer using Control Plane CIoT EPS optimization specified in 3GPP 23.401(4.10), 3GPP 23.682(4.5.14)
CAT_ControlPlane_netif
►CCordioHCIDriver	Base class of the HCI driver use by the BLE port of the Cordio stack
CAP3CordioHCIDriver
CNRFCordioHCIDriver	Nordic port of CordioHCIDriver
►CCordioHCITransportDriver	Base class of the HCI transport driver
CAP3CordioHCITransportDriver
CH4TransportDriver	Implementation of the H4 driver
CNRFCordioHCITransportDriver	Nordic port of CordioHCITransportDriver
CIPCPipeTransportDriver	Implementation of the H4 driver over PSoC6 IPC pipe
CCyH4TransportDriver	Implementation of the H4 driver over Cypress based chips
Ccore_util_atomic_flag	A lock-free, primitive atomic flag
Ccrc_mbed_config
CCriticalSectionLock	RAII object for disabling, then restoring, interrupt state Usage:
►CCThunkBase
CCThunk< T >	Class for created a pointer with data bound to it
Cloramac_frame_ctrl_t::ctrl_bits_s
Ccy_hw_crypto_t	CRYPTO object
CDeepSleepLock	RAII object for disabling, then restoring the deep sleep mode Usage:
CSimpleMessageParser::Delegate	Delegate invoked when the parser raise an event
CGenericRecordParser< ParserImplementation, ParsingResult >::Delegate	Handle that receives parsed values
►CMessageParser::Delegate	Report parsing event to the application
CSimpleMessageParser	Basic message parser that aggregates URIParser, TextParser and MimeParser
CNFCController::Delegate	The NFCController delegate
►CNFCControllerDriver::Delegate	The NFCControllerDriver delegate
CNFCController	This class represents a NFC Controller
►CNFCEEPROMDriver::Delegate	The NFCEEPROMDriver delegate
CNFCEEPROM	The NFC EEPROM class represents a NFC target device connected using a wired link (I2C, SPI, etc)
►CNFCNDEFCapable::Delegate
CNFCRemoteInitiator::Delegate	The NFCRemoteInitiator delegate
►CNFCTarget::Delegate
CNFCEEPROM::Delegate	The NFCEEPROM delegate
►CNFCRemoteEndpoint::Delegate	The NFCRemoteEndpoint base delegate
CNFCRemoteInitiator::Delegate	The NFCRemoteInitiator delegate
►CPN512TransportDriver::Delegate	The PN512TransportDriver delegate
CPN512Driver
►CDelegate
CSimpleMessageParser	Basic message parser that aggregates URIParser, TextParser and MimeParser
►CDelegate
CSimpleMessageParser	Basic message parser that aggregates URIParser, TextParser and MimeParser
►CDelegate
CSimpleMessageParser	Basic message parser that aggregates URIParser, TextParser and MimeParser
Cdevice_err_t	AT response error with error code and type
CDeviceInformationService	BLE Device Information Service Service: https://developer.bluetooth.org/gatt/services/Pages/ServiceViewer.aspx?u=org.bluetooth.service.device_information.xml Manufacturer Name String Char: https://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.manufacturer_name_string.xml
CDigitalIn	A digital input, used for reading the state of a pin
CDigitalInOut	A digital input/output, used for setting or reading a bi-directional pin
CDigitalOut	A digital output, used for setting the state of a pin
Cdirent
CDisconnectionCompleteEvent	Event produced when a disconnection is complete
CDiscoveredCharacteristic	Representation of a characteristic discovered
CDiscoveredCharacteristicDescriptor	Representation of a characteristic descriptor discovered
CDiscoveredService	Representation of a GATT service discovered
CCharacteristicDescriptorDiscovery::DiscoveryCallbackParams_t	Characteristic descriptor discovered event
►Cdisjunction
Ccan_null_check< F >
►CDNS	Base class for DNS provider
►CNetworkInterface	Common interface that is shared between network devices
►CCellularInterface	Common interface that is shared between cellular interfaces
►CCellularContext	CellularContext is CellularInterface/NetworkInterface with extensions for cellular connectivity
►CAT_CellularContext
CALT1250_PPP_CellularContext
CGEMALTO_CINTERION_CellularContext
CRM1000_AT_CellularContext
CTELIT_ME310_CellularContext
CTELIT_ME910_CellularContext
►CEMACInterface	EMACInterface class Implementation of the NetworkInterface for an EMAC-based driver
CEthernetInterface	Implementation of the NetworkStack for an EMAC-based Ethernet driver
►CEthInterface	Common interface between Ethernet hardware
CEthernetInterface	Implementation of the NetworkStack for an EMAC-based Ethernet driver
CNanostackEthernetInterface	Ethernet interface for Nanostack
►CInterfaceNanostack
►CMeshInterfaceNanostack
CLoWPANNDInterface	6LoWPAN-ND mesh network interface class
CThreadInterface	Thread mesh network interface class
CWisunInterface	Wi-SUN mesh network interface class
CNanostackEthernetInterface	Ethernet interface for Nanostack
CL3IPInterface	L3IPInterface class Implementation of the NetworkInterface for an IP-based driver
►CMeshInterface	Common interface that is shared between mesh hardware
CMeshInterfaceNanostack
CPPPInterface	PPPInterface class Implementation of the NetworkInterface for an PPP-service
CWiFiInterface	Common interface between Wi-Fi devices
►CNetworkStack	NetworkStack class
►COnboardNetworkStack	Mbed OS API for onboard IP stack abstraction
CNanostack
►CAT_CellularStack	Class AT_CellularStack
CGEMALTO_CINTERION_CellularStack
CRM1000_AT_CellularStack
CTELIT_ME310_CellularStack
Cdr_range_t	DO NOT MODIFY, WILL BREAK THE API!
CDuration< Rep, TB, Range, Forever >	Model BLE durations
Cecc_key_t	Structure definition to carry pointer and size information about an Elliptic curve key which is stored in a buffer(key_buf) in raw format (without encoding):
CAdvertisingDataParser::element_t	Representation of an Advertising Data element
►CEMAC	This interface should be used to abstract low level access to networking hardware All operations receive a void * hardware pointer which an EMAC device provides when it is registered with a stack
CEMW3080B_EMAC
CWICED_EMAC
CEndpointResolver	Utility class for resolving endpoints
Cwhitelist_t::entry_t	BLE address representation
CEnvironmentalService	BLE Environmental Service
Cequeue
Cequeue::equeue_background
Cequeue_event
Cequeue::equeue_slab
CEvent< F >	Event
CEvent< void(ArgTs...)>	Event
►CGap::EventHandler	Definition of the general handler of Gap related events
CChainableGapEventHandler	Gap::EventHandler implementation that allows the application to register multiple separate EventHandlers to be called when Gap events happen
CLinkLossService	This service defines behavior when a link is lost between two devices
CGattClient::EventHandler	Definition of the general handler of GattClient related events
►CGattServer::EventHandler	Definition of the general handler of GattServer related events
CChainableGattServerEventHandler	GattServer::EventHandler implementation that allows the application to register multiple separate EventHandlers to be called when GattServer events happen
CSecurityManager::EventHandler	The stack will use these functions to signal events to the application, subclass to override handlers
CFATFS
CFATFS_DIR
CFFOBJID
Cdr_range_t::fields_s	The structure to store the minimum and the maximum datarate
CFIL
CFilePath	Class FilePath
CFILINFO
Cflags_check_capture
Cflash_algo_t	Target flash algorithm structure
Cflash_s	Target flash configuration For targets not supporting TrustZone, its flash_set_target_config must define target_config
Cflash_target_config_t	Flash configuration structure
CGap	Define device discovery, connection and link management procedures
CGattAttribute	Representation of a GattServer attribute
►CGattCharacteristic	Representation of a GattServer characteristic
CReadOnlyGattCharacteristic< uint8_t >
CReadOnlyGattCharacteristic< TemperatureType_t >
CReadOnlyGattCharacteristic< HumidityType_t >
CReadOnlyGattCharacteristic< PressureType_t >
CReadOnlyGattCharacteristic< TemperatureValueBytes >
CReadWriteGattCharacteristic< uint8_t >
CReadOnlyArrayGattCharacteristic< T, NUM_ELEMENTS >	Helper class that represents a read-only GattCharacteristic with an array value
CReadOnlyGattCharacteristic< T >	Helper class that represents a read only GattCharacteristic
CReadWriteArrayGattCharacteristic< T, NUM_ELEMENTS >	Helper class that represents a readable and writable GattCharacteristic with an array value
CReadWriteGattCharacteristic< T >	Helper class that represents a readable and writable GattCharacteristic
CWriteOnlyArrayGattCharacteristic< T, NUM_ELEMENTS >	Helper class that represents a write-only GattCharacteristic with an array value
CWriteOnlyGattCharacteristic< T >	Helper class that represents a write only GattCharacteristic
CGattClient	Define procedures required for interacting with a distant GATT server
CGattDataSentCallbackParams	Gatt Data Sent Attribute related events
CGattHVXCallbackParams	Handle Value Notification/Indication event
CGattReadAuthCallbackParams	GATT read authorization request event
CGattReadCallbackParams	GATT Read event definition
CGattServer	Construct and operates a GATT server
CGattService	Representation of a GattServer service
CGattUpdatesChangedCallbackParams	Gatt Updates Changed Attribute related events
CGattWriteAuthCallbackParams	GATT write authorization request event
CGattWriteCallbackParams	GATT Write event definition
Cgpio_capabilities_t	GPIO capabilities for a given pin
Cloramac_mhdr_t::hdr_bits_s
CHeader	Set of constants of a record header
CHealthThermometerService	BLE Health Thermometer Service
CHeartRateService	BLE Heart Rate Service
CHeartRateService::HeartRateValueBytes
CHID_REPORT
CHighResClock	A C++11 Clock representing the HAL us_ticker
Ci2c_pinmap_t
Ci2c_t	Asynch I2C HAL structure
CI2CSlave	An I2C Slave, used for communicating with an I2C Master device
CIEEE754_union
Cinfo	The key size
CKVStore::info	Holds key information
CBLE::InitializationCompleteCallbackContext	Initialization complete event
►COnboardNetworkStack::Interface	Representation of a stack's view of an interface
►CNanostack::Interface
CNanostack::EthernetInterface
CNanostack::MeshInterface
CNanostack::PPPInterface
Cis_convertible< From, To >
Cis_unsigned< T >
Cis_unsigned< unsigned char >
Cis_unsigned< unsigned int >
Cis_unsigned< unsigned long >
Cis_unsigned< unsigned long long >
Cis_unsigned< unsigned short >
Ckv_map_entry_t	This structure maps between a string name and a partition configuration
►CKVStore	KVStore class
CFileSystemStore	FileSystemStore is a lightweight implementation of the KVStore interface over file systems
CSecureStore	SecureStore class
CTDBStore	Tiny Database Storage (TDBStore) is a lightweight module that stores data on flash storage
Ckvstore_config_t	This structure represent a KVStore partition configuration
CL3IP	This interface should be used to abstract low level access to networking hardware All operations receive a void * hardware pointer which an l3ip device provides when it is registered with a stack
Clfs
Clfs2
Clfs2_attr
Clfs2_cache	Internal littlefs data structures ///
Clfs2_config
Clfs2_file::lfs2_ctz
Clfs2_dir
Clfs2_file
Clfs2_file_config
Clfs2_filebd
Clfs2_filebd_config
Clfs2::lfs2_free
Clfs2_gstate
Clfs2_info
Clfs2_mdir
Clfs2::lfs2_mlist
Clfs2_rambd
Clfs2_rambd_config
Clfs2_superblock
Clfs2_testbd
Clfs2_testbd_config
Clfs_cache
Clfs_config
Clfs_dir
Clfs_dir::lfs_disk_dir
Clfs_entry::lfs_disk_entry
Clfs_superblock::lfs_disk_superblock
Clfs_emubd
Clfs_entry	Littlefs data structures ///
Clfs_file
Clfs_file_config
Clfs_free
Clfs_info
Clfs_superblock
►CLinkedListBase
CLinkedList< events::TaskBase >
CLinkedList< T >
►CLinkEntry
CAsyncOp	Base class for asynchronous operations in the USB stack
►CTaskBase	TaskBase
CTask< R()>
CTask< R(ARG0)>
CTask< R(ARG0, ARG1)>	Task
Clora_channelplan	DO NOT MODIFY, WILL BREAK THE API!
Clora_channels_s	DO NOT MODIFY, WILL BREAK THE API!
Clora_mac_system_params_t
Cloramac_frame_ctrl_t
Cloramac_keys
Cloramac_mcps_confirm_t
Cloramac_mcps_indication_t
Cloramac_mhdr_t
Cloramac_mlme_confirm_t
Cloramac_mlme_indication_t
Cloramac_protocol_params
Cloramac_rx_message_t	Loramac_rx_message_t
Cloramac_tx_message_t	Stack level TX message structure
►CLoRaRadio	Interface for the radios, containing the main functions that a radio needs, and five callback functions
CSTM32WL_LoRaRadio
CSX126X_LoRaRadio
CSX1272_LoRaRadio	Radio driver implementation for Semtech SX1272 plus variants
CSX1276_LoRaRadio	Radio driver implementation for Semtech SX1272 plus variants
Clorawan_app_callbacks_t	Stack level callback functions
Clorawan_connect	Lorawan_connect_t structure
Clorawan_connect_abp_t	The lorawan_connect_abp structure
Clorawan_connect_otaa_t	The lorawan_connect_otaa structure
Clorawan_rx_metadata	Meta-data collection for the received packet
Clorawan_session	LoRaWAN session
Clorawan_timers
Clorawan_tx_metadata	Meta-data collection for a transmission
CLoRaWANInterface	LoRaWANInterface Class A network interface for LoRaWAN
CLoRaWANTimeHandler	/ _____) _ | | ( (____ _____ ____ _| |_ _____ ____| |__ ____ | ___ | (_ _) ___ |/ ___) _ \ _____) ) ____| | | || |_| ____( (___| | | | (______/|_____)_|_|_| __)_____)____)_| |_| (C)2013 Semtech
CLowPowerClock	A C++11 Clock representing the HAL lp_ticker
CLowPowerTickerWrapper
Cmbed_fault_context_t
Cmbed_stats_cpu_t	Struct mbed_stats_cpu_t definition
Cmbed_stats_heap_t	Struct mbed_stats_heap_t definition
Cmbed_stats_socket_t	Structure to parse socket statistics
Cmbed_stats_stack_t	Struct mbed_stats_stack_t definition
Cmbed_stats_sys_t	Struct mbed_stats_sys_t definition
Cmbed_stats_thread_t	Struct mbed_stats_thread_t definition
CMbedCRC< polynomial, width, mode_limit >	CRC object provides CRC generation through hardware or software
Cmbedtls_aes_context	The AES context-type definition
Cmbedtls_arc4_context	ARC4 context structure
Cmbedtls_aria_context	The ARIA context-type definition
Cmbedtls_asn1_bitstring	Container for ASN1 bit strings
Cmbedtls_asn1_buf	Type-length-value structure that allows for ASN1 using DER
Cmbedtls_asn1_named_data	Container for a sequence or list of 'named' ASN.1 data items
Cmbedtls_asn1_sequence	Container for a sequence of ASN.1 items
Cmbedtls_blowfish_context	Blowfish context structure
Cmbedtls_camellia_context	CAMELLIA context structure
Cmbedtls_ccm_context	The CCM context-type definition
Cmbedtls_chacha20_context
Cmbedtls_chachapoly_context
Cmbedtls_cipher_base_t	Base cipher information
Cmbedtls_cipher_context_t	Generic cipher context
Cmbedtls_cipher_definition_t
Cmbedtls_cipher_info_t	Cipher information
Cmbedtls_cmac_context_t	The CMAC context structure
Cmbedtls_ctr_drbg_context	The CTR_DRBG context structure
Cmbedtls_des3_context	Triple-DES context structure
Cmbedtls_des_context	DES context structure
Cmbedtls_dhm_context	The DHM context structure
Cmbedtls_ecdh_context	The ECDH context structure
Cmbedtls_ecdh_context_mbed	The context used by the default ECDH implementation
Cmbedtls_ecjpake_context	EC J-PAKE context structure
Cmbedtls_ecp_curve_info	Curve information, for use by other modules
Cmbedtls_ecp_group	The ECP group structure
Cmbedtls_ecp_keypair	The ECP key-pair structure
Cmbedtls_ecp_point	The ECP point structure, in Jacobian coordinates
Cmbedtls_entropy_context	Entropy context structure
Cmbedtls_entropy_source_state	Entropy source state
Cmbedtls_gcm_context	The GCM context structure
Cmbedtls_havege_state	HAVEGE state structure
Cmbedtls_hmac_drbg_context	HMAC_DRBG context
Cmbedtls_md2_context	MD2 context structure
Cmbedtls_md4_context	MD4 context structure
Cmbedtls_md5_context	MD5 context structure
Cmbedtls_md_context_t	The generic message-digest context
Cmbedtls_md_info_t	Message digest information
Cmbedtls_mpi	MPI structure
Cmbedtls_net_context	Wrapper type for sockets
Cmbedtls_nist_kw_context	The key wrapping context-type definition
Cmbedtls_oid_descriptor_t	Base OID descriptor structure
Cmbedtls_pk_context	Public key container
Cmbedtls_pk_debug_item	Item to send to the debug module
Cmbedtls_pk_info_t
Cmbedtls_pk_rsassa_pss_options	Options for RSASSA-PSS signature verification
Cmbedtls_platform_context	The platform context structure
Cmbedtls_poly1305_context
Cmbedtls_psa_stats_s	Statistics about resource consumption related to the PSA keystore
Cmbedtls_rand_func_container
Cmbedtls_record
Cmbedtls_ripemd160_context	RIPEMD-160 context structure
Cmbedtls_rsa_context	The RSA context structure
Cmbedtls_sha1_context	The SHA-1 context structure
Cmbedtls_sha256_context	The SHA-256 context structure
Cmbedtls_sha512_context	The SHA-512 context structure
Cmbedtls_ssl_cache_context	Cache context
Cmbedtls_ssl_cache_entry	This structure is used for storing cache entries
Cmbedtls_ssl_ciphersuite_t	This structure is used for storing ciphersuite information
Cmbedtls_ssl_config	SSL/TLS configuration to be shared between mbedtls_ssl_context structures
Cmbedtls_ssl_context
Cmbedtls_ssl_cookie_ctx	Context for the default cookie functions
Cmbedtls_ssl_handshake_params
Cmbedtls_ssl_key_set	The data structure holding the cryptographic material (key and IV) used for record protection in TLS 1.3
Cmbedtls_ssl_premaster_secret
Cmbedtls_ssl_session
Cmbedtls_ssl_ticket_context	Context for session ticket handling functions
Cmbedtls_ssl_ticket_key	Information for session ticket protection
Cmbedtls_ssl_tls1_3_labels_struct
Cmbedtls_ssl_tls1_3_labels_union
Cmbedtls_ssl_transform
Cmbedtls_timing_delay_context	Context for mbedtls_timing_set/get_delay()
Cmbedtls_timing_hr_time	Timer structure
Cmbedtls_x509_crl	Certificate revocation list structure
Cmbedtls_x509_crl_entry	Certificate revocation list entry
Cmbedtls_x509_crt	Container for an X.509 certificate
Cmbedtls_x509_crt_profile	Security profile for certificate verification
Cmbedtls_x509_crt_verify_chain	Verification chain as built by mbedtls_crt_verify_chain()
Cmbedtls_x509_crt_verify_chain_item	Item in a verification chain: cert and flags for it
Cmbedtls_x509_csr	Certificate Signing Request (CSR) structure
Cmbedtls_x509_san_other_name	From RFC 5280 section 4.2.1.6: OtherName ::= SEQUENCE { type-id OBJECT IDENTIFIER, value [0] EXPLICIT ANY DEFINED BY type-id }
Cmbedtls_x509_subject_alternative_name	A structure for holding the parsed Subject Alternative Name, according to type
Cmbedtls_x509_time	Container for date and time (precision in seconds)
Cmbedtls_x509write_cert	Container for writing a certificate (CRT)
Cmbedtls_x509write_csr	Container for writing a CSR
Cmbedtls_xtea_context	XTEA context structure
Cmd5_context	/
Cmember_type< T >
Cmesh_mac_statistics_t	Mesh physical layer statistics
Cmesh_nw_statistics_t	Mesh network statistics
CMessageBuilder	Construct a NDEF Message
CMessageParser	Event driven NDEF Message parser
CMIDIMessage	A MIDI message container
CMime	Represent a mime object
CMKFS_PARM
Cmlme_cw_tx_mode_t
Cmlme_join_req_t
Cmodulation_params_t	The type describing the modulation parameters for every packet types
CMsgHeaderIterator	Allows iteration through the list of message headers received in the control parameter of the socket_sendto_control / socket_recvfrom_control methods
Cmulticast_params_s
Cmx_buf	Structure for an MX wifi buffer
CNanostackLockGuard	RAII style Nanostack mutex acquisition
►CNanostackPhy	PHY driver class for Nanostack
►CNanostackMACPhy	MAC PHY driver class for Nanostack
CNanostackEthernetPhy	Ethernet PHY driver class for Nanostack
CNanostackRfPhy	Radio PHY driver class for Nanostack
CNanostackPPPPhy	PPP PHY driver class for Nanostack
Cnetif
►CNetStackMemoryManager
►CEMACMemoryManager
CNanostackMemoryManager
Cnfc_rf_protocols_bitmask_t
Cnfc_tech_iso7816
Cnfc_tech_iso7816_app
Cnfc_tech_iso7816_c_apdu
Cnfc_tech_iso7816_r_apdu
Cnfc_tech_isodep_target
Cnfc_tech_type4_target
►CNFCControllerDriver	The abstraction for a NFC controller driver
CPN512Driver
►CNFCEEPROMDriver	The abstraction for a NFC EEPROM driver
CM24srDriver	Class representing a M24SR component
►CNFCNDEFCapable	The base class for all endpoints that can support NDEF content
►CNFCRemoteInitiator	This class represents a remote NFC initiator (the local controller being in target mode)
CType4RemoteInitiator	This class is an implementation of the Type 4 tag application
►CNFCTarget	This class represents a NFC target (either a remote target when the local controller in in initiator mode, or a target connected through a wired connection)
CNFCEEPROM	The NFC EEPROM class represents a NFC target device connected using a wired link (I2C, SPI, etc)
►CNFCRemoteEndpoint	This is the base class for all remote endpoints (initiators and targets) addressable over the air interface
CNFCRemoteInitiator	This class represents a remote NFC initiator (the local controller being in target mode)
►CNonCopyable< T >	Prevents generation of copy constructor and copy assignment operator in derived classes
CSysTimer< Period, IRQ >	The SysTimer class is used to provide timing for system suspension, and the idle loop in TICKLESS mode
►CNonCopyable< ATCmdParser >
CATCmdParser	Parser class for parsing AT commands
►CNonCopyable< BufferedSerial >
►CBufferedSerial	Class providing buffered UART communication functionality using separate circular buffer for send and receive channels
CEMW3080B_UART
►CNonCopyable< BusIn >
CBusIn	A digital input bus, used for reading the state of a collection of pins
►CNonCopyable< BusInOut >
CBusInOut	A digital input output bus, used for setting the state of a collection of pins
►CNonCopyable< BusOut >
CBusOut	A digital output bus, used for setting the state of a collection of pins
►CNonCopyable< ConditionVariable >
CConditionVariable	Synchronization primitive that allows threads to wait until a particular condition occurs
►CNonCopyable< DeviceKey >
CDeviceKey	Use this singleton if you need to derive a new key from the device root of trust
►CNonCopyable< DirHandle >
►CDirHandle	Represents a directory stream
CDir	Dir class
►CNonCopyable< EventFlags >
CEventFlags	Used to control event flags or wait for event flags other threads control
►CNonCopyable< EventQueue >
CEventQueue	EventQueue
►CNonCopyable< FileBase >
►CFileBase	Class FileBase
►CFileLike	Class FileLike
►CStream	File stream
CUSBKeyboard	USBKeyboard example
CUSBMouseKeyboard	USBMouseKeyboard example
CUSBSerial	USBSerial example
►CFileSystemLike	A filesystem-like object is one that can be used to open file-like objects though it by fopen("/name/filename", mode)
►CFileSystem	A file system object
CFATFileSystem	FAT file system based on ChaN's FAT file system library v0.8
CLittleFileSystem	LittleFileSystem, a little file system
CLittleFileSystem2	LittleFileSystem2, a little file system
CLocalFileSystem	A filesystem for accessing the local mbed Microcontroller USB disk drive
►CNonCopyable< FileHandle >
►CFileHandle	Class FileHandle
CBufferedSerial	Class providing buffered UART communication functionality using separate circular buffer for send and receive channels
CFile	File class
CFileLike	Class FileLike
CLocalFileHandle
CSerialWireOutput
CUnbufferedSerial	Class implementation for unbuffered I/O for an interrupt driven application or one that needs to have more control
►CNonCopyable< FileLike >
CFileLike	Class FileLike
►CNonCopyable< FileSystemHandle >
►CFileSystemHandle	A filesystem-like object is one that can be used to open file-like objects though it by fopen("/name/filename", mode)
CFileSystemLike	A filesystem-like object is one that can be used to open file-like objects though it by fopen("/name/filename", mode)
►CNonCopyable< FileSystemLike >
CFileSystemLike	A filesystem-like object is one that can be used to open file-like objects though it by fopen("/name/filename", mode)
►CNonCopyable< FlashIAP >
CFlashIAP	Flash IAP driver
►CNonCopyable< I2C >
CI2C	An I2C Master, used for communicating with I2C slave devices
►CNonCopyable< InterruptIn >
CInterruptIn	A digital interrupt input, used to call a function on a rising or falling edge
►CNonCopyable< KVMap >
CKVMap	KVMap class
►CNonCopyable< LocalFileHandle >
CLocalFileHandle
►CNonCopyable< LocalFileSystem >
CLocalFileSystem	A filesystem for accessing the local mbed Microcontroller USB disk drive
►CNonCopyable< LoRaWANStack >
CLoRaWANStack	LoRaWANStack Class A controller layer for LoRaWAN MAC and PHY
►CNonCopyable< Mail< T, queue_sz > >
CMail< T, queue_sz >	The Mail class allows you to control, send, receive or wait for mail
►CNonCopyable< MemoryPool< T, pool_sz > >
CMemoryPool< T, queue_sz >
CMemoryPool< T, pool_sz >	Define and manage fixed-size memory pools of objects of a given type
►CNonCopyable< MeshInterfaceNanostack >
CMeshInterfaceNanostack
►CNonCopyable< Mutex >
CMutex	Used to synchronize the execution of threads
►CNonCopyable< Nanostack >
CNanostack
►CNonCopyable< Nanostack::Interface >
CNanostack::Interface
►CNonCopyable< NanostackEthernetInterface >
CNanostackEthernetInterface	Ethernet interface for Nanostack
►CNonCopyable< OSPI >
COSPI	A OSPI Driver, used for communicating with OSPI slave devices
►CNonCopyable< QSPI >
CQSPI	A QSPI Driver, used for communicating with QSPI slave devices
►CNonCopyable< Queue< T, queue_sz > >
CQueue< T, queue_sz >	The Queue class represents a collection of objects that are stored first by order of priority, and then in first-in, first-out (FIFO) order
►CNonCopyable< ScopedLock< Lockable > >
CScopedLock< Lockable >	RAII-style mechanism for owning a lock of Lockable object for the duration of a scoped block
►CNonCopyable< ScopedRamExecutionLock >
CScopedRamExecutionLock	RAII object for disabling, then restoring RAM execute never mode Usage:
►CNonCopyable< ScopedRomWriteLock >
CScopedRomWriteLock	RAII object for disabling, then restoring ROM write never mode Usage:
►CNonCopyable< Semaphore >
CSemaphore	Used to manage and protect access to a set of shared resources
►CNonCopyable< SerialBase >
►CSerialBase	A base class for serial port implementations Can't be instantiated directly (use UnbufferedSerial or BufferedSerial)
CBufferedSerial	Class providing buffered UART communication functionality using separate circular buffer for send and receive channels
CUnbufferedSerial	Class implementation for unbuffered I/O for an interrupt driven application or one that needs to have more control
►CNonCopyable< SPI >
►CSPI	An SPI Master, used for communicating with SPI slave devices
CEMW3080B_SPI
►CNonCopyable< SPISlave >
CSPISlave	A SPI slave, used for communicating with a SPI master device
►CNonCopyable< Stream >
CStream	File stream
CNonCopyable< SysTimer< Period, true > >
►CNonCopyable< Thread >
CThread	Allow defining, creating, and controlling thread functions in the system
►CNonCopyable< TickerBase >
►CTickerBase	A Ticker is used to call a function at a recurring interval
CLowPowerTicker	Low Power Ticker
CTicker
►CTimeoutBase	A Timeout is used to call a function at a point in the future
CLowPowerTimeout	Low Power Timout
CTimeout
►CNonCopyable< TimerEvent >
►CTimerEvent	Base abstraction for timer interrupts
CTickerBase	A Ticker is used to call a function at a recurring interval
CSysTimer< Period, IRQ >	The SysTimer class is used to provide timing for system suspension, and the idle loop in TICKLESS mode
►CNonCopyable< UnbufferedSerial >
CUnbufferedSerial	Class implementation for unbuffered I/O for an interrupt driven application or one that needs to have more control
►CNonCopyable< Watchdog >
CWatchdog	A hardware watchdog timer that resets the system in the case of system failures or malfunctions
Cnsapi_addr	IP address structure for passing IP addresses by value
Cnsapi_ip_mreq	Nsapi_ip_mreq structure
Cnsapi_latency_req	Nsapi_latency_req structure
Cnsapi_msghdr	Header structure for control info
Cnsapi_pktinfo	Nsapi_pktinfo structure
Cnsapi_stack	Nsapi_stack structure
Cnsapi_stack_api	Nsapi_stack_api structure
Cnsapi_stagger_req	Nsapi_stagger_req structure
Cnsapi_wifi_ap	Nsapi_wifi_ap structure
CBLE::OnEventsToProcessCallbackContext	Events to process event
►COperationListBase
COperationList< AsyncWrite >
COperationList< AsyncRead >
COperationList< AsyncWait >
COperationList< AsyncSend >
COperationList< T >
CAllArgs< B0, B1, B2, B3, B4, B5 >::Operations< T, _ >
CAllArgs< B0 >::Operations< T, _ >
CAllArgs< B0, B1 >::Operations< T, _ >
CAllArgs< B0, B1, B2 >::Operations< T, _ >
CAllArgs< B0, B1, B2, B3 >::Operations< T, _ >
CAllArgs< B0, B1, B2, B3, B4 >::Operations< T, _ >
CAllArgs< B0, B1 >::Operations< T *, R(U::*)()>
CAllArgs< B0, B1, B2 >::Operations< T *, R(U::*)(B2)>
CAllArgs< B0, B1, B2, B3 >::Operations< T *, R(U::*)(B2, B3)>
CAllArgs< B0, B1, B2, B3, B4 >::Operations< T *, R(U::*)(B2, B3, B4)>
CAllArgs< B0, B1, B2, B3, B4, B5 >::Operations< T *, R(U::*)(B2, B3, B4, B5)>
CAllArgs< B0, B1 >::Operations< T, R(U::*)() const >
CAllArgs< B0, B1 >::Operations< T, R(U::*)() const volatile >
CAllArgs< B0, B1 >::Operations< T, R(U::*)() volatile >
CAllArgs< B0, B1, B2 >::Operations< T, R(U::*)(B2) const >
CAllArgs< B0, B1, B2 >::Operations< T, R(U::*)(B2) const volatile >
CAllArgs< B0, B1, B2 >::Operations< T, R(U::*)(B2) volatile >
CAllArgs< B0, B1, B2, B3 >::Operations< T, R(U::*)(B2, B3) const >
CAllArgs< B0, B1, B2, B3 >::Operations< T, R(U::*)(B2, B3) const volatile >
CAllArgs< B0, B1, B2, B3 >::Operations< T, R(U::*)(B2, B3) volatile >
CAllArgs< B0, B1, B2, B3, B4 >::Operations< T, R(U::*)(B2, B3, B4) const >
CAllArgs< B0, B1, B2, B3, B4 >::Operations< T, R(U::*)(B2, B3, B4) const volatile >
CAllArgs< B0, B1, B2, B3, B4 >::Operations< T, R(U::*)(B2, B3, B4) volatile >
CAllArgs< B0, B1, B2, B3, B4, B5 >::Operations< T, R(U::*)(B2, B3, B4, B5) const >
CAllArgs< B0, B1, B2, B3, B4, B5 >::Operations< T, R(U::*)(B2, B3, B4, B5) const volatile >
CAllArgs< B0, B1, B2, B3, B4, B5 >::Operations< T, R(U::*)(B2, B3, B4, B5) volatile >
CCellularNetwork::operator_names_t	Cellular operator names in numeric and alpha format
CCellularNetwork::operator_t	3GPP TS 27.007 - 7.3 PLMN selection +COPS
COsClock	A C++11 chrono TrivialClock for os_timer
Cpacket_params	The type describing the packet parameters for every packet types
Cpacket_status_t	Represents the packet status for every packet type
CPasskeyAscii	Passkey stored as a string of digits
CMessageBuilder::PayloadBuilder	Build a record payload
Cpbuf
CCellularContext::pdpcontext_params_t	PDP Context information
CPeriodicAdvertisingReportEvent	Event generated when periodic advertising packet is received
CPeriodicAdvertisingSyncEstablishedEvent	Event generated when you first receive a periodic advertisement
CPeriodicAdvertisingSyncLoss	Event generated when periodic advertising sync is lost
CPeripheralList
CScanParameters::phy_configuration_t	Scan configuration of a physical channel
Cphy_set_t	Type that describe a set of PHY(sical) transports
CPinList
CPinMap
►CPN512TransportDriver	The PN512 supports multiple transport mechanisms (SPI, I2C, UART): this class provides a unified API across these transports
CPN512SPITransportDriver
Cpollfd
Cpollfh
CPortIn	A multiple pin digital input
CPortInOut	A multiple pin digital in/out used to set/read multiple bi-directional pins
CPortOut	A multiple pin digital output
►CPPP
Cppp_service	This interface should be used to abstract low level access to networking hardware All operations receive a void * hardware pointer which an ppp device provides when it is registered with a stack
CGap::PreferredConnectionParams_t	Preferred connection parameter display in Generic Access Service
CGattCharacteristic::PresentationFormat_t	Value of a Characteristic Presentation Format descriptor
CDiscoveredCharacteristic::Properties_t	Properties of a discovered characteristic
Cpsa_aead_operation_s
Cpsa_cipher_operation_s
Cpsa_core_key_attributes_t
Cpsa_drv_entropy_t	A struct containing all of the function pointers needed to interface to an entropy source
Cpsa_drv_se_aead_t	A struct containing all of the function pointers needed to implement secure element Authenticated Encryption with Additional Data operations
Cpsa_drv_se_asymmetric_t	A struct containing all of the function pointers needed to implement asymmetric cryptographic operations using secure elements
Cpsa_drv_se_cipher_t	A struct containing all of the function pointers needed to implement cipher operations using secure elements
Cpsa_drv_se_context_t	Driver context structure
Cpsa_drv_se_key_derivation_t	A struct containing all of the function pointers needed to for secure element key derivation and agreement
Cpsa_drv_se_key_management_t	A struct containing all of the function pointers needed to for secure element key management
Cpsa_drv_se_mac_t	A struct containing all of the function pointers needed to perform secure element MAC operations
Cpsa_drv_se_t	A structure containing pointers to all the entry points of a secure element driver
Cpsa_hash_operation_s
Cpsa_invec
Cpsa_key_attributes_s
Cpsa_key_derivation_s
Cpsa_key_policy_s
Cpsa_key_slot_t	The data structure representing a key slot, containing key material and metadata for one key
Cpsa_mac_operation_s
Cpsa_operation_driver_context_t
Cpsa_outvec
Cpsa_se_key_data_storage_t	The storage representation of a key whose data is in a secure element
Cpsa_storage_info_t	A container for metadata associated with a specific uid
Cpsa_storage_version_t
CPwmOut	A pulse-width modulation digital output
CQCBORStringAllocator	This is a set of functions and pointer context (in object-oriented parlance, an "object") used to allocate memory for coalescing the segments of an indefinite length string into one
CQCBORTagListIn	This is used to tell the decoder about tags that it should record in uTagBits in QCBORItem beyond the built-in tags
CQCBORTagListOut	This is for QCBORDecode_GetNextWithTags() to be able to return the full list of tags on an item
Cqspi_command	QSPI command
Cqspi_pinmap_t
►CQUECTEL_BG96
CSTModCellular
CR_APDU	SC response structure
Cradio_error_t	Represents the possible radio system error states
Cradio_events	Reporting functions for upper layers
Cradio_fsk_packet_handler	FSK packet handle
Cradio_fsk_settings	FSK modem parameters
Cradio_lora_packet_handler	LoRa packet Contains information about a LoRa packet
Cradio_lora_settings	LoRa modem parameters
Cradio_settings	Global radio settings
Cradio_status_t	Structure describing the radio status
CRealTimeClock	An implementation of a C++11 Clock representing the HAL real-time clock
CRecord	Represent a record
►CRecordParser	Parse a record
►CGenericRecordParser< MimeParser, Mime >
CMimeParser	Parse a Mime payload
►CGenericRecordParser< TextParser, Text >
CTextParser	Parse a Text
►CGenericRecordParser< URIParser, URI >
CURIParser	Parser of a URI
CGenericRecordParser< ParserImplementation, ParsingResult >	GenericRecordParser
CRecordParserChain	Record parser chain
CRecordType	Encode a record type
CCellularNetwork::registration_params_t	Network registration information
Creset_reason_capabilities_t	Reset reason capabilities of the platform
CResetReason	A platform-independent method of checking the cause of the last system reset
Crf_ctrls	Structure to hold RF controls for LoRa Radio
Crx2_channel_params
Crx_config_params_t
Crx_counter_t	Represents the Rx internal counters values when GFSK or LoRa packet type is used
Crx_message_u	Lora_mac_rx_message_by_type_t union
CSafeEnum< Target, LayoutType >	Helper class used to define safe enumerations
►CSafeEnum< adv_data_appearance_t, uint16_t >
Cadv_data_appearance_t	Enumeration of values for the adv_data_type_t::APPEARANCE
►CSafeEnum< adv_data_type_t, uint8_t >
Cadv_data_type_t
►CSafeEnum< att_security_requirement_t, uint8_t >
Catt_security_requirement_t	Security requirement that can be attached to an attribute operation
►CSafeEnum< coded_symbol_per_bit_t, uint8_t >
Ccoded_symbol_per_bit_t	Type describing the number of symbols per bit in le coded PHY
►CSafeEnum< controller_supported_features_t, uint8_t >
Ccontroller_supported_features_t	Features supported by the controller
►CSafeEnum< io_capability_t, uint8_t >
Cio_capability_t	Type that describe the IO capability of a device; it is used during Pairing Feature exchange
►CSafeEnum< link_encryption_t, uint8_t >
Clink_encryption_t	Type that describes link's encryption state
►CSafeEnum< pairing_failure_t, uint8_t >
Cpairing_failure_t	Type that describe a pairing failure
►CSafeEnum< peer_address_type_t, uint8_t >
Cpeer_address_type_t	Type that describes a peer device address type
►CSafeEnum< phy_t, uint8_t >
Cphy_t	Type that describes a bluetooth PHY(sical) transport
►CSafeEnum< random_address_type_t, uint8_t >
Crandom_address_type_t	Type that describes a random device address type
CScanParameters	Parameters defining the scan process
CScanRequestEvent	Event produced when a peer requests a scan response from the advertiser
CScanTimeoutEvent	Event generated when scan times out
Csector_info_t	Sector information structure
CSecurityManager	Overview
Cserial_fc_pinmap_t
Cserial_pinmap_t
Cserial_t	Asynch serial HAL structure
CServiceDiscovery	Host callback types needed by the service discovery procedure
CUSBDevice::setup_packet_t
Csfdp_bptbl_info	JEDEC Basic Flash Parameter Table info
Csfdp_fbatbl_info	JEDEC 4-byte Address Instruction Parameter Table info
Csfdp_hdr_info	SFDP JEDEC Parameter Table info
Csfdp_smptbl_info	JEDEC Sector Map Table info
Cshared_data_tlv_entry	Shared data TLV entry header format
Cshared_data_tlv_header	Shared data TLV header
CSharedPtr< T >	Shared pointer class
CSingletonPtr< T >	Utility class for creating and using a singleton
CSingletonPtr< rtos::Mutex >
►CSocket	Socket interface
►CInternetSocket	Socket implementation that uses IP network stack
►CInternetDatagramSocket	InternetDatagramSocket socket implementation
CICMPSocket	ICMP socket implementation
CUDPSocket	UDP socket implementation
CTCPSocket	TCP socket connection
►CTLSSocketWrapper	TLSSocket is a wrapper around Socket for interacting with TLS servers
►CDTLSSocketWrapper	DTLSSocketWrapper implement DTLS stream over the existing Socket transport
CDTLSSocket	DTLSSocket implement DTLS stream over UDP Socket
CTLSSocket	TLSSocket is a wrapper around TCPSocket for interacting with TLS servers
CCellularNonIPSocket	Socket implementation for cellular Non-IP data delivery(NIDD)
CSocketAddress	SocketAddress class
CSocketStats	SocketStats class
CSpan< ElementType, Extent >	Nonowning view to a sequence of contiguous elements
CSpan< const uint8_t >
CSpan< ElementType, SPAN_DYNAMIC_EXTENT >	Span specialization that handle dynamic size
CSpan< uint8_t >
Cspi_capabilities_t	Describes the capabilities of a SPI peripherals
Cspi_pinmap_t
Cspi_t	Asynch SPI HAL structure
Cstat
Cstatvfs
CCallbackBase::Store
Ct_cose_crypto_hash	The context for use with the hash adaptation layer here
Ct_cose_sign1_ctx	This is the context for creating a COSE_Sign1 structure
CTask< F >
CTask< void()>
CTask< void(const setup_packet_t *)>
►CTaskQueue	TaskQueue
CPolledQueue	PolledQueue
CCharacteristicDescriptorDiscovery::TerminationCallbackParams_t	Characteristic descriptor discovery ended event
CText	Represent the well known type text
Cticker_data_t	Ticker's data structure
Cticker_event_queue_t	Ticker's event queue structure
Cticker_event_s	Ticker's event structure
Cticker_info_t	Information about the ticker implementation
Cticker_interface_t	Ticker's interface structure - required API for a ticker
CTickerDataClock	A partial implementation of a C++11 Clock representing a HAL ticker
Ctimer_event_t	Timer object description
►CTimerBase
CLowPowerTimer	Low power timer
Ctimeval
CTransaction< Class >	Transaction class defines a transaction
Ctransaction_t	Transaction structure
Ctrng_s
►Ctype_identity
Cmember_type< M C::* >
Cunqualify_fn< R(Args...) & >
Cunqualify_fn< R(Args...) &noexcept >
Cunqualify_fn< R(Args...) const & >
Cunqualify_fn< R(Args...) const &noexcept >
Cunqualify_fn< R(Args...) const >
Cunqualify_fn< R(Args...) const noexcept >
Cunqualify_fn< R(Args...) const volatile & >
Cunqualify_fn< R(Args...) const volatile &noexcept >
Cunqualify_fn< R(Args...) const volatile >
Cunqualify_fn< R(Args...) const volatile noexcept >
Cunqualify_fn< R(Args...) noexcept >
Cunqualify_fn< R(Args...) volatile & >
Cunqualify_fn< R(Args...) volatile &noexcept >
Cunqualify_fn< R(Args...) volatile >
Cunqualify_fn< R(Args...) volatile noexcept >
Cunqualify_fn< R(Args...)>
Cunqualify_fn< T >
CUpdateConnectionParametersRequestEvent	Event received when a peer wants to change the connection parameters
CURI	Model the well known type URI
Cusb_ep_entry_t
Cusb_ep_table_t
►CUSBPhy	Abstract interface to physical USB hardware
CUSBPhyHw
►CUSBPhyEvents	Event handler for USBPhy
►CUSBDevice	Core USB Device driver
CUSBAudio	USBAudio example
►CUSBCDC
CUSBSerial	USBSerial example
CUSBCDC_ECM
►CUSBHID	USBHID example
CUSBKeyboard	USBKeyboard example
CUSBMouse	USBMouse example
CUSBMouseKeyboard	USBMouseKeyboard example
CUSBMIDI	USBMIDI example
CUSBMSD	USBMSD class: generic class in order to use all kinds of blocks storage chip
Cuse_gpio_ssel_t
Cuseful_buf	The non-const UsefulBuf typically used for some allocated memory that is to be filled in
Cuseful_buf_c	UsefulBufC and UsefulBuf are simple data structures to hold a pointer and length for a binary data
Cuseful_input_buf
Cuseful_out_buf	UsefulOutBuf is a structure and functions (an object) that are good for serializing data into a buffer such as is often done with network protocols or data written to files
CUserAllocatedEvent< F, A >
CUserAllocatedEvent< F, void(ArgTs...)>	UserAllocatedEvent
CUUID	Representation of a Universally Unique Identifier (UUID)
Cwatchdog_config_t	Watchdog configuration
Cwatchdog_features_t	Watchdog features
Cwhitelist_t	Representation of a whitelist of addresses
CWiFiAccessPoint	WiFiAccessPoint class
CWisunBorderRouter	Wi-SUN Border Router class
Cws_br_info	Struct br_information Border router dynamic information
Cws_br_radius_timing	Struct ws_br_radius_timing_t is RADIUS timing configuration structure
Cws_br_route_info	Struct br_route_info is parent child relation structure
Cws_cca_threshold_table	Struct ws_cca_threshold_table Wi-SUN CCA threshold table information
Cws_nbr_info	Struct ws_nbr_info_t Gives the neighbor information
Cws_rpl_info	Struct ws_rpl_info Wi-SUN router RPL information
Cws_stack_state	Struct ws_stack_state Wi-SUN stack information