Skip to content

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
classflake::Array
Type-safe accessor for a raw typed array (array_t).
structflake::AuthenticationSink
Callback interface for authentication during connection setup.
structflake::CallBackFromTag
structflake::CallBackFromTag< TAG_ACTIONABLE, PropTag >
classflake::Confirmation
Represents the reply (confirmation) to a previously sent request.
classflake::ConfirmationSink
Callback interface for receiving Confirmation messages.
classflake::ConnectedObject
An object that is connected to the Flake bus and has an address.
classflake::Connection
Primary client-side handle to the Flake system.
structflake::ConnectionSink
Callback interface for connection lifecycle events.
structflake::flake_uuid
RFC 4122 (v1-style) UUID generator.
classflake::FlakeAllocator
STL-compatible allocator backed by the size-class byte pool.
structflake::FlakePoolStats
Diagnostic snapshot of pool occupancy.
structflake::has_tt_of
structflake::has_tt_of< T, std::void_t< decltype(tt_of< std::decay_t< T > >::value)> >
classflake::Indication
Represents an incoming indication (server → client notification).
classflake::IndicationSink
Callback interface for receiving Indication messages.
structflake::is_std_optional
structflake::is_std_optional< std::optional< T > >
classflake::Object
Client-side proxy for a Flake object.
classflake::ObjectDelegate
Interface to be implemented by the application to expose a custom Flake object.
classflake::PropArray
Ordered, serializable collection of Property values.
structflake::PropArrayHandle
POD handle that locates a PropArray's slice in the pool.
classflake::Property
A single typed, tagged property value.
classflake::PropertyPool
Shared, bounded Property storage with shift-compaction.
structflake::PropTypeFromTag
structflake::PropTypeFromTag<(0x1U) >
structflake::PropTypeFromTag<(0x2U) >
structflake::PropTypeFromTag<(0x3U) >
structflake::PropTypeFromTag<(0x4U) >
structflake::PropTypeFromTag<(0x5U) >
structflake::PropTypeFromTag<(0x6U) >
structflake::PropTypeFromTag<(0x7U) >
structflake::PropTypeFromTag<(0x81U) >
structflake::PropTypeFromTag<(0x82U) >
structflake::PropTypeFromTag<(0x8U) >
structflake::PropTypeFromTag<(0x9U) >
structflake::PropTypeFromTag<(0xAU) >
structflake::PropTypeFromTag<(0xBU) >
structflake::PropTypeFromTag<(0xCU) >
structflake::PropTypeFromTag<(0xEU) >
structflake::PropTypeFromTag<(0xFU) >
structflake::ReportFill
Fill level of an object's pending report.
structflake::Serializable
Interface for types that support binary serialization.
classflake::ServerWire
Abstract base class for server-side wire implementations.
classflake::Service
classflake::Stream
Byte-oriented read/write stream associated with an Object property.
classflake::Table
Convenience alias – column metadata lives in the MetaProperties namespace.
structflake::TableCompareRestriction
Describes a single comparison-based filter on a table column.
classflake::TagArray
Ordered set of property tags (uint32_t).
structflake::tt_allowed
structflake::tt_allowed< tt_array_t >
structflake::tt_allowed< tt_bin_t >
structflake::tt_allowed< tt_str_t >
structflake::tt_allowed< uint32_t >
structflake::tt_of
structflake::tt_of< bool >
structflake::tt_of< char * >
structflake::tt_of< float >
structflake::tt_of< int16_t >
structflake::tt_of< int32_t >
structflake::tt_of< int64_t >
structflake::tt_of< int8_t >
structflake::tt_of< tt_array_t >
structflake::tt_of< tt_bin_t >
structflake::tt_of< tt_str_t >
structflake::tt_of< tt_uuid_t >
structflake::tt_of< uint16_t >
structflake::tt_of< uint32_t >
structflake::tt_of< uint64_t >
structflake::tt_of< uint8_t >
classflake::UniqueId
128-bit (16 byte) universally unique identifier.
structflake::unwrap_optional
structflake::unwrap_optional< std::optional< U > >
classflake::Wire
Abstract base class for all client-side wire implementations.
enum class uint_least8_tflakeAuthType
Authentication mode for Flake connections.
enum class uint16_tTableCompareOperation
Comparison operations supported by TableCompareRestriction.
enum class uint16_tTableRestrictionType
Discriminator for the kind of restriction applied to a table query.
enum class intLogLevel
Verbosity levels for library-internal logging.
enum class uint8_tWireType
Discriminator for stream-oriented vs. datagram-oriented wires.
using ConnectionDevice
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 UniqueIduniqueId_t
using uint16_taddr_t
Network address type used to identify objects on the bus.
typedef binary_t { uint16_t cbbinary_t
using int32_ttt_int32_t
Flake property type alias for signed 32-bit integer.
using int64_ttt_int64_t
Flake property type alias for signed 64-bit integer.
using int16_ttt_int16_t
Flake property type alias for signed 16-bit integer.
using int8_ttt_int8_t
Flake property type alias for signed 8-bit integer.
using uint32_ttt_uint32_t
Flake property type alias for unsigned 32-bit integer.
using uint64_ttt_uint64_t
Flake property type alias for unsigned 64-bit integer.
using uint16_ttt_uint16_t
Flake property type alias for unsigned 16-bit integer.
using uint8_ttt_uint8_t
Flake property type alias for unsigned 8-bit integer.
using booltt_bool_t
Flake property type alias for boolean.
using binary_ttt_bin_t
Flake property type alias for binary blob.
using uniqueId_ttt_uuid_t
Flake property type alias for UUID.
using std::stringtt_str_t
Flake property type alias for string.
using floattt_float_t
Flake property type alias for single-precision float.
typedef array_t { uint16_t totalSizearray_t
using array_ttt_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_tToken
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 TagArrayColumnSet
A set of column tags that define which properties appear in each row.
using PropArrayTableRow
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.
voidflakeFree(uint8_t * ptr)
Return a pointer previously obtained from flakeAlloc.
std::size_tflakeAllocSize(const void * ptr)
Report the capacity backing ptr.
FlakePoolStatsflakePoolStats()
intflakeBytePoolsInit()
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)
booltokens_match(unsigned a, unsigned b)
booladdresses_match(unsigned a, unsigned b)
boolsafeWrite(uint8_t * buf, uint16_t bufSize, uint16_t & offset, const uint8_t * src, uint16_t len, uint16_t * outConsumed =nullptr)
boolsafeRead(const uint8_t * buf, uint16_t bufSize, uint16_t & offset, uint8_t * dst, uint16_t len, uint16_t * outConsumed =nullptr)
booloperator==(UniqueId & lhs, UniqueId & rhs)
booloperator!=(UniqueId & lhs, UniqueId & rhs)
booloperator<(UniqueId & lhs, UniqueId & rhs)
~binary_t() =default
binary_t(const binary_t & other)
constexprbinary_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)
constexprarray_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)
booloperator==(const Property & lhs, const Property & rhs)
booloperator!=(const Property & lhs, const Property & rhs)
uint32_tpreprocessTag(uint32_t t)
PropertyPropMakeBool(uint32_t t, tt_bool_t v)
PropertyPropMakeU8(uint32_t t, tt_uint8_t v)
PropertyPropMakeU16(uint32_t t, tt_uint16_t v)
PropertyPropMakeU32(uint32_t t, tt_uint32_t v)
PropertyPropMakeI8(uint32_t t, tt_int8_t v)
PropertyPropMakeI16(uint32_t t, tt_int16_t v)
PropertyPropMakeI32(uint32_t t, tt_int32_t v)
PropertyPropMakeDateTime(uint32_t t, tt_uint32_t v)
PropertyPropMakeFloat(uint32_t t, tt_float_t v)
PropertyPropMakeUUID(uint32_t t, const tt_uuid_t & v)
PropertyPropMakeString(uint32_t t, const tt_str_t & v)
PropertyPropMakeBin(uint32_t t, const tt_bin_t & v)
voidsetLogLevel(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_tdefaultPort
Default TCP port for unencrypted Flake connections.
constexpr uint16_tdefaultTLSPort
Default TCP port for TLS-encrypted Flake connections.
uint8_t *lpb
uint8_t *lpValues
uint16_ttype
constexpr boolis_std_optional_v
constexpr uint8_tFLAKE_PRIO_NORMAL
Default priority: the value waits for the next report.
constexpr uint8_tFLAKE_PRIO_IMMEDIATE
The value is due at once and takes everything pending along; it goes out first in the next transmission.
constexpr uint8_tFLAKE_HISTORY_CONDENSABLE
Intermediate samples may be thinned to one per minute when the volume budget runs short (default).
constexpr uint8_tFLAKE_HISTORY_COMPLETE
Every sample is kept, whatever the budget.
constexpr uint8_tFLAKE_HISTORY_LATEST
Only the last value of a report window matters once the budget runs short.
constexpr uint8_tFLAKE_HISTORY_STAGE_NORMAL
Budget stages for [Object::setHistoryStage](). They describe the volume used against the share saved up so far.
constexpr uint8_tFLAKE_HISTORY_STAGE_TIGHT
80–100 %: LATEST keeps its last value only
constexpr uint8_tFLAKE_HISTORY_STAGE_OVER
over 100 %: also CONDENSABLE at most one sample per minute
constexpr uint8_tFLAKE_HISTORY_STAGE_HOLD
month nearly spent: thinning as above, the integration stops regular sending

Types Documentation ​

enum flakeAuthType ​

EnumeratorDescription
atNone
atSignature
atInteractive

Authentication mode for Flake connections.

enum TableCompareOperation ​

EnumeratorDescription
TCO_EQEquality comparison.

Comparison operations supported by TableCompareRestriction.

enum TableRestrictionType ​

EnumeratorDescription
RES_UNRESTRICTEDNo restriction – return all rows.
RES_COMPARECompare a column value against a reference.

Discriminator for the kind of restriction applied to a table query.

enum LogLevel ​

EnumeratorDescription
ExplicitAlways-on, critical messages.
ErrorErrors (same priority as Explicit).
InfoInformational messages.
VerboseVerbose trace output.
DebugFine-grained debug output.
RawUnfiltered raw data dumps.

Verbosity levels for library-internal logging.

Higher numeric values are more verbose. Use setLogLevel() to configure at runtime.

enum WireType ​

EnumeratorDescription
wtStreamStream-oriented (e.g. TCP, Serial).
wtDatagramDatagram-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; nullptr is 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() =default

function 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() =default

function 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::defaultPort

Default TCP port for unencrypted Flake connections.

variable defaultTLSPort ​

cpp
constexpr uint16_t flake::defaultTLSPort

Default TCP port for TLS-encrypted Flake connections.

variable lpb ​

cpp
uint8_t* flake::lpb

variable lpValues ​

cpp
uint8_t* flake::lpValues

variable type ​

cpp
uint16_t flake::type

variable is_std_optional_v ​

cpp
constexpr bool flake::is_std_optional_v

variable FLAKE_PRIO_NORMAL ​

cpp
constexpr uint8_t flake::FLAKE_PRIO_NORMAL

Default priority: the value waits for the next report.

variable FLAKE_PRIO_IMMEDIATE ​

cpp
constexpr uint8_t flake::FLAKE_PRIO_IMMEDIATE

The 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_CONDENSABLE

Intermediate 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_COMPLETE

Every sample is kept, whatever the budget.

variable FLAKE_HISTORY_LATEST ​

cpp
constexpr uint8_t flake::FLAKE_HISTORY_LATEST

Only 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_NORMAL

Budget 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_TIGHT

80–100 %: LATEST keeps its last value only

variable FLAKE_HISTORY_STAGE_OVER ​

cpp
constexpr uint8_t flake::FLAKE_HISTORY_STAGE_OVER

over 100 %: also CONDENSABLE at most one sample per minute

variable FLAKE_HISTORY_STAGE_HOLD ​

cpp
constexpr uint8_t flake::FLAKE_HISTORY_STAGE_HOLD

month nearly spent: thinning as above, the integration stops regular sending