| ►CACCESS_API | |
| ►CCpl::Itc::AtomicRequest< ACCESS_API > | This concrete class define the 'Atomic' Message request that allows a client to invoke multiple operation on a server/service as one single atomic operation |
| CCpl::Itc::AtomicSync< ACCESS_API > | This concrete class provides the ITC wrapper implementation for calling the "Atomic Api" synchronously |
| CCpl::Memory::Aligned< sizeInBytes > | This type is used to create a memory-block that is aligned to a size_t boundary |
| CCpl::Memory::AlignedClass< T > | This type is used to create a memory block that is large enough to hold the memory footprint of ONE instance of 'class T' |
| CCpl::Memory::AlignedClass< AlertObserver > | |
| CCpl::Memory::AlignedClass< Cpl::Io::File::Littlefs::FileDesc_T > | |
| CCpl::Memory::AlignedClass< Cpl::Io::Socket::InputOutput > | |
| CAjax::Heating::Flc::Api | This class implements the Fuzzy logic controller as defined by the SWA-1330 GM6000 Fuzzy Logic Temperature Control document |
| CCpl::Io::File::Api | This concrete class defines the interface for handling and manipulating entries in the System's File system |
| CCpl::Io::File::Littlefs::Api | This 'singleton' class is used to create and manage the littlefs file system |
| CCpl::System::Api | This class defines methods for initializing the Colony.Core class library and other startup/init actions |
| ►CDriver::NV::Api | This class defines the interface for a platform independent Non-volatile storage driver |
| CDriver::NV::File::Cpl::Api | This class implements the Non-volatile storage driver using the Cpl::Io::File interfaces |
| CDriver::NV::Gang | This class implements the Non-volatile storage driver using a collection of NV drivers to provide a 'flat address' space that spans multiple discrete storage chips/media |
| CDriver::NV::Null | This concrete class provides a 'null' implementation of the NV Storage interface |
| CDriver::NV::Onsemi::CAT24C512::Api | This class implements the Non-volatile storage driver for the Onsemi CAT24C512 serial 512Kb (64KB) I2C EEPROM |
| CDriver::PicoDisplay::Api | This class defines an interface for accessing the 'hardware bits' of the Pico Display board |
| ►CDriver::RHTemp::Api | This class defines an interface for reading and managing a combined RH and Temperature sensor |
| CDriver::RHTemp::Simulated::Api | This class implements the RH/Temperature driver interface using model points as the physical signals |
| ►CCpl::Checksum::Api16 | This class provides an interface for calculate a 16 bit wide Checksum |
| CCpl::Checksum::Crc16CcittFast | This class provides an implementation for the 16 Bit CRC-CCITT standard |
| CCpl::Checksum::Fletcher16 | This class provides an implementation for the 16 Bit wide Fletcher Checksum |
| ►CCpl::Checksum::Api32 | This class provides an interface for calculate a 32 bit wide Checksum |
| CCpl::Checksum::Crc32EthernetFast | This class provides an implementation for the 32 Bit "Ethernet" standard |
| ►CCpl::Checksum::ApiMd5 | This class provides an interface for performing a MD5 Hash on a collection of bytes |
| CCpl::Checksum::Md5Aladdin | This class provides an implementation for the MD5 Hash interface that is wrapper to the third party MD5 Library code developed by L |
| ►CCpl::Io::Tcp::AsyncConnector | This abstract class defines the interface for establishing/requesting a SIMPLE socket connection, i.e |
| CCpl::Io::Tcp::Win32::AsyncConnector | This class implements the Asynchronous Connector |
| ►CCpl::Io::Tcp::AsyncListener | This abstract class defines the interface for a SIMPLE socket listener |
| CCpl::Io::Tcp::Win32::AsyncListener | This class implements the Asynchronous Listener |
| ►CCpl::Itc::AtomicApi< ACCESS_API > | This abstract class provides an interface to allow a client to call the server synchronously to have the server invoke the client's atomic operation |
| CCpl::Itc::AtomicSync< ACCESS_API > | This concrete class provides the ITC wrapper implementation for calling the "Atomic Api" synchronously |
| CCpl::Itc::AtomicCallback< ACCESS_API > | This abstract class defines a call-back interface that clients use to issue multiple service requests as a single "atomic" operation |
| CCpl::Itc::AtomicResponse< ACCESS_API > | This abstract class define response message types for a set of ITC services |
| CCpl::Container::AvlTree_ | This concrete class implements the core functionality of for AVL Binary tree (i.e |
| CCpl::Text::Tokenizer::Basic | This concrete class performs basic tokenizing/parse functions on a string |
| ►CCpl::Io::File::Littlefs::BlockDriverApi | This partial abstract class defines the interface for block drivers |
| CCpl::Io::File::Littlefs::BdFile | Concrete Block Driver that uses the Host's file system for the persistent storage media |
| CCpl::Io::File::Littlefs::BdSpi | Concrete Block Driver for a 'traditional' SPI based NOR flash |
| ►CCpl::Persistent::Chunk | This abstract class defines the interface for a Chunk |
| CCpl::Persistent::CrcChunk | This concrete class implements the Chunk interface by using a 32Bit CRC for ensuring data integrity |
| CCpl::Persistent::MirroredChunk | This concrete class implements the Chunk interface by storing two copies of the Record's data |
| ►CCpl::Persistent::ClearAllEntriesRequest | This abstract class define ITC message type and payload for the application to clear/delete all entries |
| CCpl::Persistent::IndexedEntryServer< Cpl::Logging::EntryData_T > | |
| CCpl::Persistent::IndexedEntryServer< ENTRY > | This concrete template class implements the ITC messaging (and Model Point monitoring) needed to provide a thread-safe/asynchronous interface for reading/writing 'Indexed Entries' |
| CCpl::Persistent::ClearAllEntriesResponse | This abstract class define ITC message type and payload for asynchronous response (to the application) of a ClearAllEntries message |
| ►CCpl::Io::Socket::Listener::Client | This class defines the callback mechanism used for accepting incoming socket connections |
| CCpl::Io::Socket::ListenerClientSync | This partially concrete class implements the synchronous ITC open call for the OpenApi |
| CCpl::TShell::Socket | This concrete class provides a socket listener/server and 'threading wrapper' for running a TShell Command Processor |
| ►CCpl::Itc::CloseApi | This abstract class defines an close interface |
| ►CCpl::Itc::CloseSync | This partially concrete class implements the synchronous ITC close call for the CloseApi |
| CCpl::Persistent::IndexedEntryServer< Cpl::Logging::EntryData_T > | |
| CAjax::Alerts::Summary | This class manages the content of the Alert Summary model point |
| CAjax::Heating::Io::Api | This class is responsible for 'translating' physical hardware signal to/from model point values |
| ►CAjax::Heating::Supervisor::Api | This class implements the Heating Algorithm Supervisor |
| CAjax::Heating::Simulated::House | This class glues the House Simulation into the Heater Application |
| CAjax::Metrics::Api | This class manages the collection of Metrics and triggering their updates to persistent storage |
| CAjax::ScreenMgr::Api | This class implements the Screen Manager |
| CAjax::Ui::LogicalButtons | This concrete class translates physical button actions into logical UI Button events |
| CAjax::Ui::StatusIndicator::Api | This class manages the what color/on-off-state of the RGB LED |
| CCpl::Logging::LogSink | This class is responsible for consuming the application's Log buffer and 'dispatching' log entries |
| CCpl::MApp::Manager | This concrete class implements the MApp Manager |
| CCpl::Persistent::IndexedEntryServer< ENTRY > | This concrete template class implements the ITC messaging (and Model Point monitoring) needed to provide a thread-safe/asynchronous interface for reading/writing 'Indexed Entries' |
| CCpl::Persistent::RecordServer | This concrete class provides an Event driven Runnable object for executing the read/write operation to persistent storage media for N Records |
| ►CDriver::AIO::Ajax::Thermistor | This class is responsible for sampling the on-board temperature sensor every N milliseconds and populating a model point |
| CDriver::AIO::Eros::Thermistor | This class is an Eros specific extension of the Driver::AIO::Ajax::Thermistor driver |
| CCpl::Itc::CloseRequest::ClosePayload | Payload for Message: Open |
| ►CCpl::Itc::CloseRequest | This abstract class define message types and payloads for a set of ITC services |
| CCpl::Itc::CloseSync | This partially concrete class implements the synchronous ITC close call for the CloseApi |
| CCpl::Itc::CloseResponse | This abstract class define response message types for a set of ITC services |
| CCpl::Io::File::Common_ | This private concrete class is a helper class that implements the common functions for the handling files |
| CAjax::Heating::Flc::Config_T | Struct defines the geometry of the input membership function |
| CDriver::DIO::InOut::Config_T | Configuration Options |
| CDriver::Wifi::Station::Connection | This class defines an asynchronous interface for a Station device to connect to a WIFI network |
| ►CCpl::Io::Socket::Connector | This abstract class defines the interface for establishing/requesting a SIMPLE socket connection, i.e |
| CCpl::Io::Socket::Posix::Connector | This concrete class implements the Cpl::Io::Socket::Connector interface using IPv4/IPv6 addressing for a Posix platform |
| CCpl::Io::Socket::Win32::Connector | This concrete class implements the Cpl::Io::Socket::Connector interface using IPv4/IPv6 addressing for the Win32 (aka winsock2) platform |
| CcorCoRoutineControlBlock | |
| ►CCpl::System::CounterSource_ | This abstract class defines the interface for registering for an Counter object with the Timer Manager |
| ►CCpl::System::TimerManager | This mostly concrete class implements manages a list of Software Timers |
| ►CCpl::System::EventLoop | This concrete class is a Runnable object that provides a event driven execution model for a thread |
| ►CCpl::Dm::EventLoop | This class extends the Cpl::System::EventLoop class to support the asynchronous change notification generated from Model Points |
| ►CCpl::Dm::MailboxServer | This class extends the Cpl::Dm::EventLoop and Cpl::Itc:Mailbox classes to support the asynchronous change notification generated from Model Points with ITC messaging |
| CCpl::Dm::PeriodicScheduler | This class extends the Cpl::Dm::MailboxServer class to add periodic scheduling to an event based 'thread' |
| CCpl::Persistent::RecordServer | This concrete class provides an Event driven Runnable object for executing the read/write operation to persistent storage media for N Records |
| ►CCpl::Itc::MailboxServer | This class collects the common functions of a generic server providing a mailbox and Event loop |
| CCpl::Itc::PeriodicScheduler | This class extends the Cpl::Itc::MailboxServer class to add periodic scheduling to an event based 'thread' |
| CCplContainerDList_T | This structure define the internal structure of a Doubly Linked List |
| CCplContainerItemDListLinkage_T | Type definition for a Doubly linked item |
| CCplContainerItemSListLinkage_T | Type definition for a singly linked item |
| CCplContainerSList_T | This structure define the internal structure of a Singly Linked List |
| CAjax::Dm::MpAlert::Data | The MP's Data container |
| CAjax::Dm::MpAlertSummary::Data | The MP's Data container |
| ►CCpl::Text::Frame::Decoder | This class defines an interface for 'receiving' (decode) a frame |
| ►CCpl::Text::Frame::Decoder_ | This private partially concrete class implements the basic/common logic for a frame decoder |
| ►CCpl::Text::Frame::StreamDecoder | This partially concrete class defines an interface a Text "Decoder" that has a Cpl::Io::Input stream as its input source |
| CCpl::Text::Frame::LineDecoder< OPTION_CPL_TSHELL_PROCESSOR_INPUT_SIZE > | |
| CCpl::Text::Frame::AsciiDecoder< BUFSIZE > | This concrete template class provide a basic implementation of the Frame::Decoder interface that uses Cpl::Io::Input stream as the input source |
| CCpl::Text::Frame::LineDecoder< BUFSIZE > | This concrete template class provide a basic implementation of the Frame::Decoder interface that uses Cpl::Io::Input stream as the input source |
| CDriver::TPipe::Maker | This concrete class is a "Maker" that assembles the objects needed for TPipe |
| CCpl::Text::Frame::StringDecoder | This concrete class defines an interface a Text "Decoder" that accepts a null terminated string as its input source |
| CCpl::Io::Descriptor | This union defines a 'IO descriptor' in terms of a an integer and/or a void* |
| CCpl::Io::Descriptor.__unnamed2__ | Union the different possible types for a descriptor |
| CCpl::Container::DHashTable_ | This concrete class implements the core functionality for a Dictionary and/or Hash Table |
| CCpl::Container::Dictionary< ITEM > | This template class implements a Dictionary and/or Hash Table |
| CCpl::Io::File::Api::DirectoryWalker | This abstract class defines the client interface for walking the contents of a directory, i.e |
| CCpl::Io::File::DirList_::DirEntry_T | Structure to hold the directory name and depth |
| CCpl::Io::File::DirList_ | This private concrete does the work for Api::walkDirectory() method |
| ►CAjax::ScreenMgr::DisplayApi | This class defines the Screen Manager's interface to Graphic library |
| CAjax::Ui::PicoDisplay | This concrete class implements the Ajax::ScreenMgr::DisplayApi using the Driver::PicoDisplay driver |
| CCpl::Container::DList< ITEM > | This template class implements a Doubly linked list which maintains the ordering imposed on it by the application |
| CCpl::Container::DList< Ajax::ScreenMgr::Api::NavigationElement > | |
| CCpl::Container::DList< Cpl::Container::DictItem > | |
| CCpl::Container::DList< Cpl::Dm::SubscriberApi > | |
| CCpl::Container::DList< Cpl::Memory::Pool_::BlockInfo_ > | |
| CCpl::Container::DList< Cpl::System::CounterCallback_ > | |
| CDriver::Crypto::ED25519 | This class implements the Edwards-curve digital signature defined by Edwards-Curve Digital Signature Algorithm (EdDSA) [RFC8032], using standard parameters |
| CCpl::System::ElapsedTime | This class defines the interface for accessing the elapsed time since power up and/or reset of the platform |
| ►CCpl::Text::Frame::Encoder | This class defines an interface for 'transmitted' (encoding) a frame |
| ►CCpl::Text::Frame::Encoder_ | This Private Namespace partially concrete class implements common/helper method for supporting the Encoder API |
| ►CCpl::Text::Frame::StreamEncoder | This concrete class implements the Encoder API where the Output destination is a Cpl::Io::Output stream |
| CCpl::Text::Frame::BlockEncoder | This concrete class implements extends the StreamDecoder implementation to be more efficient with respect to outputting data to a Stream |
| CCpl::Text::Frame::StringEncoder | This concrete class implements the Encoder API where the Output destination is a Cpl::Text::String |
| CCpl::Persistent::IndexedEntryReader::EntryMarker_T | This structure define an 'marker' that identifies an entry's location in persistent media |
| ►CCpl::Dm::Persistent::EraseRequest | This abstract class define ITC message type and payload for the application to request invalidating/corrupting the Record in persistent storage (i.e |
| ►CCpl::Dm::Persistent::Record | This mostly concrete class implements the Cpl::Persistent::Record interface where a Record instance contains the data from N model points |
| CAjax::Main::MetricsRecord | This concrete class implements the "Record" class for storing user settings |
| CAjax::Main::PersonalityRecord | This concrete class implements the "Record" class for storing the 'Personality' settings |
| CAjax::Main::UserRecord | This concrete class implements the "Record" class for storing user settings |
| CCpl::Dm::Persistent::EraseResponse | This abstract class define ITC message type and payload for asynchronous response (to the application) of a Erase message |
| CCpl::System::SharedEventHandlerApi::EventCallback_T | Define a callback entry (i.e |
| ►CCpl::System::EventFlag | This abstract class defines the interface to generated a 'Event Flag' |
| CCpl::System::EventLoop | This concrete class is a Runnable object that provides a event driven execution model for a thread |
| ►CCpl::Io::Socket::Factory | This abstract class defines an interface for a Socket factory |
| CCpl::Io::Socket::StreamPool< N > | This concrete template class implement a socket factory that is capable of creating N concurrently opened socket streams |
| CCpl::System::FatalError | This class defines methods for handling fatal errors encountered by an application |
| CCpl::Container::FDictionary< ITEM, NBUCKETS > | This template class implements a Dictionary and/or Hash Table with a FIXED memory allocation (i.e |
| CCpl::Container::FHashTable_< N > | This concrete class implements the core functionality for a Dictionary and/or Hash Table |
| CCpl::Container::FHashTable_< NBUCKETS > | |
| CCpl::Io::File::Littlefs::FileDesc_T | This struct defines the memory need per opened file |
| CCpl::Io::File::Littlefs::FileMemoryPool | Memory pool for opened files |
| ►CCpl::Dm::Persistent::FlushRequest | This abstract class define ITC message type and payload for the application to request flushing the Record to persistent storage |
| CCpl::Dm::Persistent::Record | This mostly concrete class implements the Cpl::Persistent::Record interface where a Record instance contains the data from N model points |
| CCpl::Dm::Persistent::FlushResponse | This abstract class define ITC message type and payload for asynchronous response (to the application) of a Flush message |
| ►CFsm | Here is the graph that shows the state machine this class implements |
| ►CAjax::Heating::Supervisor::FsmEventQueue_ | Event Queue for FSM events |
| CAjax::Heating::Supervisor::Api | This class implements the Heating Algorithm Supervisor |
| CAjax::Heating::Supervisor::FsmContext_ | Context (aka actions/guards) for my Finite State Machine |
| ►CCpl::MApp::GetAvailableMAppRequest | This abstract class define ITC message type and payload for the application to get list of all of the MApps instances |
| CCpl::MApp::Manager | This concrete class implements the MApp Manager |
| ►CCpl::Persistent::GetByBufferIndexRequest | This abstract class define ITC message type and payload for the application to request read Indexed Entry data |
| CCpl::Persistent::IndexedEntryServer< Cpl::Logging::EntryData_T > | |
| CCpl::Persistent::IndexedEntryServer< ENTRY > | This concrete template class implements the ITC messaging (and Model Point monitoring) needed to provide a thread-safe/asynchronous interface for reading/writing 'Indexed Entries' |
| CCpl::Persistent::GetByBufferIndexResponse | This abstract class define ITC message type and payload for asynchronous response (to the application) of a GetByBufferIndex message |
| ►CCpl::Persistent::GetLatestRequest | This abstract class define ITC message type and payload for the application to request read Indexed Entry data |
| CCpl::Persistent::IndexedEntryServer< Cpl::Logging::EntryData_T > | |
| CCpl::Persistent::IndexedEntryServer< ENTRY > | This concrete template class implements the ITC messaging (and Model Point monitoring) needed to provide a thread-safe/asynchronous interface for reading/writing 'Indexed Entries' |
| CCpl::Persistent::GetLatestResponse | This abstract class define ITC message type and payload for asynchronous response (to the application) of a GetLatest message |
| ►CCpl::Persistent::GetNextRequest | This abstract class define ITC message type and payload for the application to request read Indexed Entry data |
| CCpl::Persistent::IndexedEntryServer< Cpl::Logging::EntryData_T > | |
| CCpl::Persistent::IndexedEntryServer< ENTRY > | This concrete template class implements the ITC messaging (and Model Point monitoring) needed to provide a thread-safe/asynchronous interface for reading/writing 'Indexed Entries' |
| CCpl::Persistent::GetNextResponse | This abstract class define ITC message type and payload for asynchronous response (to the application) of a GetNext message |
| ►CCpl::Persistent::GetPreviousRequest | This abstract class define ITC message type and payload for the application to request read Indexed Entry data |
| CCpl::Persistent::IndexedEntryServer< Cpl::Logging::EntryData_T > | |
| CCpl::Persistent::IndexedEntryServer< ENTRY > | This concrete template class implements the ITC messaging (and Model Point monitoring) needed to provide a thread-safe/asynchronous interface for reading/writing 'Indexed Entries' |
| CCpl::Persistent::GetPreviousResponse | This abstract class define ITC message type and payload for asynchronous response (to the application) of a GetPrevious message |
| ►CCpl::MApp::GetStartedMAppRequest | This abstract class define ITC message type and payload for the application to Get a list of started MApp instances |
| CCpl::MApp::Manager | This concrete class implements the MApp Manager |
| CCpl::System::GlobalLock | This class defines an interface for a "Global Lock" |
| CCpl::Type::Guid_T | This structure defines a type for a 16 Byte GUID/UUID |
| CCpl::Type::Guid_T.__unnamed6__ | Value as single memory block, and/or internal structure |
| CCpl::Type::Guid_T.__unnamed6__.__unnamed8__ | |
| CCpl::Io::Serial::ST::M32F4::StreamDriver::HalMapping_T | Used to map a HAL UART Handle to an instance of this class |
| ►CDriver::Crypto::Hash | This class defines an abstract interface for a Hashing Algorithms |
| CDriver::Crypto::Orlp::SHA512 | This class implements the Hash interface using Orson Peter's SHA512 algorithm |
| CCpl::Container::HashTable_ | This concrete provides a collection of functions used by the 'Hash Table' classes |
| CCpl::Container::HashTableStats | This struct defines what usage/stats can be retrieved from a Hash table |
| CHeapRegion | |
| CAjax::SimHouse::House | This class provides a 'functional' simulation of house with respect to Outdoor temperature, Indoor temperature, and active HVAC capacity |
| CDriver::DIO::In | This class defines a generic interface for sampling a single Digital Input signal |
| CCpl::Persistent::IndexedEntryReader | This abstract class defines interface for reading/retrieve 'entries' from a a collection of entries (i.e |
| CCpl::Persistent::IndexedEntryWriter | This abstract class defines interface for appending a single 'entry' to a a collection of entries (i.e |
| CCpl::Io::File::Api::Info | This data structure defines status attributes for a file system entry |
| CDriver::DIO::InOut | This class defines a generic interface for controlling N Digital inputs and M Digital outputs |
| CCpl::Math::IntegerExpressionParser< T > | This template class evaluates an null terminate string that represents an integer arithmetic expression |
| CCpl::System::PeriodicScheduler::Interval_T | Defines an interval |
| ►CCpl::Io::IsEos | This abstract class defines a isEos() operation that is intended to be used Input and Output streams |
| ►CCpl::Io::Input | This partially abstract class defines a interface for operating on an input stream (example of a stream is 'stdin' or a socket connection) |
| ►CCpl::Io::File::InputApi | This abstract class defines the interface for a Random Access Input File |
| CCpl::Io::File::Input | This concrete class provides a platform independent 'standard' implementation of a Cpl::Io::File::Input object |
| ►CCpl::Io::File::InputOutputApi | This abstract class defines the interface for a Random Access Input Output File |
| CCpl::Io::File::InputOutput | This concrete class provides a platform independent 'standard' implementation of an InputOutputFileApi object |
| CCpl::Io::File::Null | This concrete class implements a NULL InputOutputApi File that all of its input operations return 'End-of-File' (i.e |
| ►CCpl::Io::InputOutput | This abstract class defines a interface for operating on an input-output stream (example of a stream is socket connection) |
| CCpl::Io::Null | This concrete class implements a NULL InputOutput stream - that all of its input operations return 'End-of-Stream' (i.e |
| CCpl::Io::Ram::InputOutput | This concrete class implements an InputOutput stream using a Ring Buffer |
| CCpl::Io::Serial::Adafruit::Nrf5::BLE::InputOutput | This concrete class implements the InputOutput stream interface as a wrapper around Adafruit's BLEUart class |
| CCpl::Io::Serial::Adafruit::Nrf5::InputOutput | This concrete class implements the InputOutput stream interface as a wrapper around Adafruit's Arduino UART class |
| CCpl::Io::Serial::Arduino::InputOutput | This concrete class implements the InputOutput stream interface as a wrapper around Arduino Serial class |
| CCpl::Io::Serial::PhonyStdio::InputOutput | This concrete class implements the InputOutput stream interface built on top the C Library's fread/fwrite functions with the 'stdin' and 'stdout' file handles |
| CCpl::Io::Serial::ST::M32F4::InputOutput | This concrete class implements the InputOutput stream interface built on top of ST HAL Layer/SDK |
| CCpl::Io::Socket::InputOutput | This concrete class provides a platform independent 'standard' implementation of an InputOutput stream object where the stream is Socket connection |
| CCpl::Io::Stdio::InputOutput_ | This concrete class implements a Input-Output stream |
| ►CCpl::Io::Tcp::InputOutput | This concrete class defines a platform independent implementation of an InputOutput stream used by the Listener and Connector interfaces |
| CCpl::Io::Tcp::AsyncConnector::Client | This class defines the callback mechanism used for accepting incoming TCP connections |
| CCpl::Io::Tcp::AsyncListener::Client | This class defines the callback mechanism used for accepting incoming TCP connections |
| ►CCpl::Io::Stdio::Input_ | This concrete class implements a Input stream using the underlying platform's native OS 'file interface' for the C library's stdin, stdout, and stderr streams |
| CCpl::Io::Stdio::StdIn | This concrete class represents the C-library 'stdin' stream |
| ►CCpl::Io::Output | This partially abstract class defines a interface for operating on an output stream (example of a stream is 'stdout' or a socket connection) |
| ►CCpl::Io::AtomicOutputApi< CONTEXT > | This abstract template class defines a interface for an Atomic outputs to a stream |
| CCpl::Io::AtomicOutput< CONTEXT > | This concrete template class implements the AtomicOutputApi using a mutex to enforce the 'atomic-ness' of the operation, i.e |
| ►CCpl::Io::File::OutputApi | This abstract class defines the interface for a Random Access Input File |
| CCpl::Io::File::InputOutputApi | This abstract class defines the interface for a Random Access Input Output File |
| CCpl::Io::File::Output | This concrete class provides a platform independent 'standard' implementation of a Cpl::Io::File::Output object |
| CCpl::Io::InputOutput | This abstract class defines a interface for operating on an input-output stream (example of a stream is socket connection) |
| ►CCpl::Io::Stdio::Output_ | This concrete class implements a Output stream using the underlying platform's native OS 'file interface' for the C library's stdin, stdout, and stderr streams |
| CCpl::Io::Stdio::StdErr | This concrete class represents the C-library 'stderr' stream |
| CCpl::Io::Stdio::StdOut | This concrete class represents the C-library 'stdout' stream |
| CCpl::Io::TeeOutput | This concrete class implements a Output stream that outputs the data to MANY (or none) output streams |
| ►CCpl::Container::Item | This class is used by the Container classes to implement a various types of singly linked containers |
| ►CCpl::Container::ExtendedItem | This class is used by the Container classes to implement a various types of DOUBLY linked containers |
| CAjax::ScreenMgr::Api::NavigationElement | Type for 'elements' in the Navigation Stack |
| ►CCpl::Container::DictItem | This abstract class represents a item that can be contained in Dictionary |
| ►CCpl::Container::MapItem | This abstract class represents a item that can be contained in an Map (aka a sorted list implemented using an AVL tree) |
| ►CCpl::MApp::MAppApi | This abstract class defines the interface for a Micro Application (MApp) |
| ►CCpl::MApp::MApp_ | This partial concrete class provide common infrastructure that is common to all MApp instances |
| CCpl::MApp::Temperature::Api | This concrete class implements MApp the polls a model point for a temperature value and periodically writes the value to the trace output |
| CEros::Test::Cycle::Api | This concrete class implements MApp the duty cycles the heating equipment based on command arguments |
| CEros::Test::Thermistor::Api | This concrete class implements MApp the monitors the output of the specialized Eros Thermistor driver and periodically writes the temperature and ADC-bits values to the trace output |
| ►CCpl::TShell::Command | This class defines the interface for a TShell command |
| ►CCpl::TShell::Cmd::Command | This partially concrete class implements infrastructure and/or common functionality for a Shell command |
| CAjax::Heating::Simulated::Cmd | This class implements a Shell command |
| CAjax::TShell::Provision | This class implements a TShell command that is used to provision a GM6000 unit at production |
| CAjax::TShell::State | This class implements a TShell command that displays the current 'state' of the unit |
| CAjax::TShell::Ui | This class implements a TShell command that generates a UI event |
| CCpl::Dm::TShell::Dm | This class implements a TShell command |
| CCpl::Io::File::Littlefs::TShell::Fs | This class implements a TShell command for various file system commands for a system that is using a Littlefs file system |
| CCpl::Logging::TShell::Log | This class implements a TShell command that operates on the persistently store "log file" |
| CCpl::MApp::Cmd | The class implements a TShell command that interacts with the MApp Manager to start, stop, and list available MApp instances |
| CCpl::TShell::Cmd::Arduino::Dbg | This class implements a DAC Shell command |
| CCpl::TShell::Cmd::Bye | This class implements a Shell command |
| CCpl::TShell::Cmd::Help | This class implements a Shell command |
| CCpl::TShell::Cmd::TPrint | This class implements a Shell command |
| ►CCpl::TShell::Cmd::Threads | This class implements a Shell command |
| CCpl::TShell::Cmd::FreeRTOS::Threads | This class implements a TShell command |
| CCpl::TShell::Cmd::Win32::Threads | This class implements a TShell command |
| CCpl::TShell::Cmd::Tick | This class implements a Shell command |
| CCpl::TShell::Cmd::Trace | This class implements a Shell command |
| CCpl::TShell::Cmd::User | This class implements a Shell command |
| CCpl::TShell::Cmd::Wait | This class implements a Shell command |
| CDriver::Crypto::TShell::Random | This class implements a Shell command |
| CDriver::DIO::InOutCmd | This class implements a TShell command that exercises the RH/Temp driver |
| CDriver::NV::Cmd | This class implements a TShell command that tests/directly-operates on the NV media |
| CDriver::RHTemp::TShellCmd | This class implements a TShell command that exercises the RH/Temp driver |
| CDriver::Wifi::Station::TShell::Wifi | This class implements a TShell command |
| CEros::TShell::HwSafety | This class implements a TShell command to verify the PWM signals on the board |
| CEros::TShell::Pwm | This class implements a TShell command to verify the PWM signals on the board |
| CEros::TShell::Rgb | This class implements a TShell command to verify the operation of the RGB LED on the display board |
| ►CCpl::Text::StringItem | This partially concrete provides a wrapper class that allows a String object to be stored directly in one the CPL Containers |
| CCpl::Text::DFStringItem | This concrete class implements the StringItem class for a 'String' using a 'DFString' as the internal storage for String instance |
| CCpl::Text::DStringItem | This concrete class implements the StringItem class for a 'String' using a 'DString' as the internal storage for String instance |
| CCpl::Text::FStringItem< S > | This template class implements the StringItem class for a 'String' using a 'FString' as the internal storage for String instance |
| ►CDriver::TPipe::RxFrameHandlerApi | This abstract class defines the 'Received Frame Handler' interface for the TPipe |
| CDriver::TPipe::RxFrameHandler | This partially concrete class provides functionality that is common to all Frame handlers |
| ►CCpl::Dm::SubscriberApi | This abstract class defines the Subscriber interface - for change notifications - to a Model Points data/state |
| ►CCpl::Dm::SubscriberBase | This mostly concrete class defines the Subscriber interface - for change notifications - to a Model Points data/state |
| CCpl::Dm::Subscriber< Cpl::Dm::Mp::Uint32 > | |
| CCpl::Dm::Subscriber< Cpl::Dm::Mp::Bool > | |
| CCpl::Dm::Subscriber< Ajax::Dm::MpAlert > | |
| CCpl::Dm::Subscriber< Ajax::ScreenMgr::MpScreenApiPtr > | |
| CCpl::Dm::Subscriber< Ajax::ScreenMgr::MpStaticScreenApiPtr > | |
| CCpl::Dm::Subscriber< Ajax::Dm::MpFanMode > | |
| CCpl::Dm::Subscriber< Cpl::Dm::Mp::Int32 > | |
| CCpl::Dm::Subscriber< Ajax::Dm::MpAlertSummary > | |
| CCpl::Dm::Subscriber< Cpl::Dm::ModelPoint > | |
| CCpl::Dm::Subscriber< Cpl::Dm::Mp::ArrayInt32< 2 > > | |
| ►CCpl::Dm::Subscriber< MP > | This template class defines a type safe Subscriber |
| CCpl::Dm::SubscriberComposer< Ajax::Heating::Io::Api, Cpl::Dm::Mp::Uint32 > | |
| CCpl::Dm::SubscriberComposer< Ajax::Heating::Supervisor::Api, Cpl::Dm::Mp::Bool > | |
| CCpl::Dm::SubscriberComposer< Ajax::Metrics::Api, Cpl::Dm::Mp::Uint32 > | |
| CCpl::Dm::SubscriberComposer< Ajax::Metrics::Api, Ajax::Dm::MpAlert > | |
| CCpl::Dm::SubscriberComposer< Ajax::ScreenMgr::Api, Ajax::ScreenMgr::MpScreenApiPtr > | |
| CCpl::Dm::SubscriberComposer< Ajax::ScreenMgr::Api, Ajax::ScreenMgr::MpStaticScreenApiPtr > | |
| CCpl::Dm::SubscriberComposer< Ajax::ScreenMgr::Api, Cpl::Dm::Mp::Bool > | |
| CCpl::Dm::SubscriberComposer< Ajax::ScreenMgr::Api, Cpl::Dm::Mp::Uint32 > | |
| CCpl::Dm::SubscriberComposer< Ajax::Ui::Home::Screen, Cpl::Dm::Mp::Bool > | |
| CCpl::Dm::SubscriberComposer< Ajax::Ui::Home::Screen, Ajax::Dm::MpFanMode > | |
| CCpl::Dm::SubscriberComposer< Ajax::Ui::Home::Screen, Cpl::Dm::Mp::Int32 > | |
| CCpl::Dm::SubscriberComposer< Ajax::Ui::Home::Screen, Ajax::Dm::MpAlertSummary > | |
| CCpl::Dm::SubscriberComposer< Cpl::Dm::Persistent::Record, Cpl::Dm::ModelPoint > | |
| CCpl::Dm::SubscriberComposer< Cpl::Logging::LogSink, Cpl::Dm::Mp::Uint32 > | |
| CCpl::Dm::SubscriberComposer< Cpl::Persistent::IndexedEntryServer, Cpl::Dm::Mp::Uint32 > | |
| CCpl::Dm::SubscriberComposer< Eros::Test::Thermistor::Api, Cpl::Dm::Mp::ArrayInt32< 2 > > | |
| CCpl::Dm::SubscriberComposer< CONTEXT, MP > | This template class is a composer pattern/class that manages the callback function for a Model Point's Subscribers/Observers change notification |
| ►CCpl::Itc::Message | This abstract class defines the operations for an ITC message |
| CCpl::Itc::ResponseMessage< CLIENT, SERVER, PAYLOAD > | This template class represents a client response message, which is posted to the client's mailbox after the corresponding server request message is returned to the client via the server message returnToSender interface |
| ►CCpl::Itc::ServiceMessage | This class represents a defined message, which is posted to a mailbox-server as a request |
| CCpl::Itc::RequestMessage< SERVER, PAYLOAD > | This template class represents a service request message to a particular server |
| CCpl::Memory::Pool_::BlockInfo_ | Helper class so I can put my blocks into to my standard containers |
| ►CCpl::System::CounterCallback_ | This abstract class defines the call-back interface for a Counter object |
| ►CCpl::System::Timer | This mostly concrete interface defines the operations that can be performed on a software timer |
| CCpl::System::TimerComposer< Ajax::ScreenMgr::Api > | |
| CAjax::Heating::Io::Api | This class is responsible for 'translating' physical hardware signal to/from model point values |
| CAjax::Heating::Supervisor::Api | This class implements the Heating Algorithm Supervisor |
| CAjax::Metrics::Api | This class manages the collection of Metrics and triggering their updates to persistent storage |
| CAjax::Ui::LogicalButtons | This concrete class translates physical button actions into logical UI Button events |
| CAjax::Ui::StatusIndicator::Api | This class manages the what color/on-off-state of the RGB LED |
| CCpl::Dm::Persistent::Record | This mostly concrete class implements the Cpl::Persistent::Record interface where a Record instance contains the data from N model points |
| CCpl::MApp::Temperature::Api | This concrete class implements MApp the polls a model point for a temperature value and periodically writes the value to the trace output |
| CCpl::System::TimerComposer< CONTEXT > | This template class implements a Software Timer that is context independent and allows for a single context to contain many Timers |
| CDriver::AIO::Ajax::Thermistor | This class is responsible for sampling the on-board temperature sensor every N milliseconds and populating a model point |
| CEros::Test::Cycle::Api | This concrete class implements MApp the duty cycles the heating equipment based on command arguments |
| ►CCpl::Dm::ModelPoint | This mostly abstract class defines the interface for a Model Point |
| ►CCpl::Dm::ModelPointCommon_ | This concrete class provide common infrastructure for a Model Point |
| ►CCpl::Dm::Mp::Enum_< Ajax::Type::FanMode, MpFanMode > | |
| CAjax::Dm::MpFanMode | Concrete Model Point the FanMode Enum |
| CCpl::Dm::Mp::Numeric< size_t, MpScreenApiPtr > | |
| CCpl::Dm::Mp::Numeric< size_t, MpStaticScreenApiPtr > | |
| CCpl::Dm::Mp::Numeric< uint16_t, BitArray16 > | |
| ►CCpl::Dm::Mp::Numeric< WORDSIZE, MPTYPE > | |
| CCpl::Dm::Mp::BitArray_< WORDSIZE, MPTYPE > | This template class extends the Numeric<> class to provide bit operation on the numeric value |
| ►CCpl::Dm::Mp::Numeric< double, Double > | |
| CCpl::Dm::Mp::Double | This class provides a concrete implementation for a Point who's data is a double |
| ►CCpl::Dm::Mp::Numeric< float, Float > | |
| CCpl::Dm::Mp::Float | This class provides a concrete implementation for a Point who's data is a float |
| ►CCpl::Dm::Mp::Numeric< int32_t, Int32 > | |
| CCpl::Dm::Mp::Int32 | This class provides a concrete implementation for a Point who's data is a int32_t |
| ►CCpl::Dm::Mp::Numeric< int64_t, Int64 > | |
| CCpl::Dm::Mp::Int64 | This class provides a concrete implementation for a Point who's data is a int64_t |
| ►CCpl::Dm::Mp::Numeric< size_t, MPTYPE > | |
| CCpl::Dm::Mp::Pointer_< MPTYPE > | This template class extends the implementation of Numeric<> class to support the pointers instead of integers |
| ►CCpl::Dm::Mp::Numeric< uint32_t, Uint32 > | |
| CCpl::Dm::Mp::Uint32 | This class provides a concrete implementation for a Point who's data is a uint32_t |
| ►CCpl::Dm::Mp::Numeric< uint64_t, Uint64 > | |
| CCpl::Dm::Mp::Uint64 | This class provides a concrete implementation for a Point who's data is a uint64_t |
| CCpl::Dm::Mp::Numeric< size_t, Void > | |
| CAjax::Dm::MpAlert | This class provides a concrete implementation for a basic Alert that has following attributes: |
| CAjax::Dm::MpAlertSummary | This class provides a concrete implementation for an Alert Summary |
| CAjax::Dm::MpFlcConfig | This class provides a concrete implementation for a Point who's data a Ajax::Heating::Flc::Config_t data structure |
| ►CCpl::Dm::Mp::ArrayBase_ | This a mostly concrete class provides 'common' implementation for a Model Point who's data is a array of elements |
| CCpl::Dm::Mp::NumericArrayBase_< double > | |
| CCpl::Dm::Mp::NumericArrayBase_< float > | |
| CCpl::Dm::Mp::NumericArrayBase_< int32_t > | |
| CCpl::Dm::Mp::NumericArrayBase_< int64_t > | |
| CCpl::Dm::Mp::NumericArrayBase_< int8_t > | |
| CCpl::Dm::Mp::NumericArrayBase_< uint32_t > | |
| CCpl::Dm::Mp::NumericArrayBase_< uint64_t > | |
| CCpl::Dm::Mp::NumericArrayBase_< uint8_t > | |
| ►CCpl::Dm::Mp::NumericArrayBase_< ELEMTYPE > | This template class extends the implementation of ArrayBase_ to support the toJSON() and fromJSON_() methods for numeric element types |
| ►CCpl::Dm::Mp::NumericArray_< double, N, ArrayDouble< N > > | |
| CCpl::Dm::Mp::ArrayDouble< N > | Double Array |
| ►CCpl::Dm::Mp::NumericArray_< float, N, ArrayFloat< N > > | |
| CCpl::Dm::Mp::ArrayFloat< N > | Float Array |
| ►CCpl::Dm::Mp::NumericArray_< int32_t, N, ArrayInt32< N > > | |
| CCpl::Dm::Mp::ArrayInt32< 2 > | |
| CCpl::Dm::Mp::ArrayInt32< N > | Int32_t Array |
| ►CCpl::Dm::Mp::NumericArray_< int64_t, N, ArrayInt64< N > > | |
| CCpl::Dm::Mp::ArrayInt64< N > | Int64_t Array |
| ►CCpl::Dm::Mp::NumericArray_< int8_t, N, ArrayInt8< N > > | |
| CCpl::Dm::Mp::ArrayInt8< N > | Int8_t Array |
| ►CCpl::Dm::Mp::NumericArray_< uint32_t, N, ArrayUint32< N > > | |
| CCpl::Dm::Mp::ArrayUint32< N > | Uint32_t Array |
| ►CCpl::Dm::Mp::NumericArray_< uint64_t, N, ArrayUint64< N > > | |
| CCpl::Dm::Mp::ArrayUint64< N > | Uint64_t Array |
| ►CCpl::Dm::Mp::NumericArray_< uint8_t, N, ArrayUint8< N > > | |
| CCpl::Dm::Mp::ArrayUint8< N > | Uint8_t Array |
| CCpl::Dm::Mp::NumericArray_< ELEMTYPE, NUMELEMS, MPTYPE > | This mostly concrete template class implements an 'numeric Array' Model Point with an element size of N |
| CCpl::Dm::Mp::Bool | This class provides a concrete implementation for a Point who's data is a bool |
| CCpl::Dm::Mp::ElapsedPrecisionTime | This class provides a concrete implementation for a Point who's data a Cpl::System::ElapsedTime::Precision_T data structure |
| CCpl::Dm::Mp::Enum_< BETTERENUM_TYPE, MPTYPE > | This template class provides a mostly concrete implementation for a Model Point who's data is a BETTER_ENUM type |
| ►CCpl::Dm::Mp::Numeric< ELEMTYPE, MPTYPE > | This template class provides a mostly concrete implementation for a Model Point who's data is a C numeric primitive type of type: 'ELEMTYPE' |
| ►CCpl::Dm::Mp::BitArray_< uint16_t, BitArray16 > | |
| CCpl::Dm::Mp::BitArray16 | This template class provides a concrete implementation for a Point who's data is a a bit array of N bits |
| ►CCpl::Dm::Mp::Pointer_< MpScreenApiPtr > | |
| CAjax::ScreenMgr::MpScreenApiPtr | This class provides a concrete implementation for a Point who's data is a ScreenApi pointer |
| ►CCpl::Dm::Mp::Pointer_< MpStaticScreenApiPtr > | |
| CAjax::ScreenMgr::MpStaticScreenApiPtr | This class provides a concrete implementation for a Point who's data is a StaticScreenApi pointer |
| ►CCpl::Dm::Mp::Pointer_< Void > | |
| CCpl::Dm::Mp::Void | This class provides a concrete implementation for a Point who's data is a void pointer |
| CCpl::Dm::Mp::RefCounter | This class provides a concrete implementation for a Point who's data is 32 bit unsigned reference counter |
| ►CCpl::Dm::Mp::StringBase_ | This mostly concrete class provides the base implementation for a Point who's data is a null terminated string |
| CCpl::Dm::Mp::String< S > | This concrete template class provides the storage for a Point who's data is a null terminated string |
| ►CCpl::Io::Close | This abstract class defines a close operation that is intended to be used Input and Output streams/files |
| CCpl::Io::Input | This partially abstract class defines a interface for operating on an input stream (example of a stream is 'stdin' or a socket connection) |
| CCpl::Io::Output | This partially abstract class defines a interface for operating on an output stream (example of a stream is 'stdout' or a socket connection) |
| ►CCpl::Io::LineReaderApi | This abstract class defines a interface for a stream line reader |
| CCpl::Io::LineReader | This concrete class implements a Line Reader stream using a previously opened Input stream |
| ►CCpl::Io::LineWriterApi | This abstract class defines a interface for a stream line writer |
| CCpl::Io::LineWriter | This concrete class implements a Line Writer stream using a previously opened Output stream |
| ►CCpl::Memory::Allocator | This abstract class defines the interface for a Memory Allocator |
| ►CCpl::Memory::SPool< Cpl::Io::Socket::InputOutput, N > | |
| CCpl::Io::Socket::StreamPool< N > | This concrete template class implement a socket factory that is capable of creating N concurrently opened socket streams |
| CCpl::Memory::SPool< Cpl::Io::File::Littlefs::FileDesc_T, OPTION_CPL_IO_FILE_LITTLEFS_MAX_CONCURRENT_FILES > | |
| ►CCpl::Memory::ContiguousAllocator | This abstract class is used 'extend' the Memory Allocator to have contiguous semantics |
| CCpl::Memory::LeanHeap | This class manages an allocate-only-heap |
| CCpl::Memory::HPool< T > | This template class defines a concrete Allocator that allocates its block memory from the HEAP |
| CCpl::Memory::Pool_ | This private concrete class implements a Memory Allocator using a pool of fixed size blocks |
| CCpl::Memory::SPool< T, N > | This template class defines a concrete Allocator that STATICALLY allocates all of its Memory and can allocate up to N instances of the specified Class |
| CCpl::System::Shutdown::Handler | This call defines the callback interface that is used when the application is shutdown |
| ►CCpl::System::Signable | This abstract class defines the interface by which a client can cause an object that is waiting-on-a-signal to become unblocked |
| CCpl::System::EventLoop | This concrete class is a Runnable object that provides a event driven execution model for a thread |
| CCpl::System::Semaphore | This semaphore class defines the interface for a Counting Semaphore |
| ►CCpl::System::Thread | This abstract class defines the operations that can be performed on a thread |
| CCpl::System::BareMetal::Thread | This concrete class implements 'enough' of a Thread object to support Cpl::System framework on a bare metal system (a system that has only ONE thread and potentially ISR contexts) |
| CCpl::System::Cpp11::Thread | This concrete class implements a Thread object using C++11 threads |
| CCpl::System::FreeRTOS::Thread | This concrete class implements a Thread object using FreeRTOS threads |
| CCpl::System::Posix::Thread | This concrete class implements a Thread object using Posix threads |
| CCpl::System::Win32::Thread | This concrete class implements a Thread object using Win32 threads NOTE: The class/implementation uses _beginthread() instead of CreateThread() ->this is per Microsoft's documentation that says the _beginthread() properly initializes/cleans-up the C-Runtime library as where CreateThread() does NOT |
| CCpl::System::SimTick | This class define the interface to provide a simulates system tick (in milliseconds) to the application |
| CCpl::System::StartupHook_ | This class defines a start-up handler/hook that allows a Colony.Core sub-system to register to be called when the Api::initialize() method is called |
| CCpl::Dm::Persistent::Record::Item_T | This data structure associates a Data Model subscriber instance with a Model Point instance |
| ►CITEMTYPE | |
| CCpl::Container::ReferenceItem< REFITEM, ITEMTYPE > | This template class defines wrapper class - that is makes a reference 'listable' |
| CCpl::Io::File::Littlefs::BdSpi::JedecID_T | JEDEC ID |
| ►CCpl::Container::Key | This abstract class defines the interface that a contained object must support if it has comparable key associated with it |
| CCpl::Container::KeyPlainType< DATATYPE > | This template class is used to generate Key classes for most of the C/C++ primitive data types |
| ►CCpl::Container::KeyStringBuffer | This class provides a 'Key' wrapper for a array of Character of length N, i.e |
| CCpl::Container::KeyLiteralString | This class provides a 'Key' wrapper for a C string literal |
| ►CCpl::Text::String | This abstract class defines the operations that can be before on a NULL terminated string |
| ►CCpl::Text::String_ | This partially concrete class implements the portions of the String Api that is independent of the internal storage mechanisms |
| CCpl::Text::DString | This concrete class implements a simple "dynamic storage" String Type |
| ►CCpl::Text::FString_ | This mostly concrete class implements a "fixed storage" String Type |
| CCpl::Text::FString< CPL_IO_FILE_MAX_NAME > | |
| CCpl::Text::FString< 64 > | |
| CCpl::Text::FString< configMAX_TASK_NAME_LEN > | |
| CCpl::Text::FString< OPTION_CPL_TSHELL_PROCESSOR_OUTPUT_SIZE > | |
| CCpl::Text::FString< OPTION_CPL_TSHELL_PROCESSOR_INPUT_SIZE > | |
| CCpl::Text::DFString | This concrete class is a mix of FString and a DString - the initial memory is dynamically allocated - but no additional memory allocation will occur after the instance is created, i.e |
| CCpl::Text::FString< S > | This template class represents a NULL terminated string of a specific length |
| CDriver::Crypto::ED25519::Keys_T | Asymmetrically Key Pair |
| ►CCpl::Io::Socket::ListenerClientRequest | This abstract class define message types and payloads for a set of ITC services |
| CCpl::Io::Socket::ListenerClientSync | This partially concrete class implements the synchronous ITC open call for the OpenApi |
| CCpl::System::Locks_ | This class provide access to Colony.Core's internal global mutexes |
| ►CCpl::MApp::LookupMAppRequest | This abstract class define ITC message type and payload for the application to look-up a MApp by name |
| CCpl::MApp::Manager | This concrete class implements the MApp Manager |
| CCpl::TShell::Maker | This concrete class is a "Maker" that assembles the objects needed for a 'basic' TShell Processor engine |
| ►CCpl::MApp::ManagerApi | This abstract class defines the "manager" interface to for starting, stopping, etc |
| CCpl::MApp::Manager | This concrete class implements the MApp Manager |
| CCpl::Container::Map< ITEM > | This template class implements an Map using an AVL Binary tree (i.e |
| CCpl::Container::Map< Cpl::MApp::MAppApi > | |
| CCpl::Container::Map< Cpl::TShell::Command > | |
| CCpl::Container::Map< Driver::TPipe::RxFrameHandlerApi > | |
| ►CDriver::I2C::Master | This class defines a non-platform specific interface for an I2C master device driver |
| CDriver::I2C::Arduino::Master | This class implements the I2C interface using the Arduino framework and/or APIs |
| CDriver::I2C::STM32::Master | This class implements the I2C interface for the STM32 family of micro-controller using the ST's MX Cube/IDE to configure the SPI peripherals and IO pins |
| ►CDriver::SPI::Master | This class defines a non-platform specific interface for an SPI master device driver |
| CDriver::SPI::Arduino::Master | This class implements the SPI interface using the Arduino Framework |
| CDriver::SPI::STM32::Master | This class implements the SPI interface for the STM32 family of micro-controller using the ST's MX Cube/IDE to configure the SPI peripherals and IO pins |
| ►CDriver::SPI::MasterHalfDuplex | This class defines a non-platform specific interface for an SPI master device driver using HALF-DUPLEX data transfers, i.e, only transmit data or receive data |
| CDriver::SPI::STM32::MasterHalfDuplex | This class implements the SPI Half-duplex interface for the STM32 family of micro-controller using the ST's MX Cube/IDE to configure the SPI peripherals and IO pins |
| Cmd5_state_s | Define the state of the MD5 Algorithm |
| CCpl::Container::FHashTable_< N >::MemDList | Struct to allocate Memory for array of hash buckets |
| CCpl::Dm::Mp::ArrayBase_::MetaData_T | Meta data for read/write/copy operations |
| ►CCpl::Dm::ModelDatabaseApi | This class defines the basic operations that can be performed on a Model Base |
| CCpl::Dm::ModelDatabase | This concrete class implements a simple Model Database |
| CCpl::System::Mutex | This mutex class defines the interface for a mutex that has "recursive" semantics |
| ►CAjax::ScreenMgr::Navigation | This class defines the interface - used by ScreenApi instances - to navigate to other screen instances |
| CAjax::ScreenMgr::Api | This class implements the Screen Manager |
| CCpl::Memory::New_TS | This class provides methods to access the unit testing support for overriding the global new/delete operators |
| CCpl::Io::Socket::ListenerClientRequest::NewConnectionPayload | Payload for Message: newConnection |
| CCpl::Io::NewLine | This interface defines the 'newline' character(s) |
| ►CCpl::Dm::NotificationApi_ | This class has PACKAGE Scope, i.e |
| CCpl::Dm::EventLoop | This class extends the Cpl::System::EventLoop class to support the asynchronous change notification generated from Model Points |
| ►CCpl::Io::File::ObjectApi | This abstract class defines the basic additional functionality, beyond that of a stream, for a file |
| CCpl::Io::File::InputApi | This abstract class defines the interface for a Random Access Input File |
| CCpl::Io::File::OutputApi | This abstract class defines the interface for a Random Access Input File |
| CCpl::Json::ObjectDetector | This helper class is used to determine when an entire Json object has been read from an input source |
| ►CCpl::Itc::OpenApi | This abstract class defines an open interface |
| ►CCpl::Itc::OpenSync | This partially concrete class implements the synchronous ITC open call for the OpenApi |
| CCpl::Itc::CloseSync | This partially concrete class implements the synchronous ITC close call for the CloseApi |
| CCpl::Itc::OpenRequest::OpenPayload | Payload for Message: Open |
| ►CCpl::Itc::OpenRequest | This abstract class define message types and payloads for a set of ITC services |
| CCpl::Itc::OpenSync | This partially concrete class implements the synchronous ITC open call for the OpenApi |
| CCpl::Itc::OpenResponse | This abstract class define response message types for a set of ITC services |
| CDriver::DIO::Out | This class defines a generic interface for controlling a single Digital output signal |
| CCpl::Dm::Persistent::EraseRequest::Payload | Payload for Message |
| CCpl::Dm::Persistent::FlushRequest::Payload | Payload for Message: GetLatest |
| CCpl::Itc::AtomicRequest< ACCESS_API >::Payload | Payload for Message |
| CCpl::MApp::GetAvailableMAppRequest::Payload | Payload for Message: |
| CCpl::MApp::GetStartedMAppRequest::Payload | Payload for Message: |
| CCpl::MApp::LookupMAppRequest::Payload | Payload for Message: |
| CCpl::MApp::StartMAppRequest::Payload | Payload for Message: GetLaMApp |
| CCpl::MApp::StopAllMAppRequest::Payload | Payload for Message: StopMApp (No actual Data -->just a type name) |
| CCpl::MApp::StopMAppRequest::Payload | Payload for Message: StopMApp |
| CCpl::Persistent::ClearAllEntriesRequest::Payload | Payload for Message |
| CCpl::Persistent::GetByBufferIndexRequest::Payload | Payload for Message: GetByBufferIndex |
| CCpl::Persistent::GetLatestRequest::Payload | Payload for Message: GetLatest |
| CCpl::Persistent::GetNextRequest::Payload | Payload for Message: GetNext |
| CCpl::Persistent::GetPreviousRequest::Payload | Payload for Message: GetPrevious |
| ►CCpl::Persistent::Payload | This abstract class defines the interface accessing the 'data payload' of an individual Record instance |
| CCpl::Dm::Persistent::Record | This mostly concrete class implements the Cpl::Persistent::Record interface where a Record instance contains the data from N model points |
| CCpl::Logging::EntryData_T | Defines the content of the Log entry |
| ►CCpl::Persistent::DataRecord | This mostly concrete class implements the Cpl::Persistent::DataRecord interface where a DataRecord instance contains an unmanaged data store |
| CCpl::Persistent::IndexRecord | This concrete class extends the Cpl::Persistent::DataRecord interface to store a latest/oldest 'record index' into a RegionMedia |
| CCpl::Persistent::IndexedEntryRecord | This concrete class implements the Cpl::Persistent::Record interface to store a collection 'entries' |
| ►CCpl::System::PeriodicScheduler | This concrete class is a 'policy' object that is used to add polled based, cooperative monotonic scheduling to a Runnable object |
| CCpl::Dm::PeriodicScheduler | This class extends the Cpl::Dm::MailboxServer class to add periodic scheduling to an event based 'thread' |
| CCpl::Itc::PeriodicScheduler | This class extends the Cpl::Itc::MailboxServer class to add periodic scheduling to an event based 'thread' |
| CDriver::Button::PolledDebounced | This concrete class implements a button driver where a single button is polled and its raw button state is de-bounced |
| CCpl::TShell::PolledMaker | This concrete class is a "Maker" that assembles the objects needed for a 'basic' TShell Processor engine that has POLLED semantics |
| ►CCpl::Itc::PostApi | This abstract class represents the interface used to send messages to a mailbox |
| ►CCpl::Itc::Mailbox | This mailbox class implements an Inter Thread Communications message queue |
| CCpl::Dm::MailboxServer | This class extends the Cpl::Dm::EventLoop and Cpl::Itc:Mailbox classes to support the asynchronous change notification generated from Model Points with ITC messaging |
| CCpl::Itc::MailboxServer | This class collects the common functions of a generic server providing a mailbox and Event loop |
| CCpl::Itc::SAP< SERVER > | This concrete template class represents the interface to a ITC Service Access Point (SAP) |
| CCpl::System::ElapsedTime::Precision_T | Data type for time in seconds with a 'fractional' millisecond precision |
| ►CCpl::TShell::ProcessorApi | This class defines the interface a TShell Command Processor |
| ►CCpl::TShell::Context_ | This Private Namespace class defines a "Context" for a TShell command |
| ►CCpl::TShell::Processor | This concrete class provides the implementation of Command Processor for a TShell engine |
| CCpl::TShell::PolledProcessor | This concrete class provides a non-blocking implementation of Command PolledProcessor for a TShell engine |
| CDriver::DIO::Pwm | This class defines a generic interface for controlling a simple PWM output signal |
| CCpl::Math::RealExpressionParser< T > | This template class evaluates an null terminate string that represents an real-number arithmetic expression |
| ►CCpl::Persistent::Record | This abstract class defines the public interface for a Record instance |
| CCpl::Dm::Persistent::Record | This mostly concrete class implements the Cpl::Persistent::Record interface where a Record instance contains the data from N model points |
| CCpl::Persistent::DataRecord | This mostly concrete class implements the Cpl::Persistent::DataRecord interface where a DataRecord instance contains an unmanaged data store |
| ►CDriver::LED::RedGreenBlue | This abstract class defines a basic interface for a single Red-Green-Blue LED where the application can set the individual color values and the overall brightness of the LED |
| CDriver::LED::Pimoroni::RedGreenBlue | This concrete class is wrapper to the GENERIC pimoroni RGBLED class |
| CDriver::LED::TPipe::RedGreeBlue | This concrete class implements the Red-Green-Blue LED interface by sending the LED state over the TPipe to an external client |
| ►CCpl::Persistent::RegionMedia | This mostly abstract class defines the operations that can be performed on a persistent media |
| CCpl::Persistent::FileAdapter | This concrete class implements the RegionMedia interface using the Cpl::Io::File interfaces |
| CCpl::Persistent::NVAdapter | This concrete class implements the RegionMedia interface using the Driver::NV::Api interface |
| CCpl::Persistent::NullRegionMedia | This concrete class provides a 'null' implementation of the RegionMedia interface |
| ►CCpl::Itc::ReturnHandler | This abstract class represents the action that is executed by a server thread in response to the server completing the operation requested by the SrvMsg, when the server invokes the returnToSender() operation of the message |
| CCpl::Itc::AsyncReturnHandler | This class implements an asynchronous ReturnHandler |
| CCpl::Itc::NullReturnHandler | This class implements a Null ReturnHandler |
| CCpl::Itc::SyncReturnHandler | This class implements a synchronous ReturnHandler |
| ►Cpimoroni::RGBLED | |
| CDriver::LED::Pimoroni::RedGreenBlue | This concrete class is wrapper to the GENERIC pimoroni RGBLED class |
| ►CCpl::Container::RingBuffer< ITEM > | This template class implements a Ring Buffer |
| CCpl::Container::RingBufferMT< AjaxScreenMgrEvent_T > | |
| CCpl::Container::RingBufferMT< AjaxUiEvent_T > | |
| CCpl::Container::RingBufferMT< Cpl::Logging::EntryData_T > | |
| CCpl::Container::RingBufferMT< ENTRY > | |
| ►CCpl::Container::RingBufferMT< ITEM > | This template class implements a THREAD SAFE Ring Buffer |
| CCpl::Container::RingBufferMP< AjaxScreenMgrEvent_T > | |
| CCpl::Container::RingBufferMP< AjaxUiEvent_T > | |
| CCpl::Container::RingBufferMP< Cpl::Logging::EntryData_T > | |
| CCpl::Container::RingBufferMP< ENTRY > | |
| CCpl::Container::RingBufferMP< ITEM > | This template class implements a THREAD SAFE Ring Buffer AND it maintains/reports the number of elements stored in the ring buffer via a Model Point |
| CCpl::Container::RingBuffer< AjaxScreenMgrEvent_T > | |
| CCpl::Container::RingBuffer< AjaxUiEvent_T > | |
| CCpl::Container::RingBuffer< Cpl::Logging::EntryData_T > | |
| CCpl::Container::RingBuffer< ENTRY > | |
| ►CCpl::Container::RingBuffer< FSM_EVENT_T > | |
| CAjax::Heating::Supervisor::FsmEventQueue_ | Event Queue for FSM events |
| CCpl::Container::RingBuffer< uint8_t > | |
| ►CCpl::System::Runnable | This is an abstract class defines the interface for an object that is "executed" when a Thread object is created |
| ►CCpl::Io::Socket::Listener | This abstract class defines the interface for a SIMPLE socket listener |
| ►CCpl::Io::Socket::Listener_ | This private, mostly concrete helper class manages the top level threading aspects for a simple listener |
| CCpl::Io::Socket::Posix::Listener | This concrete class implements the Cpl::Io::Socket::Listener interface using IPv4 addressing for the Posix compliant platform |
| CCpl::Io::Socket::Win32::Listener | This concrete class implements the Cpl::Io::Socket::Listener interface using IPv4 addressing for the Win32 (aka winsock2) platform |
| CCpl::System::EventLoop | This concrete class is a Runnable object that provides a event driven execution model for a thread |
| CCpl::System::FreeRTOS::MakeCurrentThreadACplThread | This is a helper class that can be used to make the current thread a CPL thread |
| CCpl::System::Mutex::ScopeBlock | This concrete class provides a simple mechanism for providing mutex protection for a "scope block" |
| ►CAjax::ScreenMgr::ScreenApi | This class defines the interface for a 'Screen' |
| CAjax::ScreenMgr::MockScreen | This class implements a 'Mock' ScreenApi instances |
| CAjax::Ui::About::Screen | This class implements the About screen |
| CAjax::Ui::EditSetpt::Screen | This class implements the Edit setpoint screen |
| CAjax::Ui::Home::Screen | This class implements the Home screen |
| CEros::Ui::Home::Screen | This class implements the Home screen |
| CEros::Ui::LcdTest::Screen | This class implements the Home screen |
| ►CCpl::TShell::Security | This abstract defines the interface for validating a 'user login' for TShell |
| CAjax::Main::TShellSecurity | Validates the TShell login password |
| CCpl::TShell::SecurityNull | This concrete class dummy/null implementation of the Security interface |
| CSEGGER_BSP_API | |
| CSEGGER_BUFFER_DESC | |
| CSEGGER_CACHE_CONFIG | |
| CSEGGER_PRINTF_API | |
| CSEGGER_PRINTF_FORMATTER | |
| CSEGGER_RTT_BUFFER_DOWN | |
| CSEGGER_RTT_BUFFER_UP | |
| CSEGGER_RTT_CB | |
| CSEGGER_SNPRINTF_CONTEXT_struct | |
| CSEGGER_SYSVIEW_MODULE_STRUCT | |
| CSEGGER_SYSVIEW_OS_API | |
| CSEGGER_SYSVIEW_TASKINFO | |
| CCpl::Type::SeqNumber | This class defines a sequence number and the operation that can be performed on it |
| ►CCpl::System::SharedEventHandlerApi | This abstract class defines the interface for a Shared Event Handler |
| CCpl::System::SharedEventHandler< N > | This template concrete class is a 'strategy class' in that in provides most of work needed for a Runnable object to support a list of callback functions for handling event-signally - instead of hard coded switch statement in its processEventFlag() method |
| CCpl::System::Shell | This class defines methods for interfacing with the Platform native OS to execute a native OS system/shell command |
| CCpl::System::Shutdown | This class defines methods for forcibly terminating the application |
| CCpl::System::Shutdown_TS | This class provides methods to access the unit testing support for the Cpl::System::Shutdown interface |
| CCpl::Container::SList< ITEM > | This template class implements a singly linked list which maintains the ordering imposed on it by the application |
| CCpl::Container::SList< Cpl::Dm::ModelPoint > | |
| CCpl::Container::SList< Cpl::Io::Output > | |
| ►CCpl::Container::SList< Message > | |
| CCpl::Itc::Mailbox | This mailbox class implements an Inter Thread Communications message queue |
| CDriver::SPI::Arduino::Master::SPIConfig_T | SPI Settings (note: needed because the SPISettings class does not allow changing the baudrate once instantiated) |
| CCpl::Container::Stack< ITEM > | This template class implements a Stack that has a fixed depth and stores copies of the data items |
| CCpl::Container::Stack< Cpl::Io::File::DirList_::DirEntry_T > | |
| CCpl::Container::Stack< OperatorValue > | |
| ►CCpl::MApp::StartMAppRequest | This abstract class define ITC message type and payload for the application to start a MApp |
| CCpl::MApp::Manager | This concrete class implements the MApp Manager |
| ►CAjax::ScreenMgr::StaticScreenApi | This class defines interface for Screens that only contain static data |
| CAjax::ScreenMgr::MockStaticScreen | This class implements a 'Mock' StaticScreenApi instances |
| CAjax::Ui::Error::Screen | This class implements the splash screen |
| CAjax::Ui::Shutdown::Screen | This class implements the shutdown screen |
| CAjax::Ui::Splash::Screen | This class implements the splash screen |
| CCpl::Memory::New_TS::Stats | New/Delete metrics |
| ►CCpl::TShell::Stdio | This concrete class provides the 'threading wrapper' for running a TShell Command Processor |
| CCpl::TShell::Restartable | This concrete class extends the 'Stdio' class for running a TShell Command Processor that provides the ability to 'restart' the TShell to be 'restarted' |
| ►CCpl::MApp::StopAllMAppRequest | This abstract class define ITC message type and payload for the application to stop the current MApp |
| CCpl::MApp::Manager | This concrete class implements the MApp Manager |
| ►CCpl::MApp::StopMAppRequest | This abstract class define ITC message type and payload for the application to stop the current MApp |
| CCpl::MApp::Manager | This concrete class implements the MApp Manager |
| CCpl::Io::Serial::ST::M32F4::StreamDriver | This concrete class implements a non-busy-wait blocking Transmit/Receive Stream UART driver with a SOFTWARE FIFO |
| CAjax::SimHouse::System | This class simulates a "system" whose state is affected by its environment and any number of control systems that may change the environment over time |
| CCpl::Text::Tokenizer::TextBlock | This concrete class tokenizes a Text Block that has the following format: |
| CCpl::System::Tls | This concrete class defines the interface for Thread Local Storage (TLS) |
| CCpl::System::Trace | This concrete class provide a 'printf' tracing mechanism |
| CCpl::System::TracePlatform_ | This class defines the interface to the platform specific implementation of the Cpl::System::Trace interface |
| ►CCpl::System::Thread::Traverser | This abstract class defines the client interface for walking the list of threads, i.e |
| CCpl::TShell::Cmd::Threads | This class implements a Shell command |
| CCpl::Type::Traverser | This class defines a set of type(s) that are used with the traverser design pattern |
| ►CDriver::TPipe::Tx | This abstract class defines the 'Transmit Command' interface for the TPipe |
| CDriver::TPipe::Pipe | This concrete class provides the implementation of TPipe |
| CCpl::Io::File::Littlefs::Api::Volume_T | This structure defines the configuration and the underlying block driver used for each volume instance |
| CxLIST | |
| CxLIST_ITEM | |
| CxMEMORY_REGION | |
| CxMINI_LIST_ITEM | |
| CxSTATIC_EVENT_GROUP | |
| CxSTATIC_LIST | |
| CxSTATIC_LIST_ITEM | |
| CxSTATIC_MINI_LIST_ITEM | |
| CxSTATIC_QUEUE | |
| CxSTATIC_QUEUE.u | |
| CxSTATIC_STREAM_BUFFER | |
| CxSTATIC_TCB | |
| CxSTATIC_TIMER | |
| CxTASK_PARAMETERS | |
| CxTASK_STATUS | |
| CxTIME_OUT | |
1.9.8