Lely core libraries 2.3.5
Data Structures
Here are the data structures with brief descriptions:
 Nlely
  NcanopenThe namespace for the C++ CANopen application library
   NdetailThe namespace for implementation details of the C++ CANopen application library
    Ccanopen_traits
    Ccanopen_traits< T, N, false >
    Ccanopen_traits< T, N, true >
    CFiberDriverBaseA base class for lely::canopen::FiberDriver, containing a fiber executor
    CLoopDriverBaseA base class for lely::canopen::LoopDriver, containing an event loop and the associated executor
    CLssFastscanRequestBase
    CLssFastscanRequestWrapper
    CLssGetIdRequestBase
    CLssGetIdRequestWrapper
    CLssGetNumberRequestBase
    CLssGetProductCodeRequestBase
    CLssGetProductCodeRequestWrapper
    CLssGetRevisionRequestBase
    CLssGetRevisionRequestWrapper
    CLssGetSerialNrRequestBase
    CLssGetSerialNrRequestWrapper
    CLssGetVendorIdRequestBase
    CLssGetVendorIdRequestWrapper
    CLssIdNonConfigRequestBase
    CLssIdNonConfigRequestWrapper
    CLssRequestBase
    CLssScanRequestBase
    CLssSetBitrateRequestBase
    CLssSetBitrateRequestWrapper
    CLssSetIdRequestBase
    CLssSetIdRequestWrapper
    CLssSlowscanRequestBase
    CLssSlowscanRequestWrapper
    CLssStoreRequestBase
    CLssStoreRequestWrapper
    CLssSwitchBitrateRequestBase
    CLssSwitchBitrateRequestWrapper
    CLssSwitchRequestBase
    CLssSwitchRequestWrapper
    CLssSwitchSelectiveRequestBase
    CLssSwitchSelectiveRequestWrapper
    CSdoDownloadDcfRequestBase
    CSdoDownloadDcfRequestWrapper
    CSdoDownloadRequestBase
    CSdoDownloadRequestWrapper
    CSdoRequestBase
    CSdoUploadRequestBase
    CSdoUploadRequestWrapper
   CAsyncMasterAn asynchronous CANopen master
   CBasicDriverThe base class for drivers for remote CANopen nodes
   CBasicLogicalDriverThe base class for drivers for logical devices on remote CANopen nodes
   CBasicLogicalDriver< BasicDriver >The base class for drivers for logical devices on remote CANopen nodes
    CRpdoMapped
    CTpdoMapped
   CBasicMasterThe CANopen master
    CSubObjectA mutator providing read/write access to a CANopen sub-object in a local object dictionary
    CConstSubObjectAn accessor providing read-only access to a CANopen sub-object in a local object dictionary
    CObjectA mutator providing read/write access to a CANopen object in a local object dictionary
    CConstObjectAn accessor providing read-only access to a CANopen object in a local object dictionary
    CRpdoMappedAn accessor providing read-only access to TPDO-mapped objects in a remote object dictionary
    CTpdoMappedA mutator providing read/write access to TPDO-mapped objects in a remote object dictionary
    CTpdoEventMutex
    CImpl_The internal implementation of the CANopen master
   CBasicSlaveThe base class for CANopen slaves
    CSubObjectA mutator providing read/write access to a CANopen sub-object in a local object dictionary
    CConstSubObjectAn accessor providing read-only access to a CANopen sub-object in a local object dictionary
    CObjectA mutator providing read/write access to a CANopen object in a local object dictionary
    CConstObjectAn accessor providing read-only access to a CANopen object in a local object dictionary
    CRpdoMappedAn accessor providing read-only access to RPDO-mapped objects in a remote object dictionary
    CTpdoMappedA mutator providing read/write access to TPDO-mapped objects in a remote object dictionary
    CImpl_The internal implementation of the CANopen slave
   Ccanopen_traitsA class template mapping CANopen types to C and C++ types
   Ccanopen_traits< bool >Specialization of lely::canopen::canopen_traits for the CANopen basic type BOOLEAN
   Ccanopen_traits< double >Specialization of lely::canopen::canopen_traits for the CANopen basic type REAL64
   Ccanopen_traits< float >Specialization of lely::canopen::canopen_traits for the CANopen basic type REAL32
   Ccanopen_traits< int16_t >Specialization of lely::canopen::canopen_traits for the CANopen basic type INTEGER16
   Ccanopen_traits< int32_t >Specialization of lely::canopen::canopen_traits for the CANopen basic type INTEGER32
   Ccanopen_traits< int64_t >Specialization of lely::canopen::canopen_traits for the CANopen basic type INTEGER64
   Ccanopen_traits< int8_t >Specialization of lely::canopen::canopen_traits for the CANopen basic type INTEGER8
   Ccanopen_traits< uint16_t >Specialization of lely::canopen::canopen_traits for the CANopen basic type UNSIGNED16
   Ccanopen_traits< uint32_t >Specialization of lely::canopen::canopen_traits for the CANopen basic type UNSIGNED32
   Ccanopen_traits< uint64_t >Specialization of lely::canopen::canopen_traits for the CANopen basic type UNSIGNED64
   Ccanopen_traits< uint8_t >Specialization of lely::canopen::canopen_traits for the CANopen basic type UNSIGNED8
   Ccanopen_traits<::std::basic_string< char16_t > >Specialization of lely::canopen::canopen_traits for the CANopen array type UNICODE_STRING
   Ccanopen_traits<::std::string >Specialization of lely::canopen::canopen_traits for the CANopen array type VISIBLE_STRING
   Ccanopen_traits<::std::vector< uint8_t > >Specialization of lely::canopen::canopen_traits for the CANopen array type OCTET_STRING
   CDeviceThe CANopen device description
    CImpl_The internal implementation of the CANopen device description
     CDeviceDeleter
   CDriverBaseThe abstract driver interface for a remote CANopen node
   CFiberDriverA CANopen driver running its tasks and callbacks in fibers
   Cis_canopenIf T is one of the CANopen basic or array types, provides the member constant value equal to true
   Cis_canopen< T, typename canopen_traits< T >::type >
   Cis_canopen_basicIf T is one of the CANopen basic types, provides the member constant value equal to true
   Cis_canopen_basic< T, typename canopen_traits< T >::type >
   CLogicalDriverBaseThe abstract driver interface for a logical device on a remote CANopen node
   CLoopDriverA CANopen driver running its own dedicated event loop in a separate thread
    CImpl_The internal implementation of lely::canopen::LoopDriver
   CLssAddressThe 128-bit number uniquely identifying each CANopen node
   CLssFastscanRequestAn 'LSS Fastscan' request
   CLssGetIdRequestAn LSS 'inquire node-ID' request
   CLssGetProductCodeRequestAn LSS 'inquire identity product-code' request
   CLssGetRevisionRequestAn LSS 'inquire identity revision-number' request
   CLssGetSerialNrRequestAn LSS 'inquire identity serial-number' request
   CLssGetVendorIdRequestAn LSS 'inquire identity vendor-ID' request
   CLssIdNonConfigRequestAn LSS 'identify non-configured remote slave' request
   CLssMasterThe base class for CANopen LSS masters
    CImpl_
   CLssSetBitrateRequestAn LSS 'configure bit timing parameters' request
   CLssSetIdRequestAn LSS 'configure node-ID' request
   CLssSlowscanRequestAn 'LSS Slowscan' request
   CLssStoreRequestAn LSS 'store configuration' request
   CLssSwitchBitrateRequestAn LSS 'activate bit timing parameters' request
   CLssSwitchRequestAn LSS 'switch state global' request
   CLssSwitchSelectiveRequestAn LSS 'switch state selective' request
   CNodeThe base class for CANopen nodes
    CTpdoEventMutexA recursive mutex-like object that can be used to postpone the transmission of acyclic and event-driven Transmit-PDOs while the lock is held
    CImpl_The internal implementation of the CANopen node
     CNmtDeleter
   CSdoA Client-SDO queue
    CImpl_The internal implementation of the Client-SDO queue
   CSdoDownloadDcfRequestA series of SDO download (i.e., write) requests corresponding to the entries in a concise DCF
   CSdoDownloadRequestAn SDO download (i.e., write) request
   CSdoErrorThe type of exception thrown when an SDO abort code is received
   CSdoUploadRequestAn SDO upload (i.e., read) request
  Ncompat
   Ndetail
    Cindex_tuple
    Cindex_tuple_cat
    Cindex_tuple_cat< index_tuple< I1... >, index_tuple< I2... > >
    Cinvoke_impl
    Cinvoke_impl< MT B::* >
    Cinvoke_result
    Cinvoke_result< decltype(void(invoke(::std::declval< F >(), ::std::declval< Args >()...))), F, Args... >
    Cis_invocable
    Cis_invocable< Result, R, typename make_void< typename Result::type >::type >
    Cis_reference_wrapper
    Cis_reference_wrapper<::std::reference_wrapper< U > >
    Cmake_index_tuple
    Cmake_index_tuple< 0 >
    Cmake_index_tuple< 1 >
    Cmake_integer_sequence
    Cmake_integer_sequence< T, N, index_tuple< Ints... > >
    Cmake_void
   CconjunctionForms the logical conjunction of the type traits B..., effectively performing a logical AND on the sequence of traits
   Cconjunction< B1 >
   Cconjunction< B1, Bn... >
   CdisjunctionForms the logical disjunction of the type traits B..., effectively performing a logical OR on the sequence of traits
   Cdisjunction< B1 >
   Cdisjunction< B1, Bn... >
   Cinteger_sequenceA compile-time sequence of integers
   Cinvoke_resultDeduces the return type of an INVOKE expression at compile time
   Cis_invocableDetermines whether F can be invoked with the arguments Args...
   Cis_invocable_rDetermines whether F can be invoked with the arguments Args... to yield a result that is convertable to R
   CnegationForms the logical negation of the type trait B
   Cremove_cvref
  Nev
   Ndetail
    CAsyncTask
    CAsyncTask< Invoker, typename ::std::enable_if< is_future< compat::invoke_result_t< Invoker > >::value >::type >
    CAsyncTask< Invoker, typename ::std::enable_if<!is_future< compat::invoke_result_t< Invoker > >::value >::type >
    CFiberMutexBaseThe base class for mutexes suitable for use in fibers
    Cis_future
    Cis_future< Future< T, E > >
    CTaskWrapper
   CCoTaskA stackless coroutine which can be submitted to an executor as a task
   CExecutorAn abstract task executor. This class is a wrapper around #ev_exec_t*
   CFiberConditionVariableA condition variable suitable for use in fibers
   CFiberExecutorA fiber executor
   CFiberMutexA plain mutex suitable for use in fibers
   CFiberRecursiveMutexA recursive mutex suitable for use in fibers
   CFiberThreadConvenience class providing a RAII-style mechanism to ensure the calling thread can be used by fiber executors for the duration of a scoped block
   CFutureA future
   Cfuture_not_readyThe exception thrown when retrieving the result of a future which is not ready or does not contain a reference to a shared state
   CLoopA polling event loop
   CPollThe abstract polling interface
   CPromiseA promise
   CStrandA strand executor
   CTaskA basic task
   CThreadLoopThe thread-local event loop
  Nimpl
   Cc_pack
   Cc_pack_push_front
   Cc_pack_push_front< T, c_pack< S... > >Pushes a type to the front of a parameter pack
   Cc_pack_pop_backPops a type from the back of a parameter pack
   Cc_pack_pop_back< T, S >Pops a type from the back of a parameter pack
  Nio
   Ndetail
    CCanChannelReadWrapper
    CCanChannelWriteWrapper
    CCanRouterReadErrorWrapper
    CCanRouterReadFrameWrapper
    CSignalSetWaitWrapper
    CTimerQueueWaitWrapper
    CTimerWaitWrapper
   CCanChannelA CAN channel
   CCanChannelBaseA reference to an abstract CAN channel
   CCanChannelReadA read operation suitable for use with a CAN channel
   CCanChannelWriteA write operation suitable for use with a CAN channel
   CCanControllerA CAN controller
   CCanControllerBaseA reference to an abstract CAN controller
   CCanNetA CAN network interface. This class is a wrapper around io_can_net_t*
   CCanRouterA CAN frame rounter. This class is a wrapper around #io_can_rt_t*
   CCanRouterReadErrorA CAN error frame read operation suitable for use with a CAN frame router
   CCanRouterReadFrameA CAN frame read operation suitable for use with a CAN frame router
   CClockAn abstract clock. This class is a wrapper around #io_clock_t*
   CCoCanChannelReadA CAN channel read operation with a stackless coroutine as the completion task
   CCoCanChannelWriteA CAN channel write operation with a stackless coroutine as the completion task
   CCoCanRouterReadErrorA CAN error frame read operation suitable for use with a CAN frame router, with a stackless coroutine as the completion task
   CCoCanRouterReadFrameA CAN frame read operation suitable for use with a CAN frame router, with a stackless coroutine as the completion task
   CContextAn I/O context
   CContextBaseA refence to an I/O context. This class is a wrapper around #io_ctx_t*
   CCoSignalSetWaitA wait operation, suitable for use with a signal handler, with a stackless coroutine as the completion task
   CCoTimerQueueWaitA wait operation, suitable for use with a timer queue, with a stackless coroutine as the completion task
   CCoTimerWaitA wait operation, suitable for use with an I/O timer, with a stackless coroutine as the completion task
   CDeviceAn abstract I/O device. This class is a wrapper around #io_dev_t*
   CIoGuardA RAII-style wrapper around io_init() and io_fini()
   CIxxatChannelAn IXXAT CAN channel
   CIxxatControllerAn IXXAT CAN controller
   CIxxatGuardA RAII-style wrapper around io_ixxat_init() and io_ixxat_fini()
   CPollThe system-dependent I/O polling interface
   CSignalSetA system signal handler
   CSignalSetBaseA reference to an abstract signal handler
   CSignalSetWaitA wait operation suitable for use with a signal handler
   CTimerAn I/O system timer
   CTimerBaseA reference to an abstract timer
   CTimerQueueA timer queue. This class is a wrapper around #io_tqueue_t*
   CTimerQueueWaitA wait operation suitable for use with a timerqueue
   CTimerWaitA wait operation suitable for use with an I/O timer
   CUserCanChannelA user-defined CAN channel
   CUserTimerA user-defined timer
   CVirtualCanChannelA virtual CAN channel
   CVirtualCanControllerA virtual CAN controller
  Nutil
   Ndetail
    Cerror_traits
    Cerror_traits< int >
    Cerror_traits<::std::error_code >
    Cerror_traits<::std::exception_ptr >
    CFailure
    Cinvoker
    CSuccess
    CSuccess< void >
   CBasicLockableAn abstract interface conforming to the BasicLockable concept
   CCoroutineThe parent class for function objects used as stackless coroutines
   CResultA type capable of representing both the successful and failure result of an operation
   CResult< T, typename ::std::enable_if<!::std::is_void< T >::value >::type >
   CResult< void, E >
   CResult< void, void >
   CStopCallbackA RAII object type that registers a callback function with a lely::util::StopToken object
   CStopSourceAn object providing the means to issue a stop request
   CStopTokenAn object providing the means to check if a stop request has been made for its associated lely::util::StopSource object
   CUnlockGuardA mutex wrapper that provides a convenient RAII-style mechanism for releasing a mutex for the duration of a scoped block
  Cbad_copyThe type of objects thrown as exceptions to report a failure to copy an instantiation of a C type
  Cbad_initThe type of objects thrown as exceptions to report a failure to initialize an instantiation of a C type
  Cbad_moveThe type of objects thrown as exceptions to report a failure to move an instantiation of a C type
  Cc_mem_call
  Cc_mem_call< impl::c_pack< R, ArgTypes... >, C, M >Provides a C wrapper for a member function with an arbitrary number of arguments
  Cc_mem_call< R(*)(ArgTypes...), C, M >Provides a C wrapper for a member function with an arbitrary number of arguments
  Cc_mem_fn
  Cc_mem_fn< impl::c_pack< R, ArgTypes... >, C >A class template supplying the type of a member function with an arbitrary number of arguments
  Cc_mem_fn< R(*)(ArgTypes...), C >A class template supplying the type of a member function with an arbitrary number of arguments
  Cc_obj_call
  Cc_obj_call< impl::c_pack< R, ArgTypes... >, F >Provides a C wrapper for a function object with an arbitrary number of arguments
  Cc_obj_call< R(*)(ArgTypes...), F >Provides a C wrapper for a function object with an arbitrary number of arguments
  Cc_type_traitsA class template supplying a uniform interface to certain attributes of C types
  Cc_type_traits< __can_net >The attributes of can_net_t required by lely::CANNet
  Cc_type_traits< __can_recv >The attributes of can_recv_t required by lely::CANRecv
  Cc_type_traits< __can_timer >The attributes of can_timer_t required by lely::CANTimer
  Cc_type_traits< __co_csdo >The attributes of co_csdo_t required by lely::COCSDO
  Cc_type_traits< __co_dev >The attributes of co_dev_t required by lely::CODev
  Cc_type_traits< __co_emcy >The attributes of co_emcy_t required by lely::COEmcy
  Cc_type_traits< __co_gw >The attributes of co_gw_t required by lely::COGW
  Cc_type_traits< __co_gw_txt >The attributes of co_gw_txt_t required by lely::COGWTxt
  Cc_type_traits< __co_lss >The attributes of co_lss_t required by lely::COLSS
  Cc_type_traits< __co_nmt >The attributes of co_nmt_t required by lely::CONMT
  Cc_type_traits< __co_obj >The attributes of co_obj_t required by lely::COObj
  Cc_type_traits< __co_rpdo >The attributes of co_rpdo_t required by lely::CORPDO
  Cc_type_traits< __co_ssdo >The attributes of co_ssdo_t required by lely::COSSDO
  Cc_type_traits< __co_sub >The attributes of co_sub_t required by lely::COSub
  Cc_type_traits< __co_sync >The attributes of co_sync_t required by lely::COSync
  Cc_type_traits< __co_time >The attributes of co_time_t required by lely::COTime
  Cc_type_traits< __co_tpdo >The attributes of co_tpdo_t required by lely::COTPDO
  Cc_type_traits< __co_wtm >The attributes of co_wtm_t required by lely::COWTM
  Cc_type_traits< __io_poll >The attributes of io_poll_t required by lely::IOPoll
  Cc_type_traits< can_buf >The attributes of can_buf required by lely::CANBuf
  Cc_type_traits< void >A class template supplying a uniform interface to certain attributes of the C type void
   C__type
  CCANBufA CAN frame buffer
  CCANNetAn opaque CAN network interface type
  CCANRecvAn opaque CAN frame receiver type
  CCANTimerAn opaque CAN timer type
  Cco_type_traitsA class template mapping CANopen types to C++ types
  Cco_type_traits_NA class template mapping CANopen types to C++ types
  Cco_type_traits_TA class template mapping CANopen types to C++ types
  Cco_type_traits_T< bool >
  Cco_type_traits_T< char * >
  Cco_type_traits_T< char16_t * >
  Cco_type_traits_T< char16_t[N]>
  Cco_type_traits_T< char[N]>
  Cco_type_traits_T< co_time_diff_t >
  Cco_type_traits_T< co_time_of_day_t >
  Cco_type_traits_T< double >
  Cco_type_traits_T< float >
  Cco_type_traits_T< int_least16_t >
  Cco_type_traits_T< int_least32_t >
  Cco_type_traits_T< int_least64_t >
  Cco_type_traits_T< int_least8_t >
  Cco_type_traits_T< uint_least16_t >
  Cco_type_traits_T< uint_least32_t >
  Cco_type_traits_T< uint_least64_t >
  Cco_type_traits_T< uint_least8_t * >
  Cco_type_traits_T< uint_least8_t >
  Cco_type_traits_T< void * >
  Cco_type_traits_T<::std::basic_string< char16_t > >
  Cco_type_traits_T<::std::string >
  Cco_type_traits_T<::std::vector< uint_least8_t > >
  CCOCSDOAn opaque CANopen Client-SDO service type
  CCOCSDOUpConA CANopen Client-SDO upload confirmation callback wrapper that deserializes the received value on success
  CCOCSDOUpCon< char * >A CANopen Client-SDO upload confirmation callback wrapper that deserializes the received array of visible characters on success
  CCOCSDOUpCon< char16_t * >A CANopen Client-SDO upload confirmation callback wrapper that deserializes the received array of (16-bit) Unicode characters on success
  CCOCSDOUpCon< uint_least8_t * >A CANopen Client-SDO upload confirmation callback wrapper for an array of octets
  CCOCSDOUpCon< void * >A CANopen Client-SDO upload confirmation callback wrapper for an arbitrary large block of data
  CCOCSDOUpCon<::std::basic_string< char16_t > >A CANopen Client-SDO upload confirmation callback wrapper that deserializes the received array of (16-bit) Unicode characters on success
  CCOCSDOUpCon<::std::string >A CANopen Client-SDO upload confirmation callback wrapper that deserializes the received array of visible characters on success
  CCOCSDOUpCon<::std::vector< uint_least8_t > >A CANopen Client-SDO upload confirmation callback wrapper that deserializes the received array of octets on success
  CCODevAn opaque CANopen device type
  CCOEmcyAn opaque CANopen EMCY producer/consumer service type
  CCOGWAn opaque CANopen gateway type
  CCOGWTxtAn opaque CANopen ASCII gateway client type
  CCOLSSAn opaque CANopen LSS master/slave service type
  CCONMTAn opaque CANopen NMT master/slave service type
  CCOObjAn opaque CANopen object type
  CCORPDOAn opaque CANopen Receive-PDO service type
  CCOSSDOAn opaque CANopen Server-SDO service type
  CCOSubAn opaque CANopen sub-object type
  CCOSubDnIndA CANopen CANopen sub-object download indication callback wrapper
  CCOSubUpIndA CANopen CANopen sub-object upload indication callback wrapper
  CCOSyncAn opaque CANopen SYNC producer/consumer service type
  CCOTimeAn opaque CANopen TIME producer/consumer service type
  CCOTPDOAn opaque CANopen Transmit-PDO service type
  CCOValA CANopen value
  CCOVal< CO_DEFTYPE_DOMAIN >A CANopen value containing an arbitrary large block of data
  CCOVal< CO_DEFTYPE_OCTET_STRING >A CANopen value containing an array of octets
  CCOVal< CO_DEFTYPE_UNICODE_STRING >A CANopen value containing an array of (16-bit) Unicode characters
  CCOVal< CO_DEFTYPE_VISIBLE_STRING >A CANopen value containing an array of visible characters
  CCOWTMAn opaque CANopen Wireless Transmission Media (WTM) interface type
  Cdelete_c_typeThe deleter for trivial, standard layout and incomplete C types
  CerrorThe type of objects thrown as exceptions to report a system error with an associated error code
  Cincomplete_c_typeThe base class for a C++ interface to an incomplete C type
  CIOCANA Controller Area Network (CAN) device handle
  CIOFileA regular file device handle
  CIOHandleAn I/O device handle
  CIOPipeA pipe I/O device handle
  CIOPollAn opaque I/O polling interface type
  CIOSerialA serial I/O device handle
  CIOSockA sock I/O device handle
  Cstandard_c_typeThe base class for a C++ interface to a standard layout C type
  Ctrivial_c_typeThe base class for a C++ interface to a trivial C type
 NstdSTL namespace
  Cis_error_code_enum<::lely::canopen::SdoErrc >
 C[struct].ctx
 C[struct].io_sigset_shared
  C[struct].io_sigset_shared.sig
 C[struct].sigctx
 C__can_netA CAN network interface
 C__can_recvA CAN frame receiver
 C__can_timerA CAN timer
 C__co_csdoA CANopen Client-SDO
 C__co_csdo_stateA CANopen Client-SDO state
 C__co_devA CANopen device
 C__co_emcyA CANopen EMCY producer/consumer service
 C__co_gwA CANopen gateway
 C__co_gw_txtA CANopen ASCII gateway
 C__co_lssA CANopen LSS master/slave service
 C__co_lss_stateA CANopen LSS state
 C__co_nmtA CANopen NMT master/slave service
 C__co_nmt_bootA CANopen NMT 'boot slave' service
 C__co_nmt_boot_stateA CANopen NMT 'boot slave' state
 C__co_nmt_cfgA CANopen NMT 'configuration request' service
 C__co_nmt_cfg_stateA CANopen NMT 'configuration request' state
 C__co_nmt_hbA CANopen NMT heartbeat consumer
 C__co_nmt_stateA CANopen NMT state
 C__co_objA CANopen object
 C__co_rpdoA CANopen Receive-PDO
 C__co_ssdoA CANopen Server-SDO
 C__co_ssdo_stateA CANopen Server-SDO state
 C__co_subA CANopen sub-object
 C__co_syncA CANopen SYNC producer/consumer service
 C__co_timeA CANopen TIME producer/consumer service
 C__co_time_diffA 48-bit struct used to describe absolute and relative times
 C__co_time_of_dayA 48-bit struct used to describe absolute and relative times
 C__co_tpdoA CANopen Transmit-PDO
 C__co_wtmA CANopen Wireless Transmission Media (WTM) interface
 C__configA configuration struct
 C__frbufAn read file buffer struct
 C__fwbufAn (atomic) write file buffer struct
 C__io_addrAn opaque network address type
  C[union].addrThe network address
 C__io_attrAn opaque serial I/O device attributes type
 C__io_pollAn I/O polling interface
 CbimapA bidirectional map
 CbinodeA node in a bidirectional map
 CbitsetA variable-sized bitset
 CcanA CAN device
 Ccan_bufA CAN frame buffer
 Ccan_errA CAN error frame
 Ccan_msgA CAN or CAN FD format frame
 Cco_1003The pre-defined error field
 Cco_array_hdrThe header directly preceding the bytes in a CANopen array
 Cco_csdo_dn_dcfThe state of a concise DCF download request
 Cco_ctx_tThe type holding the context (i.e., program counter) of a stackless coroutine
 Cco_emcy_msgAn EMCY message
 Cco_emcy_nodeA remote CANopen EMCY producer node
 Cco_gw_conThe common parameters of a CANopen gateway confirmation
 Cco_gw_con__lss_scanThe parameters of a Lely-specific gateway 'LSS Slowscan/Fastscan' confirmation
 Cco_gw_con_get_versionThe parameters of a CANopen gateway 'Get version' confirmation
 Cco_gw_con_lss_get_idThe parameters of a CANopen gateway 'LSS inquire node-ID' confirmation
 Cco_gw_con_lss_get_lssidThe parameters of a CANopen gateway 'Inquire LSS address' confirmation
 Cco_gw_con_pdo_readThe parameters of a CANopen gateway 'Read PDO' confirmation
 Cco_gw_con_sdo_upThe parameters of a CANopen gateway 'SDO upload' confirmation
 Cco_gw_ind__bootThe parameters of a Lely-specific gateway 'Boot slave process completed' indication
 Cco_gw_ind__syncThe parameters of a Lely-specific gateway 'Synchronization event received' indication
 Cco_gw_ind__timeThe parameters of a Lely-specific gateway 'Time stamp event received' indication
 Cco_gw_ind_ecThe parameters of a CANopen gateway 'Error control event received' indication
 Cco_gw_ind_emcyThe parameters of a CANopen gateway 'Emergency event received' indication
 Cco_gw_ind_rpdoThe parameters of a CANopen gateway 'RPDO received' indication
 Cco_gw_ind_sdoThe parameters of a CANopen gateway 'CiA 301 progress indication download' indication
 Cco_gw_jobA CANopen gateway network job
 Cco_gw_netA CANopen network
 Cco_gw_reqThe common parameters of a CANopen gateway request
 Cco_gw_req__lss_scanThe parameters of a Lely-specific gateway 'LSS Slowscan/Fastscan' request
 Cco_gw_req_initThe parameters of a CANopen gateway 'Initialize gateway' request
 Cco_gw_req_lss_get_lssidThe parameters of a CANopen gateway 'Inquire LSS address' request
 Cco_gw_req_lss_id_slaveThe parameters of a CANopen gateway 'LSS identify remote slave' request
 Cco_gw_req_lss_set_rateThe parameters of a CANopen gateway 'LSS configure bit-rate' request
 Cco_gw_req_lss_switchThe parameters of a CANopen gateway 'LSS switch state global' request
 Cco_gw_req_lss_switch_rateThe parameters of a CANopen gateway 'LSS activate new bit-rate' request
 Cco_gw_req_lss_switch_selThe parameters of a CANopen gateway 'LSS switch state selective' request
 Cco_gw_req_netThe common parameters of a CANopen gateway network-level request
 Cco_gw_req_nmt_set_hbThe parameters of a CANopen gateway 'Start heartbeat consumer' request
 Cco_gw_req_nmt_set_ngThe parameters of a CANopen gateway 'Enable node guarding' request
 Cco_gw_req_nodeThe common parameters of a CANopen gateway node-level request
 Cco_gw_req_pdo_readThe parameters of a CANopen gateway 'Read PDO' request
 Cco_gw_req_pdo_writeThe parameters of a CANopen gateway 'Write PDO' request
 Cco_gw_req_sdo_dnThe parameters of a CANopen gateway 'SDO download' request
 Cco_gw_req_sdo_upThe parameters of a CANopen gateway 'SDO upload' request
 Cco_gw_req_set_bootup_indThe parameters of a CANopen gateway 'Boot-up forwarding' request
 Cco_gw_req_set_cmd_sizeThe parameters of a CANopen gateway 'Set command size' request
 Cco_gw_req_set_cmd_timeoutThe parameters of a CANopen gateway 'Set command time-out' request
 Cco_gw_req_set_emcyThe parameters of a CANopen gateway 'Start/Stop emergency consumer' request
 Cco_gw_req_set_hbThe parameters of a CANopen gateway 'Set heartbeat producer' request
 Cco_gw_req_set_rpdoThe parameters of a CANopen gateway 'Configure RPDO' request
 Cco_gw_req_set_sdo_timeoutThe parameters of a CANopen gateway 'Configure SDO time-out' request
 Cco_gw_req_set_tpdoThe parameters of a CANopen gateway 'Configure TPDO' request
 Cco_gw_srvThe common parameters of a CANopen gateway service
 Cco_idAn identity record
 Cco_nmt_slaveA struct containing the state of an NMT slave
 Cco_nmt_srvA CANopen NMT service manager
 Cco_pdo_comm_parA PDO communication parameter record
 Cco_pdo_map_parA PDO mapping parameter record
 Cco_sdevA static CANopen device
 Cco_sdo_parAn SDO parameter record
 Cco_sdo_reqA CANopen SDO upload/download request
 Cco_sobjA static CANopen object
 Cco_ssubA static CANopen sub-object
 Cco_valA union of the CANopen static data types
 Cco_wtm_canA CANopen WTM CAN interface
 Cconfig_entryAn entry in a configuration section
 Cconfig_sectionA section in a configuration struct
 CdllistA doubly-linked list
 CdlnodeA node in a doubly-linked list
 Cev_exec_node
 Cev_exec_vtbl
 Cev_fiber_cnd_implThe implementation of a fiber condition variable
 Cev_fiber_cnd_tA synchronization primitive (similar to the standard C11 condition variable) that can be used to block one or more fibers until another fiber or thread both modifies the shared variable (the condition), and notifies the condition variable
 Cev_fiber_cnd_waitThe context of a wait operation on a fiber condition variable
 Cev_fiber_ctxThe context of a fiber used for executing tasks
 Cev_fiber_execThe implementation of a fiber executor
 Cev_fiber_mtx_implThe implementation of a fiber mutex
 Cev_fiber_mtx_tA synchronization primitive (similar to the standard C11 mutex) that can be used to protect shared data from being simultaneously accessed by multiple fibers
 Cev_fiber_thrdThe parameters used for creating fibers on this thread and the list of unused fibers
 Cev_futureA future
 Cev_future_when_all
 Cev_future_when_any
 Cev_loopA polling event loop
 Cev_loop_ctxAn event loop context
 Cev_loop_thrdAn event loop thread
 Cev_poll_vtbl
 Cev_promiseA promise
 Cev_std_exec
 Cev_std_exec_impl_vtbl
 Cev_strand
 Cev_taskAn executable task
 Cev_task_node
 Cev_thrd_loopA thread-local event loop
 CfiberA fiber
 Cfiber_thrdA thread-local struct containing the fiber associated with the thread and a pointer to the fiber currently running in the thread
 CfileA regular file handle
 CflocA location in a text file
 Cifr_handle
 Cio_addrinfoA network address info structure
 Cio_can_attr
 Cio_can_chan_async_read
 Cio_can_chan_async_write
 Cio_can_chan_implThe implementation of a CAN channel
 Cio_can_chan_readA CAN channel read operation
 Cio_can_chan_read_resultThe result of a CAN channel read operation
 Cio_can_chan_vtbl
 Cio_can_chan_writeA CAN channel write operation
 Cio_can_ctrl_impl
 Cio_can_ctrl_vtbl
 Cio_can_frame
 Cio_can_netThe implementation of a CAN network interface
 Cio_can_rt
 Cio_can_rt_async_read_err
 Cio_can_rt_async_read_msg
 Cio_can_rt_async_shutdown
 Cio_can_rt_read_errA CAN error frame read operation suitable for use with a CAN frame router
 Cio_can_rt_read_err_resultThe result of a CAN error frame read operation
 Cio_can_rt_read_msgA CAN frame read operation suitable for use with a CAN frame router
 Cio_can_rt_read_msg_resultThe result of a CAN frame read operation
 Cio_clock_monotonic
 Cio_clock_realtime
 Cio_clock_vtbl
 Cio_cpAn I/O completion packet
 Cio_ctx
 Cio_dev_vtbl
 Cio_eventAn I/O event
  C[union].uSignal attributes depending on the value of events
 Cio_handleAn I/O device handle
 Cio_handle_vtabThe virtual table of an I/O device handle
 Cio_ifinfoA structure describing a network interface
 Cio_poll
 Cio_poll_thrd
 Cio_poll_watchAn object representing a file descriptor being monitored for I/O events
 Cio_sigset_async_wait
 Cio_sigset_impl
 Cio_sigset_node
 Cio_sigset_vtbl
 Cio_sigset_waitA wait operation suitable for use with a signal handler
 Cio_svcAn I/O service
 Cio_svc_vtblThe virtual table of an I/O service
 Cio_timer_async_wait
 Cio_timer_impl
 Cio_timer_vtbl
 Cio_timer_waitA wait operation suitable for use with an I/O timer
 Cio_timer_wait_resultThe result of an I/O timer wait operation
 Cio_tqueue
 Cio_tqueue_async_wait
 Cio_tqueue_waitA wait operation suitable for use with a timer queue
 Cio_user_can_chanThe implementation of a user-defined CAN channel
 Cio_user_can_frame
  C[union].u
 Cio_user_timer
 Cio_vcan_chanThe implementation of a virtual CAN channel
 Cio_vcan_ctrlThe implementation of a virtual CAN controller
 Cio_vcan_frame
  C[union].u
 Cio_watchThe attributes of an I/O device handle being watched
 CitimerspecA struct specifying an interval and initial value for a timer
 Cmax_align_tAn object type whose alignment is as great as is supported by the implementation in all contexts
 CmembufA memory buffer
 CpheapA pairing heap
 CpnodeA node in a pairing heap
 CrbnodeA node in a red-black tree
 CrbtreeA red-black tree
 Crtnl_handle
 CsllistA singly-linked list
 CslnodeA node in a singly-linked list
 CsockA network socket
 CspscringA single-producer, single-consumer ring buffer
  C[struct].p
   C[struct]spscring_ctx.p.ctx
   C[struct]spscring_sig.p.sig
  C[struct].c
   C[struct]spscring_ctx.c.ctx
   C[struct]spscring_sig.c.sig
 Cstop_funcAn object providing the means to register a callback function with an stop_token_t object
 Cstop_sourceA stop source
 Cstop_tokenA stop token
 CtimespecA time type with nanosecond resolution