LibAwsCommon

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

__JL_Ctag_1118

36 bytes for the UUID plus one more for the null terminator.

__JL_Ctag_1223

Documentation not found.

__JL_Ctag_1224

Documentation not found.

__JL_Ctag_1268

honor the ABI compat

__JL_Ctag_1305

Documentation not found.

__JL_Ctag_1306

Documentation not found.

__JL_Ctag_1307

Documentation not found.

__JL_Ctag_1308

Documentation not found.

__JL_Ctag_1309

Documentation not found.

__JL_Ctag_1310

Documentation not found.

__JL_Ctag_1311

Documentation not found.

__JL_Ctag_292

Documentation not found.

__JL_Ctag_41

Documentation not found.

__JL_Ctag_443

Documentation not found.

__JL_Ctag_660

Each library gets space for 2^^10 log subject entries

__JL_Ctag_681

Documentation not found.

__JL_Ctag_884

Each library gets space for 2^^8 category entries

___itt_track_group_type

exclude_from_documentation

___itt_track_type

Placeholder for custom track types. Currently, "normal" custom track is the only available track type.

Documentation not found.

__itt_av_data_type

__itt_av_data_type

Defines types of arrays data (for C/C++ intrinsic types)

__itt_collection_scope

__itt_collection_scope

Enumerator for collection scopes

__itt_collection_state

__itt_collection_state

Enumerator for collection state.

__itt_context_type

describes the type of context metadata

__itt_metadata_type

parameters

describes the type of metadata

__itt_model_disable

__itt_model_disable

Enumerator for the disable methods

__itt_module_type

exclude_from_documentation

__itt_relation

relations

The kind of relation between two instances is specified by the enumerated type __itt_relation. Relations between instances can be added with an API call. The relation API uses instance IDs. Relations can be added before or after the actual instances are created and persist independently of the instances. This is the motivation for having different lifetimes for instance IDs and the actual instances.

__itt_scope

Describes the scope of an event object in the trace.

__itt_section_type

exclude_from_documentation

__itt_suppress_mode

__itt_suppress_mode

Enumerator for the suppressing modes

Documentation not found.

__pthread_internal_list

Documentation not found.

Documentation not found.

__pthread_mutex_s

Documentation not found.

Documentation not found.

Documentation not found.

aws_allocator

Allocator structure. An instance of this will be passed around for anything needing memory allocation

aws_array_list

Documentation not found.

Prototype for a comparator function for sorting elements.

a and b should be cast to pointers to the element type held in the list before being dereferenced. The function should compare the elements and return a positive number if a > b, zero if a = b, and a negative number if a < b.

Documentation not found.

aws_atomic_var

struct aws_atomic_var represents an atomic variable - a value which can hold an integer or pointer that can be manipulated atomically. struct aws_atomic_vars should normally only be manipulated with atomics methods defined in this header.

aws_byte_buf

Represents a length-delimited binary string or buffer. If byte buffer points to constant memory or memory that should otherwise not be freed by this struct, set allocator to NULL and free function will be a no-op.

This structure used to define the output for all functions that write to a buffer.

Note that this structure allocates memory at the buffer pointer only. The struct itself does not get dynamically allocated and must be either maintained or copied to avoid losing access to the memory.

aws_byte_cursor

Represents a movable pointer within a larger binary string or buffer.

This structure is used to define buffers for reading.

Signature for function argument to trim APIs

aws_cache

Base stucture for caches, used the linked hash table implementation.

aws_cache_vtable

Documentation not found.

aws_cli_option

Ignoring padding since we're trying to maintain getopt.h compatibility

NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)

aws_cli_options_has_arg

Documentation not found.

Invoked when a subcommand is encountered. argc and argv[] begins at the command encountered. command_name is the name of the command being handled.

aws_cli_subcommand_dispatch

Dispatch table to dispatch cli commands from. command_name should be the exact string for the command you want to handle from the command line.

aws_common_error

Documentation not found.

aws_common_log_subject

Documentation not found.

Documentation not found.

aws_condition_variable

Documentation not found.

aws_cpu_feature_name

Documentation not found.

aws_cpu_info

Documentation not found.

Documentation not found.

aws_crt_common_statistics_category

The common-specific range of the aws_crt_statistics_category cross-library enum.

This enum functions as an RTTI value that lets statistics handler's interpret (via cast) a specific statistics structure if the RTTI value is understood.

Common doesn't have any statistics structures presently, so its range is essentially empty.

aws_crt_statistics_base

Pattern-struct that functions as a base "class" for all statistics structures. To conform to the pattern, a statistics structure must have its first member be the category. In that case it becomes "safe" to cast from aws_crt_statistics_base to the specific statistics structure based on the category value.

Documentation not found.

aws_crt_statistics_handler

Base structure for all statistics handler implementations.

A statistics handler is an object that listens to a stream of polymorphic (via the category RTTI enum) statistics structures emitted from some arbitrary source. In the initial implementation, statistics handlers are primarily attached to channels, where they monitor IO throughput and state data (from channel handlers) to determine a connection's health.

Statistics handlers are a generalization of the timeout and bandwidth filters that are often associated with SDK network connections. Configurable, default implementations are defined at the protocol level (http, etc...) where they can be attached at connection (channel) creation time.

Destroys a statistics handler implementation

The period, in milliseconds, that the handler would like to be informed of statistics. Statistics generators are not required to honor this value, but should if able.

Statistics intake function. The array_list is a list of pointers to aws_crt_statistics_base "derived" (via pattern) objects. The handler should iterate the list and downcast elements whose RTTI category it understands, while skipping those it does not understand.

aws_crt_statistics_handler_vtable

Vtable for functions that all statistics handlers must implement

aws_crt_statistics_sample_interval

The start and end time, in milliseconds-since-epoch, that a set of statistics was gathered over.

aws_date_day_of_week

Documentation not found.

aws_date_format

Documentation not found.

aws_date_month

Documentation not found.

aws_date_time

Documentation not found.

aws_directory_entry

Documentation not found.

Documentation not found.

Documentation not found.

aws_error_info

Documentation not found.

aws_error_info_list

Documentation not found.

aws_file_type

Documentation not found.

Prototype for a hash table key or value destructor function pointer.

This function is used to destroy elements in the hash table when the table is cleared or cleaned up.

Note that functions which remove individual elements from the hash table provide options of whether or not to invoke the destructors on the key and value of a removed element.

Prototype for a hash table equality check function pointer.

This type is usually used for a function that compares two hash table keys, but note that the same type is used for a function that compares two hash table values in aws_hash_table_eq.

Equality functions used in a hash table must be be reflexive (a == a), symmetric (a == b => b == a), transitive (a == b, b == c => a == c) and consistent (result does not change with time).

aws_hash_element

Represents an element in the hash table. Various operations on the hash table may provide pointers to elements stored within the hash table; generally, calling code may alter value, but must not alter key (or any information used to compute key's hash code).

Pointers to elements within the hash are invalidated whenever an operation which may change the number of elements in the hash is invoked (i.e. put, delete, clear, and clean_up), regardless of whether the number of elements actually changes.

Prototype for a key hashing function pointer.

aws_hash_iter

Documentation not found.

aws_hash_iter_status

Documentation not found.

aws_hash_table

Documentation not found.

callback for iterating members of an object Iteration can be controlled as follows: - return AWS_OP_SUCCESS and out_should_continue is set to true (default value) - continue iteration without error - return AWS_OP_SUCCESS and out_continue is set to false - stop iteration without error - return AWS_OP_ERR - stop iteration with error

callback for iterating values of an array. Iteration can be controlled as follows: - return AWS_OP_SUCCESS and out_should_continue is set to true (default value) - continue iteration without error - return AWS_OP_SUCCESS and out_continue is set to false - stop iteration without error - return AWS_OP_ERR - stop iteration with error

Documentation not found.

aws_linked_hash_table

Simple linked hash table. Preserves insertion order, and can be iterated in insertion order.

You can also change the order safely without altering the shape of the underlying hash table.

aws_linked_hash_table_node

Linked-List node stored in the table. This is the node type that will be returned in aws_linked_hash_table_get_iteration_list().

aws_linked_list

Documentation not found.

aws_linked_list_node

Documentation not found.

aws_log_channel

Log channel interface and default implementations

A log channel is an abstraction for the transfer of formatted log data between a source (formatter) and a sink (writer).

Documentation not found.

Documentation not found.

aws_log_channel_vtable

Documentation not found.

aws_log_formatter

Log formatter interface and default implementation

Log formatters are invoked by the LOGF_* macros to transform a set of arguments into one or more lines of text to be output to a logging sink (writer).

Documentation not found.

Documentation not found.

aws_log_formatter_standard_options

Documentation not found.

aws_log_formatter_vtable

Documentation not found.

aws_log_level

Controls what log calls pass through the logger and what log calls get filtered out. If a log level has a value of X, then all log calls using a level <= X will appear, while those using a value > X will not occur.

You can filter both dynamically (by setting the log level on the logger object) or statically (by defining AWS_STATIC_LOG_LEVEL to be an appropriate integer module-wide). Statically filtered log calls will be completely compiled out but require a rebuild if you want to get more detail about what's happening.

aws_log_subject_info

Documentation not found.

aws_log_subject_info_list

Documentation not found.

Log subject is a way of designating the topic of logging.

The general idea is to support a finer-grained approach to log level control. The primary use case is for situations that require more detailed logging within a specific domain, where enabling that detail globally leads to an untenable flood of information.

For example, enable TRACE logging for tls-related log statements (handshake binary payloads), but only WARN logging everywhere else (because http payloads would blow up the log files).

Log subject is an enum similar to aws error: each library has its own value-space and someone is responsible for registering the value <-> string connections.

aws_log_writer

Log writer interface and default implementation(s)

A log writer functions as a sink for formatted log lines. We provide default implementations that go to stdout, stderr, and a specified file.

Documentation not found.

aws_log_writer_file_options

Documentation not found.

aws_log_writer_vtable

Documentation not found.

Documentation not found.

aws_logger

Documentation not found.

aws_logger_pipeline

Standard logger implementation composing three sub-components:

The formatter takes var args input from the user and produces a formatted log line The writer takes a formatted log line and outputs it somewhere The channel is the transport between the two

aws_logger_standard_options

Options for aws_logger_init_standard(). Set filename to open a file for logging and close it when the logger cleans up. Set file to use a file that is already open, such as stderr or stdout.

aws_logger_vtable

We separate the log level function from the log call itself so that we can do the filter check in the macros (see below)

By doing so, we make it so that the variadic format arguments are not even evaluated if the filter check does not succeed.

aws_logging_standard_formatting_data

Documentation not found.

aws_mem_trace_level

Maintainer note: The above function doesn't return the pointer (as with standard C realloc) as this pattern becomes error-prone when OOMs occur. In particular, we want to avoid losing the old pointer when an OOM condition occurs, so we prefer to take the old pointer as an in/out reference argument that we can leave unchanged on failure.

aws_memory_order

This enumeration specifies the memory ordering properties requested for a particular atomic operation. The atomic operation may provide stricter ordering than requested. Note that, within a single thread, all operations are still sequenced (that is, a thread sees its own atomic writes and reads happening in program order, but other threads may disagree on this ordering).

The behavior of these memory orderings are the same as in the C11 atomics API; however, we only implement a subset that can be portably implemented on the compilers we target.

aws_memory_usage_stats

Documentation not found.

aws_mutex

Documentation not found.

Invoked during calls to aws_directory_traverse() as an entry is encountered. entry will contain the parsed directory entry info.

Return true to continue the traversal, or alternatively, if you have a reason to abort the traversal, return false.

aws_platform_os

Documentation not found.

aws_priority_queue

Documentation not found.

The comparator should return a positive value if the second argument has a higher priority than the first; Otherwise, it should return a negative value or zero. NOTE: priority_queue pops its highest priority element first. For example: int cmp(const void *a, const void *b) { return a < b; } would result in a max heap, while: int cmp(const void *a, const void *b) { return a > b; } would result in a min heap.

aws_priority_queue_node

Documentation not found.

Standard promise interface. Promise can be waited on by multiple threads, and as long as it is ref-counted correctly, will provide the resultant value/error code to all waiters. All promise API calls are internally thread-safe.

aws_ref_count

A utility type for making ref-counted types, reminiscent of std::shared_ptr in C++

aws_ring_buffer

Lockless ring buffer implementation that is thread safe assuming a single thread acquires and a single thread releases. For any other use case (other than the single-threaded use-case), you must manage thread-safety manually.

Also, a very important note: release must happen in the same order as acquire. If you do not your application, and possibly computers within a thousand mile radius, may die terrible deaths, and the local drinking water will be poisoned for generations with fragments of what is left of your radioactive corrupted memory.

aws_run_command_options

Documentation not found.

aws_run_command_result

Documentation not found.

aws_rw_lock

Documentation not found.

aws_shutdown_callback_options

Documentation not found.

Documentation not found.

aws_string

Documentation not found.

Documentation not found.

aws_task

A task object. Once added to the scheduler, a task must remain in memory until its function is executed.

A scheduled function.

aws_task_scheduler

Documentation not found.

aws_task_status

Documentation not found.

Documentation not found.

Documentation not found.

aws_test_harness

Documentation not found.

Documentation not found.

aws_text_encoding

Documentation not found.

aws_thread

Documentation not found.

Documentation not found.

aws_thread_detach_state

Documentation not found.

Documentation not found.

aws_thread_join_strategy

Specifies the join strategy used on an aws_thread, which in turn controls whether or not a thread participates in the managed thread system. The managed thread system provides logic to guarantee a join on all participating threads at the cost of laziness (the user cannot control when joins happen).

Manual - thread does not participate in the managed thread system; any joins must be done by the user. This is the default. The user must call aws_thread_clean_up(), but only after any desired join operation has completed. Not doing so will cause the windows handle to leak.

Managed - the managed thread system will automatically perform a join some time after the thread's run function has completed. It is an error to call aws_thread_join on a thread configured with the managed join strategy. The managed thread system will call aws_thread_clean_up() on the thread after the background join has completed.

Additionally, an API exists, aws_thread_join_all_managed(), which blocks and returns when all outstanding threads with the managed strategy have fully joined. This API is useful for tests (rather than waiting for many individual signals) and program shutdown or DLL unload. This API is automatically invoked by the common library clean up function. If the common library clean up is called from a managed thread, this will cause deadlock.

Lazy thread joining is done only when threads finish their run function or when the user calls aws_thread_join_all_managed(). This means it may be a long time between thread function completion and the join being applied, but the queue of unjoined threads is always one or fewer so there is no critical resource backlog.

Currently, only event loop group async cleanup and host resolver threads participate in the managed thread system. Additionally, event loop threads will increment and decrement the pending join count (they are manually joined internally) in order to have an accurate view of internal thread usage and also to prevent failure to release an event loop group fully from allowing aws_thread_join_all_managed() from running to completion when its intent is such that it should block instead.

Documentation not found.

aws_thread_options

Documentation not found.

Documentation not found.

aws_timestamp_unit

Documentation not found.

aws_uri

Data representing a URI. uri_str is always allocated and filled in. The other portions are merely storing offsets into uri_str.

aws_uri_builder_options

Arguments for building a URI instance. All members must be initialized before passing them to aws_uri_init().

query_string and query_params are exclusive to each other. If you set query_string, do not prepend it with '?'

aws_uri_param

key/value pairs for a query string. If the query fragment was not in format key=value, the fragment value will be stored in key

Documentation not found.

aws_utf8_decoder_options

Documentation not found.

aws_uuid

Documentation not found.

aws_xml_attribute

Documentation not found.

Documentation not found.

Callback for when an xml node is encountered in the document. As a user you have a few options:

1. fail the parse by returning AWS_OP_ERR (after an error has been raised). This will stop any further parsing. 2. call aws_xml_node_traverse() on the node to descend into the node with a new callback and user_data. 3. call aws_xml_node_as_body() to retrieve the contents of the node as text.

You MUST NOT call both aws_xml_node_traverse() and aws_xml_node_as_body() on the same node.

return true to continue the parsing operation.

aws_xml_parser_options

Documentation not found.

Hash table data structure. This module provides an automatically resizing hash table implementation for general purpose use. The hash table stores a mapping between void * keys and values; it is expected that in most cases, these will point to a structure elsewhere in the heap, instead of inlining a key or value into the hash table element itself.

Currently, this hash table implements a variant of robin hood hashing, but we do not guarantee that this won't change in the future.

Associated with each hash function are four callbacks:

hash_fn - A hash function from the keys to a uint64_t. It is critical that the hash function for a key does not change while the key is in the hash table; violating this results in undefined behavior. Collisions are tolerated, though naturally with reduced performance.

equals_fn - An equality comparison function. This function must be reflexive and consistent with hash_fn.

destroy_key_fn, destroy_value_fn - Optional callbacks invoked when the table is cleared or cleaned up and at the caller's option when an element is removed from the table. Either or both may be set to NULL, which has the same effect as a no-op destroy function.

This datastructure can be safely moved between threads, subject to the requirements of the underlying allocator. It is also safe to invoke non-mutating operations on the hash table from multiple threads. A suitable memory barrier must be used when transitioning from single-threaded mutating usage to multithreaded usage.

pthread_cond_t

Documentation not found.

pthread_mutex_t

Documentation not found.

Documentation not found.

pthread_rwlock_t

Documentation not found.

Documentation not found.

siginfo

Documentation not found.

Documentation not found.

sigval

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

tm

Documentation not found.

aws_add_size_checked(a, b, r)

Adds a + b and returns the result in *r. If the result overflows, returns AWS_OP_ERR; otherwise returns AWS_OP_SUCCESS.

Prototype

AWS_STATIC_IMPL int aws_add_size_checked(size_t a, size_t b, size_t *r);

aws_add_size_saturating(a, b)

Adds a + b. If the result overflows returns SIZE_MAX.

Prototype

AWS_STATIC_IMPL size_t aws_add_size_saturating(size_t a, size_t b);

aws_add_u32_checked(a, b, r)

If a + b overflows, returns AWS_OP_ERR; otherwise adds a + b, returns the result in *r, and returns AWS_OP_SUCCESS.

Prototype

AWS_STATIC_IMPL int aws_add_u32_checked(uint32_t a, uint32_t b, uint32_t *r);

aws_add_u32_saturating(a, b)

Adds a + b. If the result overflows, returns 2^32 - 1.

Prototype

AWS_STATIC_IMPL uint32_t aws_add_u32_saturating(uint32_t a, uint32_t b);

aws_add_u64_checked(a, b, r)

If a + b overflows, returns AWS_OP_ERR; otherwise adds a + b, returns the result in *r, and returns AWS_OP_SUCCESS.

Prototype

AWS_STATIC_IMPL int aws_add_u64_checked(uint64_t a, uint64_t b, uint64_t *r);

aws_add_u64_saturating(a, b)

Adds a + b. If the result overflows, returns 2^64 - 1.

Prototype

AWS_STATIC_IMPL uint64_t aws_add_u64_saturating(uint64_t a, uint64_t b);

aws_aligned_allocator()

Allocator that align small allocations on 8 byte boundary and big allocations on 32/64 byte boundary.

Prototype

struct aws_allocator *aws_aligned_allocator(void);

aws_allocator_is_valid(alloc)

Inexpensive (constant time) check of data-structure invariants.

Prototype

bool aws_allocator_is_valid(const struct aws_allocator *alloc);

aws_array_eq(array_a, len_a, array_b, len_b)

Compare two arrays. Return whether their contents are equivalent. NULL may be passed as the array pointer if its length is declared to be 0.

Prototype

bool aws_array_eq(const void *const array_a, const size_t len_a, const void *array_b, const size_t len_b);

aws_array_eq_c_str(array, array_len, c_str)

Compare an array and a null-terminated string. Returns true if their contents are equivalent. The array should NOT contain a null-terminator, or the comparison will always return false. NULL may be passed as the array pointer if its length is declared to be 0.

Prototype

bool aws_array_eq_c_str(const void *const array, const size_t array_len, const char *const c_str);

aws_array_eq_c_str_ignore_case(array, array_len, c_str)

Perform a case-insensitive string comparison of an array and a null-terminated string. Return whether their contents are equivalent. The array should NOT contain a null-terminator, or the comparison will always return false. NULL may be passed as the array pointer if its length is declared to be 0. The "C" locale is used for comparing upper and lowercase letters. Data is assumed to be ASCII text, UTF-8 will work fine too.

Prototype

bool aws_array_eq_c_str_ignore_case(const void *const array, const size_t array_len, const char *const c_str);

aws_array_eq_ignore_case(array_a, len_a, array_b, len_b)

Perform a case-insensitive string comparison of two arrays. Return whether their contents are equivalent. NULL may be passed as the array pointer if its length is declared to be 0. The "C" locale is used for comparing upper and lowercase letters. Data is assumed to be ASCII text, UTF-8 will work fine too.

Prototype

bool aws_array_eq_ignore_case( const void *const array_a, const size_t len_a, const void *const array_b, const size_t len_b);

aws_array_list_back(list, val)

Copies the element at the end of the list if it exists. If list is empty, AWS_ERROR_LIST_EMPTY will be raised.

Prototype

AWS_STATIC_IMPL int aws_array_list_back(const struct aws_array_list *AWS_RESTRICT list, void *val);

aws_array_list_capacity(list)

Returns the number of elements that can fit in the internal array. If list is initialized in dynamic mode, the capacity changes over time.

Prototype

AWS_STATIC_IMPL size_t aws_array_list_capacity(const struct aws_array_list *AWS_RESTRICT list);

aws_array_list_clean_up(list)

Deallocates any memory that was allocated for this list, and resets list for reuse or deletion.

Prototype

AWS_STATIC_IMPL void aws_array_list_clean_up(struct aws_array_list *AWS_RESTRICT list);

aws_array_list_clean_up_secure(list)

Erases and then deallocates any memory that was allocated for this list, and resets list for reuse or deletion.

Prototype

AWS_STATIC_IMPL void aws_array_list_clean_up_secure(struct aws_array_list *AWS_RESTRICT list);

aws_array_list_clear(list)

Clears all elements in the array and resets length to zero. Size does not change in this operation.

Prototype

AWS_STATIC_IMPL void aws_array_list_clear(struct aws_array_list *AWS_RESTRICT list);

aws_array_list_comparator_string(a, b)

A convenience function for sorting lists of (const struct aws_string *) elements. This can be used as a comparator for aws_array_list_sort. It is just a simple wrapper around aws_string_compare.

Prototype

int aws_array_list_comparator_string(const void *a, const void *b);

aws_array_list_copy(from, to)

Copies the elements from from to to. If to is in static mode, it must at least be the same length as from. Any data in to will be overwritten in this copy.

Prototype

int aws_array_list_copy(const struct aws_array_list *AWS_RESTRICT from, struct aws_array_list *AWS_RESTRICT to);

aws_array_list_ensure_capacity(list, index)

Ensures that the array list has enough capacity to store a value at the specified index. If there is not already enough capacity, and the list is in dynamic mode, this function will attempt to allocate more memory, expanding the list. In static mode, if 'index' is beyond the maximum index, AWS_ERROR_INVALID_INDEX will be raised.

Prototype

int aws_array_list_ensure_capacity(struct aws_array_list *AWS_RESTRICT list, size_t index);

aws_array_list_erase(list, index)

Deletes the element this index in the list if it exists. If element does not exist, AWS_ERROR_INVALID_INDEX will be raised. This call results in shifting all remaining elements towards the front. Avoid this call unless that is intended behavior.

Prototype

AWS_STATIC_IMPL int aws_array_list_erase(struct aws_array_list *AWS_RESTRICT list, size_t index);

aws_array_list_front(list, val)

Copies the element at the front of the list if it exists. If list is empty, AWS_ERROR_LIST_EMPTY will be raised

Prototype

AWS_STATIC_IMPL int aws_array_list_front(const struct aws_array_list *AWS_RESTRICT list, void *val);

aws_array_list_get_at(list, val, index)

Copies the memory at index to val. If element does not exist, AWS_ERROR_INVALID_INDEX will be raised.

Prototype

AWS_STATIC_IMPL int aws_array_list_get_at(const struct aws_array_list *AWS_RESTRICT list, void *val, size_t index);

aws_array_list_get_at_ptr(list, val, index)

Copies the memory address of the element at index to *val. If element does not exist, AWS_ERROR_INVALID_INDEX will be raised.

Prototype

AWS_STATIC_IMPL int aws_array_list_get_at_ptr(const struct aws_array_list *AWS_RESTRICT list, void **val, size_t index);

aws_array_list_init_dynamic(list, alloc, initial_item_allocation, item_size)

Initializes an array list with an array of size initial_item_allocation * item_size. In this mode, the array size will grow by a factor of 2 upon insertion if space is not available. initial_item_allocation is the number of elements you want space allocated for. item_size is the size of each element in bytes. Mixing items types is not supported by this API.

Prototype

AWS_STATIC_IMPL int aws_array_list_init_dynamic( struct aws_array_list *AWS_RESTRICT list, struct aws_allocator *alloc, size_t initial_item_allocation, size_t item_size);

aws_array_list_init_static(list, raw_array, item_count, item_size)

Initializes an array list with a preallocated array of void *. item_count is the number of elements in the array, and item_size is the size in bytes of each element. Mixing items types is not supported by this API. Once this list is full, new items will be rejected.

Prototype

AWS_STATIC_IMPL void aws_array_list_init_static( struct aws_array_list *AWS_RESTRICT list, void *raw_array, size_t item_count, size_t item_size);

aws_array_list_init_static_from_initialized(list, raw_array, item_count, item_size)

Initializes an array list with a preallocated array of already-initialized elements. item_count is the number of elements in the array, and item_size is the size in bytes of each element.

Once initialized, nothing further can be added to the list, since it will be full and cannot resize.

Primary use case is to treat an already-initialized C array as an array list.

Prototype

AWS_STATIC_IMPL void aws_array_list_init_static_from_initialized( struct aws_array_list *AWS_RESTRICT list, void *raw_array, size_t item_count, size_t item_size);

aws_array_list_is_valid(list)

Set of properties of a valid aws_array_list.

Prototype

AWS_STATIC_IMPL bool aws_array_list_is_valid(const struct aws_array_list *AWS_RESTRICT list);

aws_array_list_length(list)

Returns the number of elements in the internal array.

Prototype

AWS_STATIC_IMPL size_t aws_array_list_length(const struct aws_array_list *AWS_RESTRICT list);

aws_array_list_pop_back(list)

Deletes the element at the end of the list if it exists. If list is empty, AWS_ERROR_LIST_EMPTY will be raised.

Prototype

AWS_STATIC_IMPL int aws_array_list_pop_back(struct aws_array_list *AWS_RESTRICT list);

aws_array_list_pop_front(list)

Deletes the element at the front of the list if it exists. If list is empty, AWS_ERROR_LIST_EMPTY will be raised. This call results in shifting all of the elements at the end of the array to the front. Avoid this call unless that is intended behavior.

Prototype

AWS_STATIC_IMPL int aws_array_list_pop_front(struct aws_array_list *AWS_RESTRICT list);

aws_array_list_pop_front_n(list, n)

Delete N elements from the front of the list. Remaining elements are shifted to the front of the list. If the list has less than N elements, the list is cleared. This call is more efficient than calling aws_array_list_pop_front() N times.

Prototype

AWS_STATIC_IMPL void aws_array_list_pop_front_n(struct aws_array_list *AWS_RESTRICT list, size_t n);

aws_array_list_push_back(list, val)

Pushes the memory pointed to by val onto the end of internal list

Prototype

AWS_STATIC_IMPL int aws_array_list_push_back(struct aws_array_list *AWS_RESTRICT list, const void *val);

aws_array_list_push_front(list, val)

Pushes the memory pointed to by val onto the front of internal list. This call results in shifting all of the elements in the list. Avoid this call unless that is intended behavior.

Prototype

AWS_STATIC_IMPL int aws_array_list_push_front(struct aws_array_list *AWS_RESTRICT list, const void *val);

aws_array_list_set_at(list, val, index)

Copies the the memory pointed to by val into the array at index. If in dynamic mode, the size will grow by a factor of two when the array is full. In static mode, AWS_ERROR_INVALID_INDEX will be raised if the index is past the bounds of the array.

Prototype

AWS_STATIC_IMPL int aws_array_list_set_at(struct aws_array_list *AWS_RESTRICT list, const void *val, size_t index);

aws_array_list_shrink_to_fit(list)

If in dynamic mode, shrinks the allocated array size to the minimum amount necessary to store its elements.

Prototype

int aws_array_list_shrink_to_fit(struct aws_array_list *AWS_RESTRICT list);

aws_array_list_sort(list, compare_fn)

Sort elements in the list in-place according to the comparator function.

Prototype

void aws_array_list_sort(struct aws_array_list *AWS_RESTRICT list, aws_array_list_comparator_fn *compare_fn);

aws_array_list_swap(list, a, b)

Swap elements at the specified indices, which must be within the bounds of the array.

Prototype

void aws_array_list_swap(struct aws_array_list *AWS_RESTRICT list, size_t a, size_t b);

aws_array_list_swap_contents(list_a, list_b)

Swap contents between two dynamic lists. Both lists must use the same allocator.

Prototype

AWS_STATIC_IMPL void aws_array_list_swap_contents( struct aws_array_list *AWS_RESTRICT list_a, struct aws_array_list *AWS_RESTRICT list_b);

aws_atomic_compare_exchange_int(var, expected, desired)

Atomically compares *var to *expected; if they are equal, atomically sets *var = desired. Otherwise, *expected is set to the value in *var. Uses sequentially consistent memory ordering, regardless of success or failure. Returns true if the compare was successful and the variable updated to desired.

Prototype

AWS_STATIC_IMPL bool aws_atomic_compare_exchange_int(volatile struct aws_atomic_var *var, size_t *expected, size_t desired);

aws_atomic_compare_exchange_int_explicit(var, expected, desired, order_success, order_failure)

Atomically compares *var to *expected; if they are equal, atomically sets *var = desired. Otherwise, *expected is set to the value in *var. On success, the memory ordering used was order_success; otherwise, it was order_failure. order_failure must be no stronger than order_success, and must not be release or acq_rel. Returns true if the compare was successful and the variable updated to desired.

Prototype

AWS_STATIC_IMPL bool aws_atomic_compare_exchange_int_explicit( volatile struct aws_atomic_var *var, size_t *expected, size_t desired, enum aws_memory_order order_success, enum aws_memory_order order_failure);

aws_atomic_compare_exchange_ptr(var, expected, desired)

Atomically compares *var to *expected; if they are equal, atomically sets *var = desired. Otherwise, *expected is set to the value in *var. Uses sequentially consistent memory ordering, regardless of success or failure. Returns true if the compare was successful and the variable updated to desired.

Prototype

AWS_STATIC_IMPL bool aws_atomic_compare_exchange_ptr(volatile struct aws_atomic_var *var, void **expected, void *desired);

aws_atomic_compare_exchange_ptr_explicit(var, expected, desired, order_success, order_failure)

Atomically compares *var to *expected; if they are equal, atomically sets *var = desired. Otherwise, *expected is set to the value in *var. On success, the memory ordering used was order_success; otherwise, it was order_failure. order_failure must be no stronger than order_success, and must not be release or acq_rel. Returns true if the compare was successful and the variable updated to desired.

Prototype

AWS_STATIC_IMPL bool aws_atomic_compare_exchange_ptr_explicit( volatile struct aws_atomic_var *var, void **expected, void *desired, enum aws_memory_order order_success, enum aws_memory_order order_failure);

aws_atomic_exchange_int(var, n)

Exchanges an integer with the value in an atomic_var, using sequentially consistent ordering. Returns the value that was previously in the atomic_var.

Prototype

AWS_STATIC_IMPL size_t aws_atomic_exchange_int(volatile struct aws_atomic_var *var, size_t n);

aws_atomic_exchange_int_explicit(var, n, memory_order)

Exchanges an integer with the value in an atomic_var, using the specified ordering. Returns the value that was previously in the atomic_var.

Prototype

AWS_STATIC_IMPL size_t aws_atomic_exchange_int_explicit( volatile struct aws_atomic_var *var, size_t n, enum aws_memory_order memory_order);

aws_atomic_exchange_ptr(var, p)

Exchanges an integer with the value in an atomic_var, using sequentially consistent ordering. Returns the value that was previously in the atomic_var.

Prototype

AWS_STATIC_IMPL void *aws_atomic_exchange_ptr(volatile struct aws_atomic_var *var, void *p);

aws_atomic_exchange_ptr_explicit(var, p, memory_order)

Exchanges a pointer with the value in an atomic_var, using the specified ordering. Returns the value that was previously in the atomic_var.

Prototype

AWS_STATIC_IMPL void *aws_atomic_exchange_ptr_explicit( volatile struct aws_atomic_var *var, void *p, enum aws_memory_order memory_order);

aws_atomic_fetch_add(var, n)

Atomically adds n to *var, and returns the previous value of *var. Uses sequentially consistent ordering.

Prototype

AWS_STATIC_IMPL size_t aws_atomic_fetch_add(volatile struct aws_atomic_var *var, size_t n);

aws_atomic_fetch_add_explicit(var, n, order)

Atomically adds n to *var, and returns the previous value of *var.

Prototype

AWS_STATIC_IMPL size_t aws_atomic_fetch_add_explicit(volatile struct aws_atomic_var *var, size_t n, enum aws_memory_order order);

aws_atomic_fetch_and(var, n)

Atomically ands n into *var, and returns the previous value of *var. Uses sequentially consistent ordering.

Prototype

AWS_STATIC_IMPL size_t aws_atomic_fetch_and(volatile struct aws_atomic_var *var, size_t n);

aws_atomic_fetch_and_explicit(var, n, order)

Atomically ANDs n with *var, and returns the previous value of *var.

Prototype

AWS_STATIC_IMPL size_t aws_atomic_fetch_and_explicit(volatile struct aws_atomic_var *var, size_t n, enum aws_memory_order order);

aws_atomic_fetch_or(var, n)

Atomically ors n into *var, and returns the previous value of *var. Uses sequentially consistent ordering.

Prototype

AWS_STATIC_IMPL size_t aws_atomic_fetch_or(volatile struct aws_atomic_var *var, size_t n);

aws_atomic_fetch_or_explicit(var, n, order)

Atomically ORs n with *var, and returns the previous value of *var.

Prototype

AWS_STATIC_IMPL size_t aws_atomic_fetch_or_explicit(volatile struct aws_atomic_var *var, size_t n, enum aws_memory_order order);

aws_atomic_fetch_sub(var, n)

Atomically subtracts n from *var, and returns the previous value of *var. Uses sequentially consistent ordering.

Prototype

AWS_STATIC_IMPL size_t aws_atomic_fetch_sub(volatile struct aws_atomic_var *var, size_t n);

aws_atomic_fetch_sub_explicit(var, n, order)

Atomically subtracts n from *var, and returns the previous value of *var.

Prototype

AWS_STATIC_IMPL size_t aws_atomic_fetch_sub_explicit(volatile struct aws_atomic_var *var, size_t n, enum aws_memory_order order);

aws_atomic_fetch_xor(var, n)

Atomically xors n into *var, and returns the previous value of *var. Uses sequentially consistent ordering.

Prototype

AWS_STATIC_IMPL size_t aws_atomic_fetch_xor(volatile struct aws_atomic_var *var, size_t n);

aws_atomic_fetch_xor_explicit(var, n, order)

Atomically XORs n with *var, and returns the previous value of *var.

Prototype

AWS_STATIC_IMPL size_t aws_atomic_fetch_xor_explicit(volatile struct aws_atomic_var *var, size_t n, enum aws_memory_order order);

aws_atomic_init_int(var, n)

Initializes an atomic variable with an integer value. This operation should be done before any other operations on this atomic variable, and must be done before attempting any parallel operations.

This operation does not imply a barrier. Ensure that you use an acquire-release barrier (or stronger) when communicating the fact that initialization is complete to the other thread. Launching the thread implies a sufficiently strong barrier.

Prototype

AWS_STATIC_IMPL void aws_atomic_init_int(volatile struct aws_atomic_var *var, size_t n);

aws_atomic_init_ptr(var, p)

Initializes an atomic variable with a pointer value. This operation should be done before any other operations on this atomic variable, and must be done before attempting any parallel operations.

This operation does not imply a barrier. Ensure that you use an acquire-release barrier (or stronger) when communicating the fact that initialization is complete to the other thread. Launching the thread implies a sufficiently strong barrier.

Prototype

AWS_STATIC_IMPL void aws_atomic_init_ptr(volatile struct aws_atomic_var *var, void *p);

aws_atomic_load_int(var)

Reads an atomic var as an integer, using sequentially consistent ordering, and returns the result.

Prototype

AWS_STATIC_IMPL size_t aws_atomic_load_int(volatile const struct aws_atomic_var *var);

aws_atomic_load_int_explicit(var, memory_order)

Reads an atomic var as an integer, using the specified ordering, and returns the result.

Prototype

AWS_STATIC_IMPL size_t aws_atomic_load_int_explicit(volatile const struct aws_atomic_var *var, enum aws_memory_order memory_order);

aws_atomic_load_ptr(var)

Reads an atomic var as a pointer, using sequentially consistent ordering, and returns the result.

Prototype

AWS_STATIC_IMPL void *aws_atomic_load_ptr(volatile const struct aws_atomic_var *var);

aws_atomic_load_ptr_explicit(var, memory_order)

Reads an atomic var as a pointer, using the specified ordering, and returns the result.

Prototype

AWS_STATIC_IMPL void *aws_atomic_load_ptr_explicit(volatile const struct aws_atomic_var *var, enum aws_memory_order memory_order);

aws_atomic_priv_xlate_order(order)

Documentation not found.

Prototype

static inline int aws_atomic_priv_xlate_order(enum aws_memory_order order);

aws_atomic_store_int(var, n)

Stores an integer into an atomic var, using sequentially consistent ordering.

Prototype

AWS_STATIC_IMPL void aws_atomic_store_int(volatile struct aws_atomic_var *var, size_t n);

aws_atomic_store_int_explicit(var, n, memory_order)

Stores an integer into an atomic var, using the specified ordering.

Prototype

AWS_STATIC_IMPL void aws_atomic_store_int_explicit(volatile struct aws_atomic_var *var, size_t n, enum aws_memory_order memory_order);

aws_atomic_store_ptr(var, p)

Stores a pointer into an atomic var, using sequentially consistent ordering.

Prototype

AWS_STATIC_IMPL void aws_atomic_store_ptr(volatile struct aws_atomic_var *var, void *p);

aws_atomic_store_ptr_explicit(var, p, memory_order)

Stores a pointer into an atomic var, using the specified ordering.

Prototype

AWS_STATIC_IMPL void aws_atomic_store_ptr_explicit(volatile struct aws_atomic_var *var, void *p, enum aws_memory_order memory_order);

aws_atomic_thread_fence(order)

Provides the same reordering guarantees as an atomic operation with the specified memory order, without needing to actually perform an atomic operation.

Prototype

AWS_STATIC_IMPL void aws_atomic_thread_fence(enum aws_memory_order order);

aws_backtrace(stack_frames, num_frames)

Records a stack trace from the call site. Returns the number of stack entries/stack depth captured, or 0 if the operation is not supported on this platform

Prototype

size_t aws_backtrace(void **stack_frames, size_t num_frames);

aws_backtrace_addr2line(stack_frames, stack_depth)

Converts stack frame pointers to symbols, using all available system tools to try to produce a human readable result. This call will not be quick, as it shells out to addr2line or similar tools. On Windows, this is the same as aws_backtrace_symbols() Returns an array up to stack_depth long that needs to be free()ed. Missing frames will be NULL. Returns NULL if the platform does not support stack frame translation or an error occurs

Prototype

char **aws_backtrace_addr2line(void *const *stack_frames, size_t stack_depth);

aws_backtrace_log(log_level)

Log the callstack from the current stack to the currently configured aws_logger

Prototype

void aws_backtrace_log(int log_level);

aws_backtrace_print(fp, call_site_data)

Print a backtrace from either the current stack, or (if provided) the current exception/signal call_site_data is siginfo_t* on POSIX, and LPEXCEPTION_POINTERS on Windows, and can be null

Prototype

void aws_backtrace_print(FILE *fp, void *call_site_data);

aws_backtrace_symbols(stack_frames, stack_depth)

Converts stack frame pointers to symbols, if symbols are available Returns an array up to stack_depth long, that needs to be free()ed. stack_depth should be the length of frames. Returns NULL if the platform does not support stack frame translation or an error occurs

Prototype

char **aws_backtrace_symbols(void *const *stack_frames, size_t stack_depth);

aws_base64_compute_decoded_len(to_decode, decoded_len)

Computes the length necessary to store the output of aws_base64_decode call. returns -1 on failure, and 0 on success. decoded_len will be set on success.

Prototype

int aws_base64_compute_decoded_len(const struct aws_byte_cursor *AWS_RESTRICT to_decode, size_t *decoded_len);

aws_base64_compute_encoded_len(to_encode_len, encoded_len)

Computes the length necessary to store the output of aws_base64_encode call. returns -1 on failure, and 0 on success. encoded_length will be set on success.

Prototype

int aws_base64_compute_encoded_len(size_t to_encode_len, size_t *encoded_len);

aws_base64_decode(to_decode, output)

Base 64 decodes the contents of to_decode and stores the result in output.

Prototype

int aws_base64_decode(const struct aws_byte_cursor *AWS_RESTRICT to_decode, struct aws_byte_buf *AWS_RESTRICT output);

aws_base64_encode(to_encode, output)

Base 64 encodes the contents of to_encode and stores the result in output.

Prototype

int aws_base64_encode(const struct aws_byte_cursor *AWS_RESTRICT to_encode, struct aws_byte_buf *AWS_RESTRICT output);

aws_byte_buf_advance(buffer, output, len)

Appends a sub-buffer to the specified buffer.

If the buffer has at least len' bytes remaining (buffer->capacity - buffer->len >= len), then buffer->len is incremented by len, and an [awsbytebuf](@ref) is assigned to *output corresponding to the last len bytes of the input buffer. The [awsbytebuf`](@ref) at *output will have a null allocator, a zero initial length, and a capacity of 'len'. The function then returns true.

If there is insufficient space, then this function nulls all fields in *output and returns false.

Prototype

bool aws_byte_buf_advance( struct aws_byte_buf *const AWS_RESTRICT buffer, struct aws_byte_buf *const AWS_RESTRICT output, const size_t len);

aws_byte_buf_append(to, from)

Copies from to to. If to is too small, AWS_ERROR_DEST_COPY_TOO_SMALL will be returned. dest->len will contain the amount of data actually copied to dest.

from and to may be the same buffer, permitting copying a buffer into itself.

Prototype

int aws_byte_buf_append(struct aws_byte_buf *to, const struct aws_byte_cursor *from);

aws_byte_buf_append_and_update(to, from_and_update)

Copy contents of cursor to buffer, then update cursor to reference the memory stored in the buffer. If buffer is too small, AWS_ERROR_DEST_COPY_TOO_SMALL will be returned.

The cursor is permitted to reference memory from earlier in the buffer.

Prototype

int aws_byte_buf_append_and_update(struct aws_byte_buf *to, struct aws_byte_cursor *from_and_update);

aws_byte_buf_append_byte_dynamic(buffer, value)

Copies a single byte into to. If to is too small, the buffer will be grown appropriately and the old contents copied over, before the byte is appended.

If the grow fails (overflow or OOM), then an error will be returned.

Prototype

int aws_byte_buf_append_byte_dynamic(struct aws_byte_buf *buffer, uint8_t value);

aws_byte_buf_append_byte_dynamic_secure(buffer, value)

Copies a single byte into to. If to is too small, the buffer will be grown appropriately and the old contents copied over, before the byte is appended.

If the grow fails (overflow or OOM), then an error will be returned.

If the buffer is grown, the old buffer will be securely cleared before getting freed.

Prototype

int aws_byte_buf_append_byte_dynamic_secure(struct aws_byte_buf *buffer, uint8_t value);

aws_byte_buf_append_decoding_uri(buffer, cursor)

Writes the uri decoding of a UTF-8 cursor to a buffer, replacing xx escapes by their single byte equivalent. For example, reading "a20b_c" would write "a b_c".

Prototype

int aws_byte_buf_append_decoding_uri(struct aws_byte_buf *buffer, const struct aws_byte_cursor *cursor);

aws_byte_buf_append_dynamic(to, from)

Copies from to to. If to is too small, the buffer will be grown appropriately and the old contents copied to, before the new contents are appended.

If the grow fails (overflow or OOM), then an error will be returned.

from and to may be the same buffer, permitting copying a buffer into itself.

Prototype

int aws_byte_buf_append_dynamic(struct aws_byte_buf *to, const struct aws_byte_cursor *from);

aws_byte_buf_append_dynamic_secure(to, from)

Copies from to to. If to is too small, the buffer will be grown appropriately and the old contents copied over, before the new contents are appended.

If the grow fails (overflow or OOM), then an error will be returned.

If the buffer is grown, the old buffer will be securely cleared before getting freed.

from and to may be the same buffer, permitting copying a buffer into itself.

Prototype

int aws_byte_buf_append_dynamic_secure(struct aws_byte_buf *to, const struct aws_byte_cursor *from);

aws_byte_buf_append_encoding_uri_param(buffer, cursor)

Writes the uri query param encoding (passthrough alnum + '-' '_' '~' '.') of a UTF-8 cursor to a buffer For example, reading "a b_c" would write "a20b_c".

Prototype

int aws_byte_buf_append_encoding_uri_param( struct aws_byte_buf *buffer, const struct aws_byte_cursor *cursor);

aws_byte_buf_append_encoding_uri_path(buffer, cursor)

Writes the uri path encoding of a cursor to a buffer. This is the modified version of rfc3986 used by sigv4 signing.

Prototype

int aws_byte_buf_append_encoding_uri_path( struct aws_byte_buf *buffer, const struct aws_byte_cursor *cursor);

aws_byte_buf_append_json_string(value, output)

Appends a unformatted JSON string representation of the aws_json_value into the passed byte buffer. The byte buffer is expected to be already initialized so the function can append the JSON into it.

Note: The byte buffer will automatically have its size extended if the JSON string is over the byte buffer capacity AND the byte buffer has an allocator associated with it. If the byte buffer does not have an allocator associated and the JSON string is over capacity, AWS_OP_ERR will be returned.

Note: When you are finished with the aws_byte_buf, you must call "aws_byte_buf_clean_up_secure" to free the memory used, as it will NOT be called automatically.

Arguments

• value: The aws_json_value to format.
• output: The destination for the JSON string

Returns

AWS_OP_SUCCESS if the JSON string was allocated to output without any errors Will return AWS_OP_ERR if the value passed is not an aws_json_value or if there was an error appending the JSON into the byte buffer.

Prototype

int aws_byte_buf_append_json_string(const struct aws_json_value *value, struct aws_byte_buf *output);

aws_byte_buf_append_json_string_formatted(value, output)

Appends a formatted JSON string representation of the aws_json_value into the passed byte buffer. The byte buffer is expected to already be initialized so the function can append the JSON into it.

Note: The byte buffer will automatically have its size extended if the JSON string is over the byte buffer capacity AND the byte buffer has an allocator associated with it. If the byte buffer does not have an allocator associated and the JSON string is over capacity, AWS_OP_ERR will be returned.

Note: When you are finished with the aws_byte_buf, you must call "aws_byte_buf_clean_up_secure" to free the memory used, as it will NOT be called automatically.

Arguments

• value: The aws_json_value to format.
• output: The destination for the JSON string

Returns

AWS_OP_SUCCESS if the JSON string was allocated to output without any errors Will return AWS_OP_ERR if the value passed is not an aws_json_value or if there aws an error appending the JSON into the byte buffer.

Prototype

int aws_byte_buf_append_json_string_formatted(const struct aws_json_value *value, struct aws_byte_buf *output);

aws_byte_buf_append_null_terminator(buf)

Appends '\0' at the end of the buffer.

Prototype

int aws_byte_buf_append_null_terminator(struct aws_byte_buf *buf);

aws_byte_buf_append_with_lookup(to, from, lookup_table)

Copies from to to while converting bytes via the passed in lookup table. If to is too small, AWS_ERROR_DEST_COPY_TOO_SMALL will be returned. to->len will contain its original size plus the amount of data actually copied to to.

from and to should not be the same buffer (overlap is not handled) lookup_table must be at least 256 bytes

Prototype

int aws_byte_buf_append_with_lookup( struct aws_byte_buf *AWS_RESTRICT to, const struct aws_byte_cursor *AWS_RESTRICT from, const uint8_t *lookup_table);

aws_byte_buf_clean_up(buf)

Documentation not found.

Prototype

void aws_byte_buf_clean_up(struct aws_byte_buf *buf);

aws_byte_buf_clean_up_secure(buf)

Equivalent to calling aws_byte_buf_secure_zero and then aws_byte_buf_clean_up on the buffer.

Prototype

void aws_byte_buf_clean_up_secure(struct aws_byte_buf *buf);

aws_byte_buf_eq(a, b)

Compare two aws_byte_buf structures. Return whether their contents are equivalent.

Prototype

bool aws_byte_buf_eq(const struct aws_byte_buf *const a, const struct aws_byte_buf *const b);

aws_byte_buf_eq_c_str(buf, c_str)

Compare an aws_byte_buf and a null-terminated string. Returns true if their contents are equivalent. The buffer should NOT contain a null-terminator, or the comparison will always return false.

Prototype

bool aws_byte_buf_eq_c_str(const struct aws_byte_buf *const buf, const char *const c_str);

aws_byte_buf_eq_c_str_ignore_case(buf, c_str)

Perform a case-insensitive string comparison of an aws_byte_buf and a null-terminated string. Return whether their contents are equivalent. The buffer should NOT contain a null-terminator, or the comparison will always return false. The "C" locale is used for comparing upper and lowercase letters. Data is assumed to be ASCII text, UTF-8 will work fine too.

Prototype

bool aws_byte_buf_eq_c_str_ignore_case(const struct aws_byte_buf *const buf, const char *const c_str);

aws_byte_buf_eq_ignore_case(a, b)

Perform a case-insensitive string comparison of two aws_byte_buf structures. Return whether their contents are equivalent. The "C" locale is used for comparing upper and lowercase letters. Data is assumed to be ASCII text, UTF-8 will work fine too.

Prototype

bool aws_byte_buf_eq_ignore_case(const struct aws_byte_buf *const a, const struct aws_byte_buf *const b);

aws_byte_buf_from_array(bytes, len)

Documentation not found.

Prototype

struct aws_byte_buf aws_byte_buf_from_array(const void *bytes, size_t len);

aws_byte_buf_from_c_str(c_str)

For creating a byte buffer from a null-terminated string literal.

Prototype

struct aws_byte_buf aws_byte_buf_from_c_str(const char *c_str);

aws_byte_buf_from_empty_array(bytes, capacity)

Documentation not found.

Prototype

struct aws_byte_buf aws_byte_buf_from_empty_array(const void *bytes, size_t capacity);

aws_byte_buf_init(buf, allocator, capacity)

Documentation not found.

Prototype

int aws_byte_buf_init(struct aws_byte_buf *buf, struct aws_allocator *allocator, size_t capacity);

aws_byte_buf_init_copy(dest, allocator, src)

Initializes an aws_byte_buf structure base on another valid one. Requires: *src and *allocator are valid objects. Ensures: *dest is a valid aws_byte_buf with a new backing array dest->buffer which is a copy of the elements from src->buffer.

Prototype

int aws_byte_buf_init_copy( struct aws_byte_buf *dest, struct aws_allocator *allocator, const struct aws_byte_buf *src);

aws_byte_buf_init_copy_from_cursor(dest, allocator, src)

Copies src buffer into dest and sets the correct len and capacity. A new memory zone is allocated for dest->buffer. When dest is no longer needed it will have to be cleaned-up using aws_byte_buf_clean_up(dest). Dest capacity and len will be equal to the src len. Allocator of the dest will be identical with parameter allocator. If src buffer is null the dest will have a null buffer with a len and a capacity of 0 Returns AWS_OP_SUCCESS in case of success or AWS_OP_ERR when memory can't be allocated.

Prototype

int aws_byte_buf_init_copy_from_cursor( struct aws_byte_buf *dest, struct aws_allocator *allocator, struct aws_byte_cursor src);

aws_byte_buf_init_from_file(out_buf, alloc, filename)

Reads 'filename' into 'out_buf'. If successful, 'out_buf' is allocated and filled with the data; It is your responsibility to call 'aws_byte_buf_clean_up()' on it. Otherwise, 'out_buf' remains unused. In the very unfortunate case where some API needs to treat out_buf as a c_string, a null terminator is appended, but is not included as part of the length field.

Prototype

int aws_byte_buf_init_from_file(struct aws_byte_buf *out_buf, struct aws_allocator *alloc, const char *filename);

aws_byte_buf_init_from_file_with_size_hint(out_buf, alloc, filename, size_hint)

Same as aws_byte_buf_init_from_file(), but for reading "special files" like /proc/cpuinfo. These files don't accurately report their size, so size_hint is used as initial buffer size, and the buffer grows until the while file is read.

Prototype

int aws_byte_buf_init_from_file_with_size_hint( struct aws_byte_buf *out_buf, struct aws_allocator *alloc, const char *filename, size_t size_hint);

aws_byte_buf_is_valid(buf)

Evaluates the set of properties that define the shape of all valid aws_byte_buf structures. It is also a cheap check, in the sense it run in constant time (i.e., no loops or recursion).

Prototype

bool aws_byte_buf_is_valid(const struct aws_byte_buf *const buf);

aws_byte_buf_reserve(buffer, requested_capacity)

Attempts to increase the capacity of a buffer to the requested capacity

If the the buffer's capacity is currently larger than the request capacity, the function does nothing (no shrink is performed).

Prototype

int aws_byte_buf_reserve(struct aws_byte_buf *buffer, size_t requested_capacity);

aws_byte_buf_reserve_relative(buffer, additional_length)

Convenience function that attempts to increase the capacity of a buffer relative to the current length.

aws_byte_buf_reserve_relative(buf, x) ~~ aws_byte_buf_reserve(buf, buf->len + x)

Prototype

int aws_byte_buf_reserve_relative(struct aws_byte_buf *buffer, size_t additional_length);

aws_byte_buf_reset(buf, zero_contents)

Resets the len of the buffer to 0, but does not free the memory. The buffer can then be reused. Optionally zeroes the contents, if the "zero_contents" flag is true.

Prototype

void aws_byte_buf_reset(struct aws_byte_buf *buf, bool zero_contents);

aws_byte_buf_secure_zero(buf)

Sets all bytes of buffer to zero and resets len to zero.

Prototype

void aws_byte_buf_secure_zero(struct aws_byte_buf *buf);

aws_byte_buf_write(buf, src, len)

Write specified number of bytes from array to byte buffer.

On success, returns true and updates the buffer length accordingly. If there is insufficient space in the buffer, returns false, leaving the buffer unchanged.

Prototype

bool aws_byte_buf_write( struct aws_byte_buf *AWS_RESTRICT buf, const uint8_t *AWS_RESTRICT src, size_t len);

aws_byte_buf_write_be16(buf, x)

Writes a 16-bit integer in network byte order (big endian) to buffer.

On success, returns true and updates the buffer /length accordingly. If there is insufficient space in the buffer, returns false, leaving the buffer unchanged.

Prototype

bool aws_byte_buf_write_be16(struct aws_byte_buf *buf, uint16_t x);

aws_byte_buf_write_be24(buf, x)

Writes low 24-bits (3 bytes) of an unsigned integer in network byte order (big endian) to buffer. Ex: If x is 0x00AABBCC then {0xAA, 0xBB, 0xCC} is written to buffer.

On success, returns true and updates the buffer /length accordingly. If there is insufficient space in the buffer, or x's value cannot fit in 3 bytes, returns false, leaving the buffer unchanged.

Prototype

bool aws_byte_buf_write_be24(struct aws_byte_buf *buf, uint32_t x);

aws_byte_buf_write_be32(buf, x)

Writes a 32-bit integer in network byte order (big endian) to buffer.

On success, returns true and updates the buffer /length accordingly. If there is insufficient space in the buffer, returns false, leaving the buffer unchanged.

Prototype

bool aws_byte_buf_write_be32(struct aws_byte_buf *buf, uint32_t x);

aws_byte_buf_write_be64(buf, x)

Writes a 64-bit integer in network byte order (big endian) to buffer.

On success, returns true and updates the buffer /length accordingly. If there is insufficient space in the buffer, returns false, leaving the buffer unchanged.

Prototype

bool aws_byte_buf_write_be64(struct aws_byte_buf *buf, uint64_t x);

aws_byte_buf_write_float_be32(buf, x)

Writes a 32-bit float in network byte order (big endian) to buffer.

On success, returns true and updates the buffer /length accordingly. If there is insufficient space in the buffer, returns false, leaving the buffer unchanged.

Prototype

bool aws_byte_buf_write_float_be32(struct aws_byte_buf *buf, float x);

aws_byte_buf_write_float_be64(buf, x)

Writes a 64-bit float in network byte order (big endian) to buffer.

On success, returns true and updates the buffer /length accordingly. If there is insufficient space in the buffer, returns false, leaving the buffer unchanged.

Prototype

bool aws_byte_buf_write_float_be64(struct aws_byte_buf *buf, double x);

aws_byte_buf_write_from_whole_buffer(buf, src)

Copies all bytes from buffer to buffer.

On success, returns true and updates the buffer /length accordingly. If there is insufficient space in the buffer, returns false, leaving the buffer unchanged.

Prototype

bool aws_byte_buf_write_from_whole_buffer( struct aws_byte_buf *AWS_RESTRICT buf, struct aws_byte_buf src);

aws_byte_buf_write_from_whole_cursor(buf, src)

Copies all bytes from buffer to buffer.

On success, returns true and updates the buffer /length accordingly. If there is insufficient space in the buffer, returns false, leaving the buffer unchanged.

Prototype

bool aws_byte_buf_write_from_whole_cursor( struct aws_byte_buf *AWS_RESTRICT buf, struct aws_byte_cursor src);

aws_byte_buf_write_from_whole_string(buf, src)

Copies all bytes from string to buf.

On success, returns true and updates the buf pointer/length accordingly. If there is insufficient space in the buf, returns false, leaving the buf unchanged.

Prototype

bool aws_byte_buf_write_from_whole_string( struct aws_byte_buf *AWS_RESTRICT buf, const struct aws_string *AWS_RESTRICT src);

aws_byte_buf_write_to_capacity(buf, advancing_cursor)

Without increasing buf's capacity, write as much as possible from advancing_cursor into buf.

buf's len is updated accordingly. advancing_cursor is advanced so it contains the remaining unwritten parts. Returns the section of advancing_cursor which was written.

This function cannot fail. If buf is full (len == capacity) or advancing_len has 0 length, then buf and advancing_cursor are not altered and a cursor with 0 length is returned.

Example: Given a buf with 2 bytes of space available and advancing_cursor with contents "abc". "ab" will be written to buf and buf->len will increase 2 and become equal to buf->capacity. advancing_cursor will advance so its contents become the unwritten "c". The returned cursor's contents will be the "ab" from the original advancing_cursor.

Prototype

struct aws_byte_cursor aws_byte_buf_write_to_capacity( struct aws_byte_buf *buf, struct aws_byte_cursor *advancing_cursor);

aws_byte_buf_write_u8(buf, c)

Copies one byte to buffer.

On success, returns true and updates the cursor /length accordingly.

If there is insufficient space in the buffer, returns false, leaving the buffer unchanged.

Prototype

bool aws_byte_buf_write_u8(struct aws_byte_buf *AWS_RESTRICT buf, uint8_t c);

aws_byte_buf_write_u8_n(buf, c, count)

Writes one byte repeatedly to buffer (like memset)

If there is insufficient space in the buffer, returns false, leaving the buffer unchanged.

Prototype

bool aws_byte_buf_write_u8_n(struct aws_byte_buf *buf, uint8_t c, size_t count);

aws_byte_cursor_advance(cursor, len)

Tests if the given aws_byte_cursor has at least len bytes remaining. If so, *buf is advanced by len bytes (incrementing ->ptr and decrementing ->len), and an aws_byte_cursor referring to the first len bytes of the original *buf is returned. Otherwise, an aws_byte_cursor with ->ptr = NULL, ->len = 0 is returned.

Note that if len is above (SIZE_MAX / 2), this function will also treat it as a buffer overflow, and return NULL without changing *buf.

Prototype

struct aws_byte_cursor aws_byte_cursor_advance(struct aws_byte_cursor *const cursor, const size_t len);

aws_byte_cursor_advance_nospec(cursor, len)

Behaves identically to aws_byte_cursor_advance, but avoids speculative execution potentially reading out-of-bounds pointers (by returning an empty ptr in such speculated paths).

This should generally be done when using an untrusted or data-dependent value for 'len', to avoid speculating into a path where cursor->ptr points outside the true ptr length.

Prototype

struct aws_byte_cursor aws_byte_cursor_advance_nospec(struct aws_byte_cursor *const cursor, size_t len);

aws_byte_cursor_compare_lexical(lhs, rhs)

Lexical (byte value) comparison of two byte cursors

Prototype

int aws_byte_cursor_compare_lexical(const struct aws_byte_cursor *lhs, const struct aws_byte_cursor *rhs);

aws_byte_cursor_compare_lookup(lhs, rhs, lookup_table)

Lexical (byte value) comparison of two byte cursors where the raw values are sent through a lookup table first

Prototype

int aws_byte_cursor_compare_lookup( const struct aws_byte_cursor *lhs, const struct aws_byte_cursor *rhs, const uint8_t *lookup_table);

aws_byte_cursor_eq(a, b)

Compare two aws_byte_cursor structures. Return whether their contents are equivalent.

Prototype

bool aws_byte_cursor_eq(const struct aws_byte_cursor *a, const struct aws_byte_cursor *b);

aws_byte_cursor_eq_byte_buf(a, b)

Compare an aws_byte_cursor and an aws_byte_buf. Return whether their contents are equivalent.

Prototype

bool aws_byte_cursor_eq_byte_buf(const struct aws_byte_cursor *const a, const struct aws_byte_buf *const b);

aws_byte_cursor_eq_byte_buf_ignore_case(a, b)

Perform a case-insensitive string comparison of an aws_byte_cursor and an aws_byte_buf. Return whether their contents are equivalent. The "C" locale is used for comparing upper and lowercase letters. Data is assumed to be ASCII text, UTF-8 will work fine too.

Prototype

bool aws_byte_cursor_eq_byte_buf_ignore_case(const struct aws_byte_cursor *const a, const struct aws_byte_buf *const b);

aws_byte_cursor_eq_c_str(cursor, c_str)

Compare an aws_byte_cursor and a null-terminated string. Returns true if their contents are equivalent. The cursor should NOT contain a null-terminator, or the comparison will always return false.

Prototype

bool aws_byte_cursor_eq_c_str(const struct aws_byte_cursor *const cursor, const char *const c_str);

aws_byte_cursor_eq_c_str_ignore_case(cursor, c_str)

Perform a case-insensitive string comparison of an aws_byte_cursor and a null-terminated string. Return whether their contents are equivalent. The cursor should NOT contain a null-terminator, or the comparison will always return false. The "C" locale is used for comparing upper and lowercase letters. Data is assumed to be ASCII text, UTF-8 will work fine too.

Prototype

bool aws_byte_cursor_eq_c_str_ignore_case(const struct aws_byte_cursor *const cursor, const char *const c_str);

aws_byte_cursor_eq_ignore_case(a, b)

Perform a case-insensitive string comparison of two aws_byte_cursor structures. Return whether their contents are equivalent. The "C" locale is used for comparing upper and lowercase letters. Data is assumed to be ASCII text, UTF-8 will work fine too.

Prototype

bool aws_byte_cursor_eq_ignore_case(const struct aws_byte_cursor *a, const struct aws_byte_cursor *b);

aws_byte_cursor_find_exact(input_str, to_find, first_find)

Search for an exact byte match inside a cursor. The first match will be returned. Returns AWS_OP_SUCCESS on successful match and first_find will be set to the offset in input_str, and length will be the remaining length from input_str past the returned offset. If the match was not found, AWS_OP_ERR will be returned and AWS_ERROR_STRING_MATCH_NOT_FOUND will be raised.

Prototype

int aws_byte_cursor_find_exact( const struct aws_byte_cursor *AWS_RESTRICT input_str, const struct aws_byte_cursor *AWS_RESTRICT to_find, struct aws_byte_cursor *first_find);

aws_byte_cursor_from_array(bytes, len)

Documentation not found.

Prototype

struct aws_byte_cursor aws_byte_cursor_from_array(const void *const bytes, const size_t len);

aws_byte_cursor_from_buf(buf)

Documentation not found.

Prototype

struct aws_byte_cursor aws_byte_cursor_from_buf(const struct aws_byte_buf *const buf);

aws_byte_cursor_from_c_str(c_str)

Documentation not found.

Prototype

struct aws_byte_cursor aws_byte_cursor_from_c_str(const char *c_str);

aws_byte_cursor_from_string(src)

Creates an aws_byte_cursor from an existing string.

Prototype

struct aws_byte_cursor aws_byte_cursor_from_string(const struct aws_string *src);

aws_byte_cursor_is_valid(cursor)

Evaluates the set of properties that define the shape of all valid aws_byte_cursor structures. It is also a cheap check, in the sense it runs in constant time (i.e., no loops or recursion).

Prototype

bool aws_byte_cursor_is_valid(const struct aws_byte_cursor *cursor);

aws_byte_cursor_left_trim_pred(source, predicate)

Shrinks a byte cursor from the left for as long as the supplied predicate is true

Prototype

struct aws_byte_cursor aws_byte_cursor_left_trim_pred( const struct aws_byte_cursor *source, aws_byte_predicate_fn *predicate);

aws_byte_cursor_next_split(input_str, split_on, substr)

No copies, no buffer allocations. Iterates over input_str, and returns the next substring between split_on instances relative to previous substr. Behaves similar to strtok with substr being used as state for next split.

Returns true each time substr is set and false when there is no more splits (substr is set to empty in that case).

Example usage. struct aws_byte_cursor substr = {0}; while (aws_byte_cursor_next_split(&input_str, ';', &substr)) { // ...use substr... }

Note: It is the user's responsibility zero-initialize substr before the first call.

Edge case rules are as follows: empty input will have single empty split. ex. "" splits into "" if input starts with split_on then first split is empty. ex ";A" splits into "", "A" adjacent split tokens result in empty split. ex "A;;B" splits into "A", "", "B" If the input ends with split_on, last split is empty. ex. "A;" splits into "A", ""

It is the user's responsibility to make sure the input buffer stays in memory long enough to use the results.

Prototype

bool aws_byte_cursor_next_split( const struct aws_byte_cursor *AWS_RESTRICT input_str, char split_on, struct aws_byte_cursor *AWS_RESTRICT substr);

aws_byte_cursor_read(cur, dest, len)

Reads specified length of data from byte cursor and copies it to the destination array.

On success, returns true and updates the cursor pointer/length accordingly. If there is insufficient space in the cursor, returns false, leaving the cursor unchanged.

Prototype

bool aws_byte_cursor_read( struct aws_byte_cursor *AWS_RESTRICT cur, void *AWS_RESTRICT dest, const size_t len);

aws_byte_cursor_read_and_fill_buffer(cur, dest)

Reads as many bytes from cursor as size of buffer, and copies them to buffer.

On success, returns true and updates the cursor pointer/length accordingly. If there is insufficient space in the cursor, returns false, leaving the cursor unchanged.

Prototype

bool aws_byte_cursor_read_and_fill_buffer( struct aws_byte_cursor *AWS_RESTRICT cur, struct aws_byte_buf *AWS_RESTRICT dest);

aws_byte_cursor_read_be16(cur, var)

Reads a 16-bit value in network byte order from cur, and places it in host byte order into var.

On success, returns true and updates the cursor pointer/length accordingly. If there is insufficient space in the cursor, returns false, leaving the cursor unchanged.

Prototype

bool aws_byte_cursor_read_be16(struct aws_byte_cursor *cur, uint16_t *var);

aws_byte_cursor_read_be24(cur, var)

Reads an unsigned 24-bit value (3 bytes) in network byte order from cur, and places it in host byte order into 32-bit var. Ex: if cur's next 3 bytes are {0xAA, 0xBB, 0xCC}, then var becomes 0x00AABBCC.

On success, returns true and updates the cursor pointer/length accordingly. If there is insufficient space in the cursor, returns false, leaving the cursor unchanged.

Prototype

bool aws_byte_cursor_read_be24(struct aws_byte_cursor *cur, uint32_t *var);

aws_byte_cursor_read_be32(cur, var)

Reads a 32-bit value in network byte order from cur, and places it in host byte order into var.

On success, returns true and updates the cursor pointer/length accordingly. If there is insufficient space in the cursor, returns false, leaving the cursor unchanged.

Prototype

bool aws_byte_cursor_read_be32(struct aws_byte_cursor *cur, uint32_t *var);

aws_byte_cursor_read_be64(cur, var)

Reads a 64-bit value in network byte order from cur, and places it in host byte order into var.

On success, returns true and updates the cursor pointer/length accordingly. If there is insufficient space in the cursor, returns false, leaving the cursor unchanged.

Prototype

bool aws_byte_cursor_read_be64(struct aws_byte_cursor *cur, uint64_t *var);

aws_byte_cursor_read_float_be32(cur, var)

Reads a 32-bit value in network byte order from cur, and places it in host byte order into var.

On success, returns true and updates the cursor pointer/length accordingly. If there is insufficient space in the cursor, returns false, leaving the cursor unchanged.

Prototype

bool aws_byte_cursor_read_float_be32(struct aws_byte_cursor *cur, float *var);

aws_byte_cursor_read_float_be64(cur, var)

Reads a 64-bit value in network byte order from cur, and places it in host byte order into var.

On success, returns true and updates the cursor pointer/length accordingly. If there is insufficient space in the cursor, returns false, leaving the cursor unchanged.

Prototype

bool aws_byte_cursor_read_float_be64(struct aws_byte_cursor *cur, double *var);

aws_byte_cursor_read_hex_u8(cur, var)

Reads 2 hex characters from ASCII/UTF-8 text to produce an 8-bit number. Accepts both lowercase 'a'-'f' and uppercase 'A'-'F'. For example: "0F" produces 15.

On success, returns true and advances the cursor by 2. If there is insufficient space in the cursor or an invalid character is encountered, returns false, leaving the cursor unchanged.

Prototype

bool aws_byte_cursor_read_hex_u8(struct aws_byte_cursor *cur, uint8_t *var);

aws_byte_cursor_read_u8(cur, var)

Reads a single byte from cursor, placing it in *var.

On success, returns true and updates the cursor pointer/length accordingly. If there is insufficient space in the cursor, returns false, leaving the cursor unchanged.

Prototype

bool aws_byte_cursor_read_u8(struct aws_byte_cursor *AWS_RESTRICT cur, uint8_t *AWS_RESTRICT var);

aws_byte_cursor_right_trim_pred(source, predicate)

Shrinks a byte cursor from the right for as long as the supplied predicate is true

Prototype

struct aws_byte_cursor aws_byte_cursor_right_trim_pred( const struct aws_byte_cursor *source, aws_byte_predicate_fn *predicate);

aws_byte_cursor_satisfies_pred(source, predicate)

Returns true if the byte cursor's range of bytes all satisfy the predicate

Prototype

bool aws_byte_cursor_satisfies_pred(const struct aws_byte_cursor *source, aws_byte_predicate_fn *predicate);

aws_byte_cursor_split_on_char(input_str, split_on, output)

No copies, no buffer allocations. Fills in output with a list of aws_byte_cursor instances where buffer is an offset into the input_str and len is the length of that string in the original buffer.

Edge case rules are as follows: if the input begins with split_on, an empty cursor will be the first entry in output. if the input has two adjacent split_on tokens, an empty cursor will be inserted into the output. if the input ends with split_on, an empty cursor will be appended to the output.

It is the user's responsibility to properly initialize output. Recommended number of preallocated elements from output is your most likely guess for the upper bound of the number of elements resulting from the split.

The type that will be stored in output is struct aws_byte_cursor (you'll need this for the item size param).

It is the user's responsibility to make sure the input buffer stays in memory long enough to use the results.

Prototype

int aws_byte_cursor_split_on_char( const struct aws_byte_cursor *AWS_RESTRICT input_str, char split_on, struct aws_array_list *AWS_RESTRICT output);

aws_byte_cursor_split_on_char_n(input_str, split_on, n, output)

No copies, no buffer allocations. Fills in output with a list of aws_byte_cursor instances where buffer is an offset into the input_str and len is the length of that string in the original buffer. N is the max number of splits, if this value is zero, it will add all splits to the output.

Edge case rules are as follows: if the input begins with split_on, an empty cursor will be the first entry in output if the input has two adjacent split_on tokens, an empty cursor will be inserted into the output. if the input ends with split_on, an empty cursor will be appended to the output.

It is the user's responsibility to properly initialize output. Recommended number of preallocated elements from output is your most likely guess for the upper bound of the number of elements resulting from the split.

If the output array is not large enough, input_str will be updated to point to the first character after the last processed split_on instance.

The type that will be stored in output is struct aws_byte_cursor (you'll need this for the item size param).

It is the user's responsibility to make sure the input buffer stays in memory long enough to use the results.

Prototype

int aws_byte_cursor_split_on_char_n( const struct aws_byte_cursor *AWS_RESTRICT input_str, char split_on, size_t n, struct aws_array_list *AWS_RESTRICT output);

aws_byte_cursor_starts_with(input, prefix)

Return true if the input starts with the prefix (exact byte comparison).

Prototype

bool aws_byte_cursor_starts_with(const struct aws_byte_cursor *input, const struct aws_byte_cursor *prefix);

aws_byte_cursor_starts_with_ignore_case(input, prefix)

Return true if the input starts with the prefix (case-insensitive). The "C" locale is used for comparing upper and lowercase letters. Data is assumed to be ASCII text, UTF-8 will work fine too.

Prototype

bool aws_byte_cursor_starts_with_ignore_case(const struct aws_byte_cursor *input, const struct aws_byte_cursor *prefix);

aws_byte_cursor_trim_pred(source, predicate)

Shrinks a byte cursor from both sides for as long as the supplied predicate is true

Prototype

struct aws_byte_cursor aws_byte_cursor_trim_pred( const struct aws_byte_cursor *source, aws_byte_predicate_fn *predicate);

aws_byte_cursor_utf8_parse_u64(cursor, dst)

Read entire cursor as ASCII/UTF-8 unsigned base-10 number. Stricter than strtoull(), which allows whitespace and inputs that start with "0x"

Examples: "0" -> 0 "123" -> 123 "00004" -> 4 // leading zeros ok

Rejects things like: "-1" // negative numbers not allowed "1,000" // only characters 0-9 allowed "" // blank string not allowed " 0 " // whitespace not allowed "0x0" // hex not allowed "FF" // hex not allowed "999999999999999999999999999999999999999999" // larger than max u64

Prototype

int aws_byte_cursor_utf8_parse_u64(struct aws_byte_cursor cursor, uint64_t *dst);

aws_byte_cursor_utf8_parse_u64_hex(cursor, dst)

Read entire cursor as ASCII/UTF-8 unsigned base-16 number with NO "0x" prefix.

Examples: "F" -> 15 "000000ff" -> 255 // leading zeros ok "Ff" -> 255 // mixed case ok "123" -> 291 "FFFFFFFFFFFFFFFF" -> 18446744073709551616 // max u64

Rejects things like: "0x0" // 0x prefix not allowed "" // blank string not allowed " F " // whitespace not allowed "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" // larger than max u64

Prototype

int aws_byte_cursor_utf8_parse_u64_hex(struct aws_byte_cursor cursor, uint64_t *dst);

aws_c_string_is_valid(str)

Best-effort checks aws_string invariants, when the str->len is unknown

Prototype

AWS_STATIC_IMPL bool aws_c_string_is_valid(const char *str);

aws_cache_base_default_clear(cache)

Documentation not found.

Prototype

void aws_cache_base_default_clear(struct aws_cache *cache);

aws_cache_base_default_destroy(cache)

Default implementations

Prototype

void aws_cache_base_default_destroy(struct aws_cache *cache);

aws_cache_base_default_find(cache, key, p_value)

Documentation not found.

Prototype

int aws_cache_base_default_find(struct aws_cache *cache, const void *key, void **p_value);

aws_cache_base_default_get_element_count(cache)

Documentation not found.

Prototype

size_t aws_cache_base_default_get_element_count(const struct aws_cache *cache);

aws_cache_base_default_remove(cache, key)

Documentation not found.

Prototype

int aws_cache_base_default_remove(struct aws_cache *cache, const void *key);

aws_cache_clear(cache)

Clears all items from the cache.

Prototype

void aws_cache_clear(struct aws_cache *cache);

aws_cache_destroy(cache)

Cleans up the cache. Elements in the cache will be evicted and cleanup callbacks will be invoked.

Prototype

void aws_cache_destroy(struct aws_cache *cache);

aws_cache_find(cache, key, p_value)

Finds element in the cache by key. If found, *p_value will hold the stored value, and AWS_OP_SUCCESS will be returned. If not found, AWS_OP_SUCCESS will be returned and *p_value will be NULL.

If any errors occur AWS_OP_ERR will be returned.

Prototype

int aws_cache_find(struct aws_cache *cache, const void *key, void **p_value);

aws_cache_get_element_count(cache)

Returns the number of elements in the cache.

Prototype

size_t aws_cache_get_element_count(const struct aws_cache *cache);

aws_cache_new_fifo(allocator, hash_fn, equals_fn, destroy_key_fn, destroy_value_fn, max_items)

Initializes the first-in-first-out cache. Sets up the underlying linked hash table. Once max_items elements have been added, the oldest(first-in) item will be removed. For the other parameters, see aws/common/hash_table.h. Hash table semantics of these arguments are preserved.

Prototype

struct aws_cache *aws_cache_new_fifo( struct aws_allocator *allocator, aws_hash_fn *hash_fn, aws_hash_callback_eq_fn *equals_fn, aws_hash_callback_destroy_fn *destroy_key_fn, aws_hash_callback_destroy_fn *destroy_value_fn, size_t max_items);

aws_cache_new_lifo(allocator, hash_fn, equals_fn, destroy_key_fn, destroy_value_fn, max_items)

Initializes the last-in-first-out cache. Sets up the underlying linked hash table. Once max_items elements have been added, the latest(last-in) item will be removed. For the other parameters, see aws/common/hash_table.h. Hash table semantics of these arguments are preserved.

Prototype

struct aws_cache *aws_cache_new_lifo( struct aws_allocator *allocator, aws_hash_fn *hash_fn, aws_hash_callback_eq_fn *equals_fn, aws_hash_callback_destroy_fn *destroy_key_fn, aws_hash_callback_destroy_fn *destroy_value_fn, size_t max_items);