* Decreases an object's reference count, releasing memory and * resources. * * This function affects nested objects, meaning that when an Array or

* Releases a spinlock. Releasing an unacquired lock will break it. * * Returns a non-zero value on success, or 0 if the lock was in an unlocked * s

* Writes data at the end of the string, resizing the string as required. * Returns the new length of the String */

Busy waits for the spinlock (CAREFUL). */

Creates a String object. Remember to use `fiobj_free`. */

Returns a pointer (`char *`) to the String's content. */

* Returns a temporary handle to the object associated hashed key value. * * This function takes a `uintptr_t` Hash value (see `fio_siphash`) to * p

* Calculates an Objects's SipHash value for possible use as a HashMap key. * * The Object MUST answer to the fiobj_obj2cstr, or the result is unusab

* Pushes an object to the end of the Array. */

Returns the argument's value as a NUL terminated C String. */

Adds a callback to the list of callbacks to be called for the event. */

Returns the String's length in bytes. */

* Returns a temporary object owned by the Array. * * Negative values are retrieved from the end of the array. i.e., `-1` * is the last item. */

Creates a buffer String object. Remember to use `fiobj_free`. */

returns the callback object (self).

* Frees the String's resources and reinitializes the container. * * Note: if the container isn't allocated on the stack, it should be freed * separ

* Copy by reference(!) - increases an object's (and any nested object's) * reference count. * * Always returns the value passed along. */

* `fio_close` marks the connection for disconnection once all the data was * sent. The actual disconnection will be managed by the `fio_flush` functi

Performs all deferred functions until the queue had been depleted. */

* Sets a key-value pair in the Hash, duplicating the Symbol and **moving** * the ownership of the object to the Hash. * * Returns -1 on error. */

Resizes a String object, allocating more memory if required. */

* Sets a response header, taking ownership of the value object, but NOT the * name object (so name objects could be reused in future responses). *

Forces all the existing callbacks to run, as if the event occurred. */

* `fio_force_close` closes the connection immediately, without adhering to any * protocol restrictions and without sending any remaining data in the

Returns the number of elements in the Array. */

public API. */

Tests if the list is NOT empty (contains any nodes). */

returns 0 if the lock was acquired and another value on failure. */

Unsubscribes from a filter, pub/sub channel or pattern */

Creates a Number object. Remember to use `fiobj_free`. */

Fires a connection object's event */

public API. */

* Creates a mutable empty Hash object. Use `fiobj_free` when done. * * Notice that these Hash objects are designed for smaller collections and * re

* Returns an object's numerical value. * * If a String or Symbol are passed to the function, they will be * parsed assuming base 10 numerical data.

* Sends an HTTP error response. * * Returns -1 on error and 0 on success. * * AFTER THIS FUNCTION IS CALLED, THE `http_s` OBJECT IS NO LONGER VALI

pushes an instruction to the instruction array */

* A helper function that converts between String data to a signed int64_t. * * Numbers are assumed to be in base 10. Octal (`0###`), Hex (`0x##`/`x#

Creates a mutable empty Array object with the requested capacity. */

* Attaches (or updates) a protocol object to a socket UUID. * Returns -1 on error and 0 on success. */

* A helper function that writes a signed int64_t to a string. * * No overflow guard is provided, make sure there's at least 68 bytes * available (f

tested for randomness using code from: http://xoshiro.di.unimi.it/hwd.php */

Initialize/reset the SHA-2 object. SHA-2 is actually a family of functions with different variants. When initializing the SHA-2 container, you must s

Finalizes the SHA-2 hash, returning the Hashed data. `sha2_result` can be called for the same object multiple times, but the finalization will only b

Writes data to the SHA-2 buffer. */

* Deeply compare two objects. No hashing or recursive function calls are * involved. * * Uses a similar algorithm to `fiobj_each2`, except adjusted

Adds a node to the list's head. */

public API. */

Sets a timeout for a specific connection (only when running and valid). */

Returns the number of elements in the Array. */

* Sends the response headers for a header only response. * * AFTER THIS FUNCTION IS CALLED, THE `http_s` OBJECT IS NO LONGER VALID. */

Computes a facil.io Risky Hash. */

Returns the String's existing capacity (allocated memory). */

Defer an execution of a function for later. */

frees the internal message data */

* Writes a number at the end of the String using normal base 10 notation. * * Returns the new length of the String */

* This seems to be faster on some systems, especially for smaller distances. * * On newer systems, `memchr` should be faster. */

resets connection data, marking it as either open or closed. */

Returns the argument's value as an integer. */

add reference count to fio_msg_internal_s */

* Creates a timer to run a task at the specified interval. * * The task will repeat `repetitions` times. If `repetitions` is set to 0, task * will

* Binary comparison returns `1` if both strings are equal and `0` if not. */

Returns the number of miliseconds until the next event, up to FIO_POLL_TICK */

* Single layer iteration using a callback for each nested fio object. * * Accepts any `FIOBJ ` type but only collections (Arrays and Hashes) are *

* Parses JSON, setting `pobj` to point to the new Object. * * Returns the number of bytes consumed. On Error, 0 is returned and no data is * consum

send a FIOBJ object through a socket. */

Confirms the requested capacity is available and allocates as required. */

* Adds a named parameter to the hash, resolving nesting references. * * i.e.: * * * "name[]" references a nested Array (nested in the Hash). * *

* Called when simple template text (string) is detected. * * A conforming implementation will output data as a string (no escaping). */

public API. */

Process the buffer once full. */

PUBLIC API: opens a server or client socket */

* Replaces the value in a key-value pair, returning the old value (and it's * ownership) to the caller. * * A return value of NULL indicates that n

This will encode a byte array (data) of a specified length (len) and place the encoded data into the target byte buffer (target). The target buffer MU

public API. */

* Writes the local machine address (qualified host name) to the buffer. * * Returns the amount of data written (excluding the NUL byte). * * `limi

Tests if the list is empty. */