erpc_message_buffer.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2016, Freescale Semiconductor, Inc.
 * Copyright 2016 NXP
 * All rights reserved.
 *
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#ifndef _EMBEDDED_RPC__MESSAGE_BUFFER_H_
#define _EMBEDDED_RPC__MESSAGE_BUFFER_H_

#include "erpc_common.h"

#include <cstddef>
#include <stdint.h>

// Classes

namespace erpc {
class MessageBuffer
{
public:
    MessageBuffer(void) : m_buf(NULL), m_len(0), m_used(0) {}

    MessageBuffer(uint8_t *buffer, uint16_t length) : m_buf(buffer), m_len(length), m_used(0) {}

    MessageBuffer(const MessageBuffer &buffer);

    void set(uint8_t *buffer, uint16_t length)
    {
        m_buf = buffer;
        m_len = length;
        m_used = 0;
    }

    uint8_t *get(void) { return m_buf; }

    const uint8_t *get(void) const { return m_buf; }

    uint16_t getLength(void) const { return m_len; }

    uint16_t getUsed(void) const { return m_used; }

    uint16_t getFree(void) const { return m_len - m_used; }

    void setUsed(uint16_t used);

    erpc_status_t read(uint16_t offset, void *data, uint32_t length);

    erpc_status_t write(uint16_t offset, const void *data, uint32_t length);

    erpc_status_t copy(const MessageBuffer *other);

    void swap(MessageBuffer *other);

    operator uint8_t *(void) { return m_buf; }

    operator const uint8_t *(void) const { return m_buf; }

    uint8_t &operator[](int index) { return m_buf[index]; }

    const uint8_t &operator[](int index) const { return m_buf[index]; }

private:
    uint8_t *volatile m_buf;  
    uint16_t volatile m_len;  
    uint16_t volatile m_used; 
};

class Cursor
{
public:
    Cursor(void) : m_buffer(), m_pos(NULL) {}

    explicit Cursor(MessageBuffer &buffer) : m_buffer(buffer), m_pos(buffer.get()) {}

    void setBuffer(MessageBuffer &buffer, uint8_t reserved = 0);

    MessageBuffer getBuffer(void);

    MessageBuffer &getBufferRef(void);

    uint8_t *get(void) { return m_pos; }

    const uint8_t *get(void) const { return m_pos; }

    uint16_t getRemaining(void) const { return m_buffer.getLength() - (uint16_t)(m_pos - m_buffer.get()); }

    uint16_t getRemainingUsed(void) const { return m_buffer.getUsed() - (uint16_t)(m_pos - m_buffer.get()); }

    erpc_status_t read(void *data, uint32_t length);

    erpc_status_t write(const void *data, uint32_t length);

    operator uint8_t *(void) { return m_pos; }

    operator const uint8_t *(void) const { return m_pos; }

    uint8_t &operator[](int index);

    const uint8_t &operator[](int index) const;

    Cursor &operator+=(uint16_t n);

    Cursor &operator-=(uint16_t n);

    Cursor &operator++(void);

    Cursor &operator--(void);

private:
    MessageBuffer m_buffer; 
    uint8_t *m_pos;         
};

class MessageBufferFactory
{
public:
    MessageBufferFactory(void);

    virtual ~MessageBufferFactory(void);

    virtual MessageBuffer create(void) = 0;

    MessageBuffer create(uint8_t reserveHeaderSize);

    virtual bool createServerBuffer(void);

    virtual erpc_status_t prepareServerBufferForSend(MessageBuffer &message, uint8_t reserveHeaderSize = 0);

    virtual void dispose(MessageBuffer *buf) = 0;
};

} // namespace erpc

#endif // _EMBEDDED_RPC__MESSAGE_BUFFER_H_