Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

Nluabridge
CStack< PIString >	LuaBridge stack adapter for PIString
NPIClientServer
CClient	Active client connection that initiates a connection to a server. Client implementation for connecting to servers. Provides TCP connection to remote server with diagnostics and packet streaming support
CClientBase	Base class for client and server-side client communication. Provides TCP connection management, diagnostics, and packet streaming capabilities
CServer	TCP server implementation for client-server communication. Accepts incoming connections and manages multiple clients with configurable factory for client instance creation
CServerClient	Server-side representation of one accepted client connection. Server-side client representation. Created and managed by Server. Used to communicate with remote clients connected to the server
NPICloud	Namespace for low-level PICloud transport helpers
CTCP	Builds and parses PICloud frames on top of PIStreamPacker
NPICodeInfo	Namespace contains structures for code generation. See Code generation
CTypeInfo	Type information
CFunctionInfo	Method information
CClassInfo	Class or struct information
CEnumeratorInfo	Enumerator information
CEnumInfo	Enum information
NPIHTTP	Namespace with shared HTTP constants and vocabulary
CMessageConst	Immutable HTTP message view with accessors for method, path, headers and body
CMessageMutable	Mutable HTTP message with setters and argument/header modifiers
NPIMQTT	Namespace with shared MQTT data types
CMessageConst	Immutable MQTT message
CMessageMutable	Mutable MQTT message
NPIScreenTypes	Namespace with shared screen cells, layout flags, and tile event types
CCellFormat	Packed character formatting used by screen cells
CCell	One character cell of the console screen
CTileEvent	User-defined event raised by a tile
CPIScreenBase	Base interface used by tiles to notify the owning screen about focus, removal, and custom events
NPISystemTests	Calibration values loaded from system test results
CPISystemTestReader	Initializes calibration values for PISystemTests
NPIUnits	Namespace containing unit metadata and conversion helpers
NClass	Namespace containing unit family descriptors
CAngle	Descriptor of angle units and their public type identifiers
CDistance	Descriptor of distance units and their public type identifiers
CInformation	Descriptor of information units and their public type identifiers
CInternal	Internal registry and base interfaces for unit families
CClassBase	Base interface implemented by every unit family descriptor
CRegistrator	Helper that registers every type declared by unit family "P"
CMass	Descriptor of mass units and their public type identifiers
CPressure	Descriptor of pressure units and their public type identifiers
CTemperature	Descriptor of temperature units and their public type identifiers
CTime	Descriptor of time and frequency units and their public type identifiers
CPrefix	Helpers for localized prefix names, symbols, and multipliers
CValue	Numeric value paired with a registered unit type
NPIVariantTypes	Namespace contains several types for PIVariant
CEnumerator	Name-value pair
CEnum	Collection of PIVariantTypes::Enumerator
CFile	File location description
CDir	Directory description
CColor	32-bits color
CIODevice	Variant description used to create or configure PIIODevice
Ccomplex	STL class
CFunctionType	Template struct for extracting function type from callable objects
CFunctionType< Ret(Class::*)(Args...) const >	Specialization for member function pointers
Cis_complex	Type trait that reports whether T is a specialization of std::complex
Cis_complex< std::complex< T > >	Specialization for complex types
CMicrohttpdServer	Base HTTP server with request dispatch and optional basic authentication
CPIAuth	Peer authentication state machine with signed key exchange
CPIBaseTransfer	Base transport for reliable fixed-size packet exchange over an external channel
CPacketHeader	Common header placed before every protocol packet
CPart	Logical fragment description used to split data into packets
CPIBinaryLog	Class for writing and reading binary data to/from log files, with support for playback in different modes
CBinLogRecordInfo	Statistics for records sharing the same record ID
CBinLogIndex	Indexed location of a record inside a log file
CBinLogInfo	Summary information about a log file and its indexed record types
CPIBinaryStream	CRTP interface for binary serialization streams
CPIBinaryStreamTrivialRef	Helper wrapper used to detect default trivial streaming operators. Helper class to detect default operators
CPIBitArray	The PIBitArray class provides a space-efficient array of bits
CPIBlockingQueue	Thread-safe queue that supports blocking operations - waits for space when storing and waits for element when retrieving
CPIBroadcast	Multi-channel sender and receiver over multicast, broadcast and loopback endpoints
CPIByteArray	The PIByteArray class provides an array of bytes with efficient memory management and various manipulation operations
CPICAN	CAN device based on interface name and frame identifier
CPIChar	Single UTF-16 character
CPIChunkStream	Class for binary de/serialization
CChunk	Nested template struct for chunk data
CChunkConst	Nested template struct for constant chunk data
CPICLI	Command-line argument parser class The PICLI class provides convenient parsing of command-line arguments. It supports short keys (e.g., -c), full keys (e.g., –console), and arguments with/without values
CPICloudBase	Base class for cloud client and server
CPICloudClient	PIIODevice implementation for a logical PICloud client
CPICloudServer	PIIODevice implementation for a logical PICloud server
CClient	Per-client PIIODevice exposed by PICloudServer
CPICodeParser	Parser of C/C++ declarations used by the code model tools
CMacro	Parsed function-like macro
CMember	Parsed member declaration or function signature
CEntity	Parsed class, struct or namespace
CEnumeratorInfo	Parsed enumerator entry
CEnum	Parsed enumeration
CPICollection	Global collection of PIObject-based instances grouped by name
CCollectionAdder	Helper that registers object in collection during static initialization
CPIConditionVariable	Condition variable used together with external PIMutex
CPIConfig	Parser and writer for configuration files with tree structure supportPIConfig provides functionality to read, write and manipulate configuration files in a tree-like structure. Supports dotted paths, INI-style section prefixes, multiline values and include entries resolved during parsing
CBranch	Branch class - container for Entry objects
CEntry	Node of the parsed configuration tree
CPIConnection	Routes data between shared devices, packet extractors, channels and periodic senders
CPIConstChars	C-String class
CPICout	Universal output to console class. This class provides a universal output interface with support for various data types, formatting options, and multiple output devices (console, buffer)
CNotifier	Class for emit notifications of PICout
CPICRC	Generic table-driven CRC calculator for a polynomial width L
CPICrypt	Class for encrypting and decrypting data. Class providing cryptographic operations using the libsodium library, including encryption, decryption, hashing, and digital signatures. It supports both instance-based and static method-based operations. Requires libsodium library initialization. All methods are thread-safe when using different keys
CPIDataTransfer	Class for send and receive PIByteArray via PIBaseTransfer
CPIDate	Calendar date
CPIDateTime	Calendar date and time
CPIDeque	Sequence two-way linear container - dynamic size array of any type
CPIDiagnostics	Connection diagnostics for packet frequency, throughput and receive quality This class provides connection quality diagnostics based on packet reception statistics
CState	Snapshot of current counters and derived statistics
CPIDigest	One-shot digest API for supported algorithms
CPIDir	Local directory
CCurrentDirOverrider	Temporarily change working directory
CPIEllipsoidModel	Reference ellipsoid parameters used by geographic calculations. This module provides Earth ellipsoid models used in geodesy and navigation systems. It includes standard models like WGS84, PZ90, GPS, and Krasovskiy
CPIEthernet	PIIODevice implementation for UDP sockets, TCP clients and TCP servers
CInterface	Public descriptor of a system network interface
CInterfaceList	Collection of Interface descriptors with lookup helpers
CPIEthUtilBase	Base helper that adds optional packet encryption to transport utilities
CPIEvaluator	Expression evaluator with reusable compiled instructions
CPIFile	Local file
CFileInfo	Local file or directory information
CPermissions	Local file or directory permissions
CPIFileTransfer	Class for sending and receiving files and directories via PIBaseTransfer
CPFTFileInfo	File-system entry description extended with destination relative path
CPFTHeader	Custom packet header used by the file-transfer protocol
CPIFlags	The PIFlags class is a template container for bit flags with various bitwise operations and comparison operators
CPIGeoPosition	Geographic position represented in one of several coordinate systems. This class provides functionality for storing and converting between different coordinate systems including geodetic, geocentric, Cartesian, and spherical coordinates. It supports various ellipsoid models for Earth representation
CPIGPIO	GPIO support library
CPIGrabberBase	Base polling grabber thread with a pending queue, recording virtual methods, and a last-item snapshot
CPIHIDevice	Provides access to HID (Human Interface Device) devices such as game controllers, joysticks, and other input devices
CEvent	Input event produced by PIHIDevice
CPIHIDeviceInfo	Information about a discovered HID device
CValueInfoBase	Common information for HID controls addressed by index
CAxisInfo	Description of a HID axis
CButtonInfo	Description of a HID button
CPIHTTPClient	Asynchronous HTTP client request with completion callbacks
CPIHTTPServer	HTTP server that routes requests by method and path pattern
CPIIntrospectionContainersType	Metadata describing one tracked container element type
CPIIOBinaryStream	PIBinaryStream adapter over a PIIODevice
CPIIOByteArray	PIIODevice wrapper around PIByteArray
CPIIODevice	Base class for input/output devices
CPIIOString	PIIODevice wrapper around PIString
CPIIOTextStream	PITextStream adapter over a PIIODevice
CPIJSON	JSON tree node
CPIKbdListener	Console input listener for keyboard and mouse events
CKeyEvent	Information about one keyboard event
CMouseEvent	Information about one mouse event
CWheelEvent	Information about one mouse wheel event
CPILibrary	Run-time library
CPILine	Two-dimensional line segment
CPILog	High-level log
CPILuaProgram	Helper object for loading scripts and exposing the embedded Lua state through LuaBridge. Provides interface for loading and executing Lua scripts using LuaBridge
CPIMap	Map of unique keys and associated values
CPIMapIterator	Java-style iterator for PIMap
CPIMapIteratorConst	Java-style iterator for PIMap
CPIMapIteratorConstReverse	Java-style reverse iterator for PIMap
CPIMapIteratorReverse	Java-style reverse iterator for PIMap
CPIMathMatrix	Dynamic-size math matrix. Uses PIVector2D as storage and keeps the matrix interface aligned with PIMathMatrixT
CPIMathMatrixT	Fixed-size math matrix. Stores matrix data inline and performs dimension checks at compile time where possible
CPIMathSolver	Numerical solver for transfer-function models
CPIMathVector	Template class for dynamic-size mathematical vector Provides vector operations including arithmetic, normalization, angles, cross product, and dot product for dynamic-size vectors
CPIMathVectorT	Fixed-size mathematical vector with compile-time size Provides vector operations including arithmetic, normalization, angles, cross product, and dot product
CPIMemoryBlock	Helper struct to store and restore custom blocks of data to/from PIBinaryStream
CPIMutex	Mutex for mutual exclusion between threads
CPIMutexLocker	Scope guard that locks a PIMutex in constructor and unlocks it in destructor
CPINetworkAddress	Network address, IP and port
CPINonTriviallyCopyable	Inherit from this class to make your class non-trivially copyable
CPIObject	Base class for objects that declare events, event handlers and registered methods
CConnection	Handle of one connection between a source object and a destination object or functor
CPIOpenCL	Entry point for the OpenCL wrapper API
CKernelArg	Reflected description of a kernel argument
CDevice	Description of a discovered OpenCL device
CPlatform	Description of an OpenCL platform and its devices
CContext	OpenCL context wrapper that owns created programs and buffers
CBuffer	OpenCL buffer wrapper optionally bound to a host container
CProgram	Compiled OpenCL program that owns discovered kernels
CKernel	OpenCL kernel wrapper with reflected argument metadata
CPIPackedTCP	TCP device wrapper that exposes framed packets through the PIIODevice API.The PIPackedTCP class provides a TCP client/server device with automatic data packing/unpacking using PIStreamPacker. It supports both client and server roles with reliable byte-stream transmission over TCP connections
CPIPacketExtractor	Extracts packets from data produced by a child PIIODevice. The PIPacketExtractor class provides packet recognition from data stream using various algorithms
CPIPair	Class template that provides a way to store two heterogeneous objects as a single unit
CPIParseHelper	Maps packet keys to handlers and deserializes payloads before invocation
CPIPeer	Named network peer built on top of PIIODevice
CPeerInfo	Public information about a discovered peer
CPeerAddress	Network address of a peer endpoint
CPIPipelineThread	Thread-based pipeline template class for multi-stage data processing
CPIPluginInfo	Metadata collected for one plugin or for the host application
CPIPluginInfoStorage	Storage of plugin metadata for the application and loaded plugins
CPIPluginLoader	Plugin loader. Handles dynamic library loading, symbol resolution, and plugin lifecycle management
CPIPoint	Two-dimensional point
CPIProcess	Class for managing external processes
CPIPropertyStorage	This class provides key-value properties storage
CProperty	PIPropertyStorage element
CPIProtectedVariable	Thread-safe variable template class
CPointer	Pointer-like wrapper returned by getRef() while the protected value remains locked
CPIQuaternion	Quaternion for representing 3D rotations and orientations
CPIQueue	Queue container built on top of PIDeque
CPIReadLocker	Scope guard that acquires reader access in constructor and releases it in destructor
CPIReadWriteLock	Synchronization primitive that allows concurrent readers and exclusive writer access
CPIRect	The PIRect class provides a two-dimensional rectangle class for 2D geometry
CPIRegularExpression	Regular expression class
CMatcher	Match result and iterator state
CPIResources	Access to resources embedded into the application binary
CPIResourcesStorage	Global storage for sections and entries registered by the resources subsystem
CSection	One logical resource section with named binary entries
CPIScopeExitCall	Class for executing a function upon scope exit
CPIScreen	Console screen manager with tile layout, drawing, and input routing
CPIScreenDrawer	Helper that draws primitives and text into a PIScreen cell buffer
CPIScreenTile	Base tile in the console screen tree. Base class for all screen tiles providing layout and event handling
CPISemaphore	Counting semaphore that tracks available resource units
CPISemaphoreLocker	Scope guard that acquires semaphore units in constructor and releases them in destructor
CPISerial	Serial device
CDeviceInfo	Information about serial device
CPISet	Set of unique values
Cconst_iterator	Constant iterator over PISet elements
CPISharedMemory	Shared memory
CPISignals	Helper for installing process signal handlers
CPISingleApplication	Single-instance application control
CPISPI	SPI device with configurable speed, word size and clock mode
CPISpinlock	Lock based on atomic spinning for very short critical sections
CPISpinlockLocker	Scope guard that locks a PISpinlock in constructor and unlocks it in destructor
CPIStack	A container class inherited from the PIVector with stack functionality
CPIStateBase	Base class for states in a hierarchical state machine
CPIStateFinal	Final state that finishes its parent state when entered
CPIStateLambda	State implementation that forwards enter and exit virtual methods to callbacks
CPIStateMachine	Root object that owns and runs a hierarchical state machine
CPIStatistic	Template class for calculating statistical measures of a data set Calculates mean, variance, skewness and kurtosis for a numeric sample
CPIStreamPacker	Simple packet wrapper around any PIIODevice Provides packet framing and deframing for data transmission over any PIIODevice implementation
CPIStreamPackerConfig	Configuration for PIStreamPacker packet framing
CPIString	String class
CPIStringContextTr	Context-aware string wrapper that automatically translates strings using PITranslator::tr(). Helper returned by operator""_tr for optional-context translation
CPIStringContextTrNoOp	Context-aware string wrapper that preserves original strings without translation (no-op). Helper returned by operator""_trNoOp that keeps source text unchanged
CPIStringList	Based on PIDeque<PIString> strings list
CPISystemInfo	System information class
CMountInfo	Mount point information structure
CPISystemMonitor	Process and thread resource monitoring. This module provides process and system resource monitoring capabilities including CPU usage, memory consumption, and thread statistics. It supports cross-platform monitoring on Linux, Windows, macOS, and ESP platforms
CProcessStatsFixed	Process statistics (fixed-size fields)
CThreadStatsFixed	Thread statistics (fixed-size fields)
CProcessStats	Process statistics
CThreadStats	Thread statistics
CPISystemTime	System time with nanosecond precision
CFrequency	Frequency type
CPITerminal	Virtual terminal that runs a shell and mirrors its screen into a cell buffer. Provides terminal emulation for reading console input and output. Supports ANSI escape sequences for cursor movement, colors, and text formatting
CPITextStream	Text serialization functionality over PIBinaryStream
CPIThread	Thread object that executes work on a dedicated system thread
CPIThreadNotifier	Thread notifier class for synchronization between threads
CPIThreadPoolLoop	Helper that runs one integer range across a fixed set of worker threads
CPIThreadPoolWorker	Fixed-size pool of worker threads for generic-purpose tasks
CPITime	Calendar time
CPITimeMeasurer	Time measurements
CPITimer	Periodic timer that emits ticks from an internal worker thread
CPITransitionBase	Transition between states in PIStateMachine
CPITransitionTimeout	Transition that fires automatically after a timeout
CPITranslator	Translation support
CPITransparentDevice	PIIODevice that returns written packets through read()
CPIUSB	USB implementation of PIIODevice
CEndpoint	Parsed USB endpoint descriptor
CInterface	USB interface description with its endpoints
CConfiguration	USB configuration description with available interfaces
CDescriptor	Top-level USB device descriptor collected during opening
CPIValueTree	The PIValueTree class represents a tree structure of PIVariant values with attributes
CAttribute	The Attribute struct contains constants for commonly used attribute names
CPIVariant	Variant type
CPIVariantSimple	Lightweight strongly-typed variant for a single value
CPIVector	Sequence linear container - dynamic size array of any type
CPIVector2D	2D array container.This class is used to store a 2D array of elements of any type as a single continuous block of memory (a plain PIVector). Elements can be accessed using the [][] operators, where the first index is the row and the second is the column. Rows can be manipulated as PIVector objects, allowing modification of individual elements or assignment of entire rows. You cannot directly add or remove elements to change the dimensions of the array after construction (use resize(), addRow(), removeRow(), removeColumn() instead), but you can modify the values of existing elements
CIndex	Index structure for 2D array elements (row, column)
CRowConst	Proxy class representing a single read-only row in a PIVector2D. Returned by const operator[] or row(). Provides const access to row elements
CColConst	Proxy class representing a single read-only column in a PIVector2D. Returned by const col(). Provides const access to column elements
CRow	Proxy class representing a single row in a PIVector2D for modification. Objects of this class are returned by non-const operator[] or row(). They provide array-like access to the elements of a specific row and allow operations such as assignment from another row or a PIVector, searching, filling, and iteration
CCol	Proxy class representing a single column in a PIVector2D for modification. Objects of this class are returned by non-const col(). They provide column-wise access and operations similar to Row
CPIWriteLocker	Scope guard that acquires writer access in constructor and releases it in destructor
CTileButton	Push button tile
CTileButtons	Group of selectable buttons arranged in one tile
CTileCheck	Check box tile
CTileInput	Single-line editable text input tile
CTileList	Scrollable list tile with optional row selection
CTilePICout	Log view tile backed by the global PICout buffer
CTileProgress	Progress indicator tile
CTileScrollBar	Scroll bar tile used by list-like widgets
CTileSimple	Simple text tile with per-row formatting
CTransferFunction	Transfer-function coefficient storage
Cuint_cl	Fixed-width unsigned helper used by generic CRC implementations