Appearance
namespace flake
Namespaces
| Name |
|---|
| flake::MessageType Protocol message type constants. |
| flake::MetaProperties Meta-property tags (attached as auxiliary data, not user properties). |
| flake::ParameterProperties Standard parameter property tags used in protocol messages. |
| flake::ReservedProperties System-reserved property tags. |
| flake::ServerWirePool |
| flake::sizing |
| flake::utils |
| flake::WirePool |
Namespaces
| Name |
|---|
| flake::MessageType Protocol message type constants. |
| flake::MetaProperties Meta-property tags (attached as auxiliary data, not user properties). |
| flake::ParameterProperties Standard parameter property tags used in protocol messages. |
| flake::ReservedProperties System-reserved property tags. |
| flake::ServerWirePool |
| flake::sizing |
| flake::utils |
| flake::WirePool |
Types
| Name | |
|---|---|
| class | flake::Array Type-safe accessor for a raw typed array (array_t). |
| struct | flake::AuthenticationSink Callback interface for authentication during connection setup. |
| struct | flake::CallBackFromTag |
| struct | flake::CallBackFromTag< TAG_ACTIONABLE, PropTag > |
| class | flake::Confirmation Represents the reply (confirmation) to a previously sent request. |
| class | flake::ConfirmationSink Callback interface for receiving Confirmation messages. |
| class | flake::ConnectedObject An object that is connected to the Flake bus and has an address. |
| class | flake::Connection Primary client-side handle to the Flake system. |
| struct | flake::ConnectionSink Callback interface for connection lifecycle events. |
| struct | flake::flake_uuid RFC 4122 (v1-style) UUID generator. |
| class | flake::FlakeAllocator STL-compatible allocator backed by the size-class byte pool. |
| struct | flake::FlakePoolStats Diagnostic snapshot of pool occupancy. |
| struct | flake::has_tt_of |
| struct | flake::has_tt_of< T, std::void_t< decltype(tt_of< std::decay_t< T > >::value)> > |
| class | flake::Indication Represents an incoming indication (server → client notification). |
| class | flake::IndicationSink Callback interface for receiving Indication messages. |
| struct | flake::is_std_optional |
| struct | flake::is_std_optional< std::optional< T > > |
| class | flake::Object Client-side proxy for a Flake object. |
| class | flake::ObjectDelegate Interface to be implemented by the application to expose a custom Flake object. |
| class | flake::PropArray Ordered, serializable collection of Property values. |
| struct | flake::PropArrayHandle POD handle that locates a PropArray's slice in the pool. |
| class | flake::Property A single typed, tagged property value. |
| class | flake::PropertyPool Shared, bounded Property storage with shift-compaction. |
| struct | flake::PropTypeFromTag |
| struct | flake::PropTypeFromTag<(0x1U) > |
| struct | flake::PropTypeFromTag<(0x2U) > |
| struct | flake::PropTypeFromTag<(0x3U) > |
| struct | flake::PropTypeFromTag<(0x4U) > |
| struct | flake::PropTypeFromTag<(0x5U) > |
| struct | flake::PropTypeFromTag<(0x6U) > |
| struct | flake::PropTypeFromTag<(0x7U) > |
| struct | flake::PropTypeFromTag<(0x81U) > |
| struct | flake::PropTypeFromTag<(0x82U) > |
| struct | flake::PropTypeFromTag<(0x8U) > |
| struct | flake::PropTypeFromTag<(0x9U) > |
| struct | flake::PropTypeFromTag<(0xAU) > |
| struct | flake::PropTypeFromTag<(0xBU) > |
| struct | flake::PropTypeFromTag<(0xCU) > |
| struct | flake::PropTypeFromTag<(0xEU) > |
| struct | flake::PropTypeFromTag<(0xFU) > |
| struct | flake::ReportFill Fill level of an object's pending report. |
| struct | flake::Serializable Interface for types that support binary serialization. |
| class | flake::ServerWire Abstract base class for server-side wire implementations. |
| class | flake::Service |
| class | flake::Stream Byte-oriented read/write stream associated with an Object property. |
| class | flake::Table Convenience alias – column metadata lives in the MetaProperties namespace. |
| struct | flake::TableCompareRestriction Describes a single comparison-based filter on a table column. |
| class | flake::TagArray Ordered set of property tags (uint32_t). |
| struct | flake::tt_allowed |
| struct | flake::tt_allowed< tt_array_t > |
| struct | flake::tt_allowed< tt_bin_t > |
| struct | flake::tt_allowed< tt_str_t > |
| struct | flake::tt_allowed< uint32_t > |
| struct | flake::tt_of |
| struct | flake::tt_of< bool > |
| struct | flake::tt_of< char * > |
| struct | flake::tt_of< float > |
| struct | flake::tt_of< int16_t > |
| struct | flake::tt_of< int32_t > |
| struct | flake::tt_of< int64_t > |
| struct | flake::tt_of< int8_t > |
| struct | flake::tt_of< tt_array_t > |
| struct | flake::tt_of< tt_bin_t > |
| struct | flake::tt_of< tt_str_t > |
| struct | flake::tt_of< tt_uuid_t > |
| struct | flake::tt_of< uint16_t > |
| struct | flake::tt_of< uint32_t > |
| struct | flake::tt_of< uint64_t > |
| struct | flake::tt_of< uint8_t > |
| class | flake::UniqueId 128-bit (16 byte) universally unique identifier. |
| struct | flake::unwrap_optional |
| struct | flake::unwrap_optional< std::optional< U > > |
| class | flake::Wire Abstract base class for all client-side wire implementations. |
| enum class uint_least8_t | flakeAuthType Authentication mode for Flake connections. |
| enum class uint16_t | TableCompareOperation Comparison operations supported by TableCompareRestriction. |
| enum class uint16_t | TableRestrictionType Discriminator for the kind of restriction applied to a table query. |
| enum class int | LogLevel Verbosity levels for library-internal logging. |
| enum class uint8_t | WireType Discriminator for stream-oriented vs. datagram-oriented wires. |
| using Connection | Device Legacy typedef – Connection was formerly named Device. |
| using std::basic_string< char, std::char_traits< char >, FlakeAllocator< char > > | String Byte-pool-backed drop-in for std::string. |
| using UniqueId | uniqueId_t |
| using uint16_t | addr_t Network address type used to identify objects on the bus. |
| typedef binary_t { uint16_t cb | binary_t |
| using int32_t | tt_int32_t Flake property type alias for signed 32-bit integer. |
| using int64_t | tt_int64_t Flake property type alias for signed 64-bit integer. |
| using int16_t | tt_int16_t Flake property type alias for signed 16-bit integer. |
| using int8_t | tt_int8_t Flake property type alias for signed 8-bit integer. |
| using uint32_t | tt_uint32_t Flake property type alias for unsigned 32-bit integer. |
| using uint64_t | tt_uint64_t Flake property type alias for unsigned 64-bit integer. |
| using uint16_t | tt_uint16_t Flake property type alias for unsigned 16-bit integer. |
| using uint8_t | tt_uint8_t Flake property type alias for unsigned 8-bit integer. |
| using bool | tt_bool_t Flake property type alias for boolean. |
| using binary_t | tt_bin_t Flake property type alias for binary blob. |
| using uniqueId_t | tt_uuid_t Flake property type alias for UUID. |
| using std::string | tt_str_t Flake property type alias for string. |
| using float | tt_float_t Flake property type alias for single-precision float. |
| typedef array_t { uint16_t totalSize | array_t |
| using array_t | tt_array_t Flake property type alias for typed array. |
| template <class T > using typename unwrap_optional< std::decay_t< T > >::type | unwrap_optional_t |
| using std ::optional< std::variant< tt_int8_t, tt_int16_t, tt_int32_t, tt_int64_t, tt_uint8_t, tt_uint16_t, tt_uint32_t, tt_uint64_t, tt_bool_t, tt_float_t, tt_uuid_t, tt_bin_t, tt_str_t, tt_array_t > > | PropValue |
| template <uint32_t PropTag> using typename PropTypeFromTag<((PropTag) &0x7FFU)>::type | PropType |
| using uint16_t | Token Token type used to match requests with their confirmations. |
| using std::function< void(const Property &)> | PropCallBackPlain |
| using std::function< int(Property &, const PropArray &, bool)> | PropCallBackActionable |
| using std::function< int(const char *, const uint16_t, const uint32_t)> | PropCallBackStreamWrite |
| using std::function< int(char *, uint16_t *, uint16_t, const uint32_t)> | PropCallBackStreamRead |
| using std::function< void(bool)> | PropCallBackStreamOpenClose |
| template <uint32_t PropTag> using typename CallBackFromTag< PropTag &TAG_ACTIONABLE, PropTag >::type | PropCallback |
| using TagArray | ColumnSet A set of column tags that define which properties appear in each row. |
| using PropArray | TableRow A single table row, represented as a PropArray. |
| using void * | flakeMutexId_t Opaque mutex handle used in the portable OS abstraction. |
Functions Overview
| Name | |
|---|---|
| uint8_t * | flakeAlloc(std::size_t bytes) Allocate bytes from the size-class pool, with arena overhang fallback on exhaustion. |
| void | flakeFree(uint8_t * ptr) Return a pointer previously obtained from flakeAlloc. |
| std::size_t | flakeAllocSize(const void * ptr) Report the capacity backing ptr. |
| FlakePoolStats | flakePoolStats() |
| int | flakeBytePoolsInit() Rebind all four size-class buckets to arena-carved slices. |
| template <typename T ,typename... Args> T * | flakeNew(Args &&... args) Construct a T in memory drawn from the size-class pool. Use for heap objects that have no static compile-time upper bound and thus cannot back themselves with a dedicated PoolAllocator. |
| template <typename T > void | flakeDelete(T * p) Destroy and release a pointer obtained from flakeNew. |
| template <typename T ,typename U > bool | operator==(const FlakeAllocator< T > & , const FlakeAllocator< U > & ) |
| template <typename T ,typename U > bool | operator!=(const FlakeAllocator< T > & , const FlakeAllocator< U > & ) |
| template <typename T > constexpr unsigned int | UNSIGNED(T v) |
| template <typename T > constexpr int | SIGNED(T v) |
| template <typename T > constexpr std::uint32_t | U32(T v) |
| template <typename T > constexpr std::int32_t | I32(T v) |
| template <typename T > constexpr std::uint16_t | U16(T v) |
| template <typename T > constexpr std::int16_t | I16(T v) |
| template <typename T > constexpr std::uint8_t | U8(T v) |
| template <typename T > constexpr std::int8_t | I8(T v) |
| bool | tokens_match(unsigned a, unsigned b) |
| bool | addresses_match(unsigned a, unsigned b) |
| bool | safeWrite(uint8_t * buf, uint16_t bufSize, uint16_t & offset, const uint8_t * src, uint16_t len, uint16_t * outConsumed =nullptr) |
| bool | safeRead(const uint8_t * buf, uint16_t bufSize, uint16_t & offset, uint8_t * dst, uint16_t len, uint16_t * outConsumed =nullptr) |
| bool | operator==(UniqueId & lhs, UniqueId & rhs) |
| bool | operator!=(UniqueId & lhs, UniqueId & rhs) |
| bool | operator<(UniqueId & lhs, UniqueId & rhs) |
| ~binary_t() =default | |
| binary_t(const binary_t & other) | |
| constexpr | binary_t(uint16_t cb_, uint8_t * lpb_) |
| binary_t(binary_t && other) | |
| binary_t & | operator=(binary_t && other) |
| binary_t & | operator=(const binary_t & other) |
| ~array_t() =default | |
| array_t(const array_t & other) | |
| constexpr | array_t(uint16_t totalSize_, uint8_t * lpValues_, uint16_t type_) |
| array_t(array_t && other) | |
| array_t & | operator=(array_t && other) |
| array_t & | operator=(const array_t & other) |
| template <typename T > constexpr bool | type_matches_tag(uint32_t tag) |
| bool | operator==(const Property & lhs, const Property & rhs) |
| bool | operator!=(const Property & lhs, const Property & rhs) |
| uint32_t | preprocessTag(uint32_t t) |
| Property | PropMakeBool(uint32_t t, tt_bool_t v) |
| Property | PropMakeU8(uint32_t t, tt_uint8_t v) |
| Property | PropMakeU16(uint32_t t, tt_uint16_t v) |
| Property | PropMakeU32(uint32_t t, tt_uint32_t v) |
| Property | PropMakeI8(uint32_t t, tt_int8_t v) |
| Property | PropMakeI16(uint32_t t, tt_int16_t v) |
| Property | PropMakeI32(uint32_t t, tt_int32_t v) |
| Property | PropMakeDateTime(uint32_t t, tt_uint32_t v) |
| Property | PropMakeFloat(uint32_t t, tt_float_t v) |
| Property | PropMakeUUID(uint32_t t, const tt_uuid_t & v) |
| Property | PropMakeString(uint32_t t, const tt_str_t & v) |
| Property | PropMakeBin(uint32_t t, const tt_bin_t & v) |
| void | setLogLevel(LogLevel level) Set the global log verbosity at runtime. |
| const char * | errorToString(long e) Convert an error code to a human-readable string. |
| const char * | timeToString(time_t t) Format a time_t value as a human-readable string. |
| char * | tagToString(uint32_t tag) Format a property tag as a human-readable string. |
Attributes
| Name | |
|---|---|
| constexpr uint16_t | defaultPort Default TCP port for unencrypted Flake connections. |
| constexpr uint16_t | defaultTLSPort Default TCP port for TLS-encrypted Flake connections. |
| uint8_t * | lpb |
| uint8_t * | lpValues |
| uint16_t | type |
| constexpr bool | is_std_optional_v |
| constexpr uint8_t | FLAKE_PRIO_NORMAL Default priority: the value waits for the next report. |
| constexpr uint8_t | FLAKE_PRIO_IMMEDIATE The value is due at once and takes everything pending along; it goes out first in the next transmission. |
| constexpr uint8_t | FLAKE_HISTORY_CONDENSABLE Intermediate samples may be thinned to one per minute when the volume budget runs short (default). |
| constexpr uint8_t | FLAKE_HISTORY_COMPLETE Every sample is kept, whatever the budget. |
| constexpr uint8_t | FLAKE_HISTORY_LATEST Only the last value of a report window matters once the budget runs short. |
| constexpr uint8_t | FLAKE_HISTORY_STAGE_NORMAL Budget stages for [Object::setHistoryStage](). They describe the volume used against the share saved up so far. |
| constexpr uint8_t | FLAKE_HISTORY_STAGE_TIGHT 80–100 %: LATEST keeps its last value only |
| constexpr uint8_t | FLAKE_HISTORY_STAGE_OVER over 100 %: also CONDENSABLE at most one sample per minute |
| constexpr uint8_t | FLAKE_HISTORY_STAGE_HOLD month nearly spent: thinning as above, the integration stops regular sending |
Types Documentation
enum flakeAuthType
| Enumerator | Description |
|---|---|
| atNone | |
| atSignature | |
| atInteractive |
Authentication mode for Flake connections.
enum TableCompareOperation
| Enumerator | Description |
|---|---|
| TCO_EQ | Equality comparison. |
Comparison operations supported by TableCompareRestriction.
enum TableRestrictionType
| Enumerator | Description |
|---|---|
| RES_UNRESTRICTED | No restriction – return all rows. |
| RES_COMPARE | Compare a column value against a reference. |
Discriminator for the kind of restriction applied to a table query.
enum LogLevel
| Enumerator | Description |
|---|---|
| Explicit | Always-on, critical messages. |
| Error | Errors (same priority as Explicit). |
| Info | Informational messages. |
| Verbose | Verbose trace output. |
| Debug | Fine-grained debug output. |
| Raw | Unfiltered raw data dumps. |
Verbosity levels for library-internal logging.
Higher numeric values are more verbose. Use setLogLevel() to configure at runtime.
enum WireType
| Enumerator | Description |
|---|---|
| wtStream | Stream-oriented (e.g. TCP, Serial). |
| wtDatagram | Datagram-oriented (e.g. UDP). |
Discriminator for stream-oriented vs. datagram-oriented wires.
using Device
cpp
using flake::Device = typedef Connection;Legacy typedef – Connection was formerly named Device.
using String
cpp
using flake::String = typedef std::basic_string<char, std::char_traits<char>, FlakeAllocator<char> >;Byte-pool-backed drop-in for std::string.
Note: Wire classes currently still use std::string for internal m_ip / m_port fields — SSO covers IPv4 without heap traffic, and the migration to [flake::String](/embed/2.2.0/API/Namespaces/namespaceflake.md#using-string) is deferred pending a reproducer for an intermittent regression surfaced when all six wire classes were converted together. Internal containers or future code should prefer [flake::String](/embed/2.2.0/API/Namespaces/namespaceflake.md#using-string).
Short-string optimisation keeps typical IPv4 host strings and port literals inline (no allocation at all); longer strings spill into the size-class byte pool via FlakeAllocator. Available for internal storage fields where the no-heap contract must hold even when the integrator hands in hostnames that exceed the stdlib SSO threshold (typically 15 bytes) — e.g. IPv6 literals.
Interoperates with std::string at the c_str() / data() boundary.
using uniqueId_t
cpp
using flake::uniqueId_t = typedef UniqueId;using addr_t
cpp
using flake::addr_t = typedef uint16_t;Network address type used to identify objects on the bus.
typedef binary_t
cpp
flake::binary_t;using tt_int32_t
cpp
using flake::tt_int32_t = typedef int32_t;Flake property type alias for signed 32-bit integer.
using tt_int64_t
cpp
using flake::tt_int64_t = typedef int64_t;Flake property type alias for signed 64-bit integer.
using tt_int16_t
cpp
using flake::tt_int16_t = typedef int16_t;Flake property type alias for signed 16-bit integer.
using tt_int8_t
cpp
using flake::tt_int8_t = typedef int8_t;Flake property type alias for signed 8-bit integer.
using tt_uint32_t
cpp
using flake::tt_uint32_t = typedef uint32_t;Flake property type alias for unsigned 32-bit integer.
using tt_uint64_t
cpp
using flake::tt_uint64_t = typedef uint64_t;Flake property type alias for unsigned 64-bit integer.
using tt_uint16_t
cpp
using flake::tt_uint16_t = typedef uint16_t;Flake property type alias for unsigned 16-bit integer.
using tt_uint8_t
cpp
using flake::tt_uint8_t = typedef uint8_t;Flake property type alias for unsigned 8-bit integer.
using tt_bool_t
cpp
using flake::tt_bool_t = typedef bool;Flake property type alias for boolean.
using tt_bin_t
cpp
using flake::tt_bin_t = typedef binary_t;Flake property type alias for binary blob.
using tt_uuid_t
cpp
using flake::tt_uuid_t = typedef uniqueId_t;Flake property type alias for UUID.
using tt_str_t
cpp
using flake::tt_str_t = typedef std::string;Flake property type alias for string.
using tt_float_t
cpp
using flake::tt_float_t = typedef float;Flake property type alias for single-precision float.
typedef array_t
cpp
flake::array_t;using tt_array_t
cpp
using flake::tt_array_t = typedef array_t;Flake property type alias for typed array.
using unwrap_optional_t
cpp
template <class T >
using flake::unwrap_optional_t = typedef typename unwrap_optional<std::decay_t<T> >::type;using PropValue
cpp
using flake::PropValue = typedef std ::optional<std::variant<tt_int8_t, tt_int16_t, tt_int32_t, tt_int64_t, tt_uint8_t, tt_uint16_t, tt_uint32_t, tt_uint64_t, tt_bool_t, tt_float_t, tt_uuid_t, tt_bin_t, tt_str_t, tt_array_t> >;using PropType
cpp
template <uint32_t PropTag>
using flake::PropType = typedef typename PropTypeFromTag<(( PropTag ) & 0x7FFU)>::type;using Token
cpp
using flake::Token = typedef uint16_t;Token type used to match requests with their confirmations.
using PropCallBackPlain
cpp
using flake::PropCallBackPlain = typedef std::function<void (const Property &)>;using PropCallBackActionable
cpp
using flake::PropCallBackActionable = typedef std::function<int (Property &, const PropArray &, bool)>;using PropCallBackStreamWrite
cpp
using flake::PropCallBackStreamWrite = typedef std::function<int (const char*, const uint16_t, const uint32_t)>;using PropCallBackStreamRead
cpp
using flake::PropCallBackStreamRead = typedef std::function<int (char*, uint16_t*, uint16_t, const uint32_t)>;using PropCallBackStreamOpenClose
cpp
using flake::PropCallBackStreamOpenClose = typedef std::function<void (bool)>;using PropCallback
cpp
template <uint32_t PropTag>
using flake::PropCallback = typedef typename CallBackFromTag<PropTag & TAG_ACTIONABLE, PropTag>::type;using ColumnSet
cpp
using flake::ColumnSet = typedef TagArray;A set of column tags that define which properties appear in each row.
using TableRow
cpp
using flake::TableRow = typedef PropArray;A single table row, represented as a PropArray.
using flakeMutexId_t
cpp
using flake::flakeMutexId_t = typedef void*;Opaque mutex handle used in the portable OS abstraction.
Function Details
function flakeAlloc
cpp
uint8_t * flakeAlloc(
std::size_t bytes
)Allocate bytes from the size-class pool, with arena overhang fallback on exhaustion.
Return: Pointer to at least bytes writable bytes. May come from a bucket slot or from the arena overhang (see file-header comment). nullptr only when the arena is also exhausted — call sites map that to E_NO_ALLOC at the public API boundary.
function flakeFree
cpp
void flakeFree(
uint8_t * ptr
)Return a pointer previously obtained from flakeAlloc.
Parameters:
- ptr Pointer to release;
nullptris accepted and ignored.
Pointer-range compares route the free to the originating bucket (O(1), no per-allocation header). Arena-overhang pointers are silently ignored — bump allocator has no per-allocation free path.
function flakeAllocSize
cpp
std::size_t flakeAllocSize(
const void * ptr
)Report the capacity backing ptr.
Return: Slot size in bytes if ptr originates from a pool bucket, the originally requested byte count if ptr is an arena-overhang allocation, 0 otherwise. Handy when a caller needs to know the upper bound of writable bytes behind a flake-sourced pointer.
function flakePoolStats
cpp
FlakePoolStats flakePoolStats()function flakeBytePoolsInit
cpp
int flakeBytePoolsInit()Rebind all four size-class buckets to arena-carved slices.
Called by the central pool-init helper (see flakeArenaCarveAllPools in utils/arena_pool_init.cpp) at the top of every flakeInitialize* entry point, before any allocation runs. Returns 0 on success or -1 on arena exhaustion (maps to E_NO_ALLOC at the public API boundary).
After a successful call the buckets draw exclusively from the arena — the internal default static storage is abandoned. Callers that do not run flakeInitialize* keep the default backing: the library still works out of the box without arena wiring.
function flakeNew
cpp
template <typename T ,
typename... Args>
T * flakeNew(
Args &&... args
)Construct a T in memory drawn from the size-class pool. Use for heap objects that have no static compile-time upper bound and thus cannot back themselves with a dedicated PoolAllocator.
function flakeDelete
cpp
template <typename T >
void flakeDelete(
T * p
)Destroy and release a pointer obtained from flakeNew.
function operator==
cpp
template <typename T ,
typename U >
inline bool operator==(
const FlakeAllocator< T > & ,
const FlakeAllocator< U > &
)function operator!=
cpp
template <typename T ,
typename U >
inline bool operator!=(
const FlakeAllocator< T > & ,
const FlakeAllocator< U > &
)function UNSIGNED
cpp
template <typename T >
constexpr unsigned int UNSIGNED(
T v
)function SIGNED
cpp
template <typename T >
constexpr int SIGNED(
T v
)function U32
cpp
template <typename T >
constexpr std::uint32_t U32(
T v
)function I32
cpp
template <typename T >
constexpr std::int32_t I32(
T v
)function U16
cpp
template <typename T >
constexpr std::uint16_t U16(
T v
)function I16
cpp
template <typename T >
constexpr std::int16_t I16(
T v
)function U8
cpp
template <typename T >
constexpr std::uint8_t U8(
T v
)function I8
cpp
template <typename T >
constexpr std::int8_t I8(
T v
)function tokens_match
cpp
inline bool tokens_match(
unsigned a,
unsigned b
)function addresses_match
cpp
inline bool addresses_match(
unsigned a,
unsigned b
)function safeWrite
cpp
inline bool safeWrite(
uint8_t * buf,
uint16_t bufSize,
uint16_t & offset,
const uint8_t * src,
uint16_t len,
uint16_t * outConsumed =nullptr
)function safeRead
cpp
inline bool safeRead(
const uint8_t * buf,
uint16_t bufSize,
uint16_t & offset,
uint8_t * dst,
uint16_t len,
uint16_t * outConsumed =nullptr
)function operator==
cpp
inline bool operator==(
UniqueId & lhs,
UniqueId & rhs
)function operator!=
cpp
inline bool operator!=(
UniqueId & lhs,
UniqueId & rhs
)function operator<
cpp
inline bool operator<(
UniqueId & lhs,
UniqueId & rhs
)function ~binary_t
cpp
~binary_t() =defaultfunction binary_t
cpp
binary_t(
const binary_t & other
)function binary_t
cpp
constexpr binary_t(
uint16_t cb_,
uint8_t * lpb_
)function binary_t
cpp
binary_t(
binary_t && other
)function operator=
cpp
binary_t & operator=(
binary_t && other
)function operator=
cpp
binary_t & operator=(
const binary_t & other
)function ~array_t
cpp
~array_t() =defaultfunction array_t
cpp
array_t(
const array_t & other
)function array_t
cpp
constexpr array_t(
uint16_t totalSize_,
uint8_t * lpValues_,
uint16_t type_
)function array_t
cpp
array_t(
array_t && other
)function operator=
cpp
array_t & operator=(
array_t && other
)function operator=
cpp
array_t & operator=(
const array_t & other
)function type_matches_tag
cpp
template <typename T >
constexpr bool type_matches_tag(
uint32_t tag
)function operator==
cpp
inline bool operator==(
const Property & lhs,
const Property & rhs
)function operator!=
cpp
inline bool operator!=(
const Property & lhs,
const Property & rhs
)function preprocessTag
cpp
inline uint32_t preprocessTag(
uint32_t t
)function PropMakeBool
cpp
inline Property PropMakeBool(
uint32_t t,
tt_bool_t v
)function PropMakeU8
cpp
inline Property PropMakeU8(
uint32_t t,
tt_uint8_t v
)function PropMakeU16
cpp
inline Property PropMakeU16(
uint32_t t,
tt_uint16_t v
)function PropMakeU32
cpp
inline Property PropMakeU32(
uint32_t t,
tt_uint32_t v
)function PropMakeI8
cpp
inline Property PropMakeI8(
uint32_t t,
tt_int8_t v
)function PropMakeI16
cpp
inline Property PropMakeI16(
uint32_t t,
tt_int16_t v
)function PropMakeI32
cpp
inline Property PropMakeI32(
uint32_t t,
tt_int32_t v
)function PropMakeDateTime
cpp
inline Property PropMakeDateTime(
uint32_t t,
tt_uint32_t v
)function PropMakeFloat
cpp
inline Property PropMakeFloat(
uint32_t t,
tt_float_t v
)function PropMakeUUID
cpp
inline Property PropMakeUUID(
uint32_t t,
const tt_uuid_t & v
)function PropMakeString
cpp
inline Property PropMakeString(
uint32_t t,
const tt_str_t & v
)function PropMakeBin
cpp
inline Property PropMakeBin(
uint32_t t,
const tt_bin_t & v
)function setLogLevel
cpp
void setLogLevel(
LogLevel level
)Set the global log verbosity at runtime.
Parameters:
- level Desired log level.
Messages with a LogLevel numerically greater than level will be suppressed.
function errorToString
cpp
const char * errorToString(
long e
)Convert an error code to a human-readable string.
Parameters:
Return: Static string describing the error.
Note: Debug builds only.
function timeToString
cpp
const char * timeToString(
time_t t
)Format a time_t value as a human-readable string.
Parameters:
- t The time value.
Return: Static string with the formatted timestamp.
Note: Debug builds only.
function tagToString
cpp
char * tagToString(
uint32_t tag
)Format a property tag as a human-readable string.
Parameters:
- tag The 32-bit property tag.
Return: Heap-allocated string – caller must delete[].
Note: Debug builds only.
Attributes Documentation
variable defaultPort
cpp
constexpr uint16_t flake::defaultPortDefault TCP port for unencrypted Flake connections.
variable defaultTLSPort
cpp
constexpr uint16_t flake::defaultTLSPortDefault TCP port for TLS-encrypted Flake connections.
variable lpb
cpp
uint8_t* flake::lpbvariable lpValues
cpp
uint8_t* flake::lpValuesvariable type
cpp
uint16_t flake::typevariable is_std_optional_v
cpp
constexpr bool flake::is_std_optional_vvariable FLAKE_PRIO_NORMAL
cpp
constexpr uint8_t flake::FLAKE_PRIO_NORMALDefault priority: the value waits for the next report.
variable FLAKE_PRIO_IMMEDIATE
cpp
constexpr uint8_t flake::FLAKE_PRIO_IMMEDIATEThe value is due at once and takes everything pending along; it goes out first in the next transmission.
variable FLAKE_HISTORY_CONDENSABLE
cpp
constexpr uint8_t flake::FLAKE_HISTORY_CONDENSABLEIntermediate samples may be thinned to one per minute when the volume budget runs short (default).
variable FLAKE_HISTORY_COMPLETE
cpp
constexpr uint8_t flake::FLAKE_HISTORY_COMPLETEEvery sample is kept, whatever the budget.
variable FLAKE_HISTORY_LATEST
cpp
constexpr uint8_t flake::FLAKE_HISTORY_LATESTOnly the last value of a report window matters once the budget runs short.
variable FLAKE_HISTORY_STAGE_NORMAL
cpp
constexpr uint8_t flake::FLAKE_HISTORY_STAGE_NORMALBudget stages for [Object::setHistoryStage](). They describe the volume used against the share saved up so far.
up to 80 %
variable FLAKE_HISTORY_STAGE_TIGHT
cpp
constexpr uint8_t flake::FLAKE_HISTORY_STAGE_TIGHT80–100 %: LATEST keeps its last value only
variable FLAKE_HISTORY_STAGE_OVER
cpp
constexpr uint8_t flake::FLAKE_HISTORY_STAGE_OVERover 100 %: also CONDENSABLE at most one sample per minute
variable FLAKE_HISTORY_STAGE_HOLD
cpp
constexpr uint8_t flake::FLAKE_HISTORY_STAGE_HOLDmonth nearly spent: thinning as above, the integration stops regular sending