array.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright(c) 2022 Intel Corporation. All rights reserved.
 */
 
#ifndef DSP_FW_FW_ARRAY_H_
#define DSP_FW_FW_ARRAY_H_
 
#include <stdint.h>
#include <stddef.h>
 
#include <rtos/panic.h>
 
#ifdef __cplusplus
extern "C" {
#endif

typedef struct byte_array {
    uint8_t    *data;
    size_t      size;
} byte_array_t;
 
static inline uint8_t *array_get_data(const byte_array_t *ba)
{
    return (uint8_t *)ba->data;
}
 
static inline uint8_t *array_get_data_end(const byte_array_t *ba)
{
    return array_get_data(ba) + ba->size;
}
 
 
static inline size_t array_get_size(const byte_array_t *ba)
{
    return ba->size;
}
 
static inline uint8_t *array_alloc_from(byte_array_t *ba,
                    size_t required_size)
{
    /* TODO: add alignment */
    /* TODO: validate inputs */
    /* TODO: move this to more appropriate file */
 
    uint8_t *cached_data = array_get_data(ba);
 
    ba->data += required_size;
    ba->size -= required_size;
 
    return cached_data;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#ifdef __cplusplus
 
static inline uint8_t *array_get_data(const byte_array_t &ba)
{
    return (uint8_t *)ba.data;
}
 
static inline size_t array_get_size(const byte_array_t &ba)
{
    return ba.size;
}
 
namespace dsp_fw
{
template < class T >
class Array /*: public byte_array*/
{
public:

Array()
{
    data_ = NULL;
    size_ = 0;
}

Array(T * ptr, size_t size)
{
    data_ = (T *)ptr;
    size_ = size;
}

void Init(T *ptr, size_t size)
{
    data_ = (T *)ptr;
    size_ = size;
}

void InitWithRange(T *ptr, T *ptr_end)
{
    assert(ptr_end >= ptr);
    data_ = (T *)ptr;
    size_ = ptr_end - ptr;
}

void Detach(void) { data_ = NULL; size_ = 0; }
size_t size(void) const { return size_; }
size_t alloc_size(void) const { return size()*sizeof(T); }
void Resize(size_t new_size) { size_ = new_size; }
const T *data(void) const { return (const T *)data_; }
T *data(void) { return (T *)data_; }
const T *data_end(void) const { return data() + size_; }
T *data_end(void) { return data() + size_; }
const T & operator[](size_t idx) const {
    /*assert(idx < size()); //TODO: no exceptions, release err handling req */
    return data()[idx];
}

T & operator[](size_t idx) {
    /*assert(idx < size()); //TODO: no exceptions, release err handling req */
    return data()[idx];
}

void copyFrom(const T *src, size_t srcSize, size_t dst_offset = 0)
{
    assert(data() != NULL);
    assert(size() > dst_offset);
    assert((size() - dst_offset) >= srcSize);
    memcpy_s(data() + dst_offset, alloc_size() - dst_offset * sizeof(T),
        src, srcSize * sizeof(T));
}

void copyFrom(const Array < T > &src, size_t dst_offset = 0)
{
    assert(data() != 0);
    assert(size() > dst_offset);
    assert((size() - dst_offset) >= src.size());
    memcpy_s(data() + dst_offset, alloc_size() - dst_offset * sizeof(T),
        src.data(), src.alloc_size());
}

void copyTo(T *dst, size_t dstSize) const {
    assert(data() != 0);
    assert(size() <= dstSize);
    memcpy_s(dst, dstSize * sizeof(T), data(), alloc_size());
}

void copyTo(Array < T > &dst) const {
    assert(data() != 0);
    assert(size() <= dst.size());
    memcpy_s(dst.data(), dst.alloc_size(), data(), alloc_size());
}

void copyFragmentTo(Array < T > &dst, size_t copy_size, size_t src_offset = 0) const {
    assert(data() != 0);
    assert((src_offset + copy_size) <= size());
    assert(copy_size <= dst.size());
    memcpy_s(dst.data(), dst.alloc_size(), data() + src_offset, copy_size * sizeof(T));
}

template < class TC >
TC *dataAs(void)
{
    if (alloc_size() < sizeof(TC)) {
        assert(false);
        return NULL;
    }
    return reinterpret_cast < TC * > (data());
}
 
template < class TC >
TC *dataAsArray(size_t size)
{
    if (alloc_size() < sizeof(TC)*size) {
        assert(false);
        return NULL;
    }
    return reinterpret_cast < TC * > (data());
}

template < class TC >
const TC *dataAs(void) const {
    if (alloc_size() < sizeof(TC)) {
        assert(false);
        return NULL;
    }
    return reinterpret_cast < const TC * > (data());
}

template < class TC >
void setDataAs(const TC & d)
{
    TC *t = dataAs < TC > ();
 
    if (t == NULL) {
        assert(false);
        return;
    }
    *t = d; /* using operator=, not shallow copy */
    Resize(sizeof(TC));
}

void clear(void)
{
    memset(data(), 0x00, alloc_size());
}
 
void Swap(Array < T > *array)
{
    Array < T > temp(*array);
    array->data_ = data_;
    array->size_ = size_;
    this->data_ = temp.data_;
    this->size_ = temp.size_;
}
 
void Swap(Array < T > &array)
{
    Array < T > temp(array);
    array.data_ = data_;
    array.size_ = size_;
    this->data_ = temp.data_;
    this->size_ = temp.size_;
}
private:
    T *data_;
    size_t size_;
};

typedef Array < uint8_t > ByteArray;

typedef Array < uint32_t > DwordArray;
 
} /* end of namespace dsp_fw */
 
#endif /* __cplusplus */
/* clang-format on */
#endif /* #ifndef DSP_FW_FW_ARRAY_H_ */