ra8_mdl_storage_ram.c

Go to the documentation of this file.

 
#include "ra8_mdl_storage_ram.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"

RA8_INTERNAL static ra8_err_t internal_ram_begin(void* context, const char* destination)
{
  if ((context == nullptr) || (destination == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  ra8_mdl_storage_ram_t* storage = context;
  if (destination[0] == '\0') {
    return k_ra8_err_invalid_arg;
  }
  if (storage->active) {
    return k_ra8_err_invalid_state;
  }
  storage->length    = 0U;
  storage->committed = false;
  storage->active    = true;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_ram_write(void* context, const uint8_t* data, uint16_t length, uint16_t* written)
{
  if ((context == nullptr) || (written == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *written = 0U;
  if ((data == nullptr) && (length != 0U)) {
    return k_ra8_err_null_ptr;
  }
  ra8_mdl_storage_ram_t* storage = context;
  if (!storage->active) {
    return k_ra8_err_invalid_state;
  }
  if ((size_t)length > (storage->capacity - storage->length)) {
    return k_ra8_err_no_mem;
  }
  if (length != 0U) {
    (void)memcpy(&storage->data[storage->length], data, length);
  }
  storage->length += length;
  *written = length;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_ram_commit(void* context)
{
  if (context == nullptr) {
    return k_ra8_err_null_ptr;
  }
  ra8_mdl_storage_ram_t* storage = context;
  if ((!storage->active) || (storage->length == 0U)) {
    return k_ra8_err_invalid_state;
  }
  storage->active    = false;
  storage->committed = true;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_ram_abort(void* context)
{
  if (context == nullptr) {
    return k_ra8_err_null_ptr;
  }
  ra8_mdl_storage_ram_t* storage = context;
  if (!storage->active) {
    return k_ra8_err_invalid_state;
  }
  storage->length    = 0U;
  storage->active    = false;
  storage->committed = false;
  return k_ra8_ok;
}
 
/* data cannot be const: it seeds the struct's non-const uint8_t* data
 * field, which internal_ram_write() later writes through. */
ra8_err_t ra8_mdl_storage_ram_init(
  ra8_mdl_storage_ram_t*   storage,
  ra8_mdl_storage_iface_t* output,
  // NOLINTNEXTLINE(readability-non-const-parameter) -- interface contract fixes this writable pointer type.
  uint8_t* data,
  size_t   capacity)
{
  if ((storage == nullptr) || (output == nullptr) || (data == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (capacity == 0U) {
    return k_ra8_err_invalid_size;
  }
  *storage = (ra8_mdl_storage_ram_t){.data = data, .capacity = capacity};
  *output  = (ra8_mdl_storage_iface_t){.begin    = internal_ram_begin,
                                       .write    = internal_ram_write,
                                       .validate = nullptr,
                                       .commit   = internal_ram_commit,
                                       .abort    = internal_ram_abort,
                                       .ctx      = storage};
  return k_ra8_ok;
}
 
ra8_err_t
ra8_mdl_storage_ram_view(const ra8_mdl_storage_ram_t* storage, const uint8_t** data, size_t* length)
{
  if ((storage == nullptr) || (data == nullptr) || (length == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if ((!storage->committed) || storage->active || (storage->length == 0U)) {
    return k_ra8_err_invalid_state;
  }
  *data   = storage->data;
  *length = storage->length;
  return k_ra8_ok;
}