osmailboxqueue.h

/******************************************************************************
 
    @file    IntrOS: osmailboxqueue.h
    @author  Rajmund Szymanski
    @date    17.11.2025
    @brief   This file contains definitions for IntrOS.
 
 ******************************************************************************
 
   Copyright (c) 2018-2022 Rajmund Szymanski. All rights reserved.
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to
   deal in the Software without restriction, including without limitation the
   rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   sell copies of the Software, and to permit persons to whom the Software is
   furnished to do so, subject to the following conditions:
 
   The above copyright notice and this permission notice shall be included
   in all copies or substantial portions of the Software.
 
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
   IN THE SOFTWARE.
 
 ******************************************************************************/
 
#ifndef __INTROS_BOX_H
#define __INTROS_BOX_H
 
#include "oskernel.h"
#include "osclock.h"


 
typedef struct __box box_t;
 
struct __box
{
    obj_t    obj;   
 
    size_t   count; 
    size_t   limit; 
    size_t   size;  
 
    size_t   head;  
    size_t   tail;  
    char *   data;  
};
 
typedef struct __box box_id [];
 
/******************************************************************************
 *
 * Name              : _BOX_INIT
 *
 * Description       : create and initialize a mailbox queue object
 *
 * Parameters
 *   limit           : size of a queue (max number of stored mails)
 *   size            : size of a single mail (in bytes)
 *   data            : mailbox queue data buffer
 *
 * Return            : mailbox queue object
 *
 * Note              : for internal use
 *
 ******************************************************************************/
 
#define               _BOX_INIT( _limit, _size, _data ) { _OBJ_INIT(), 0, _limit * _size, _size, 0, 0, _data }
 
/******************************************************************************
 *
 * Name              : _BOX_DATA
 *
 * Description       : create a mailbox queue data buffer
 *
 * Parameters
 *   limit           : size of a queue (max number of stored mails)
 *   size            : size of a single mail (in bytes)
 *
 * Return            : mailbox queue data buffer
 *
 * Note              : for internal use
 *
 ******************************************************************************/
 
#ifndef __cplusplus
#define               _BOX_DATA( _limit, _size ) (char[_limit * _size]){ 0 }
#endif

 
#define             OS_BOX_BUFFER( buf, limit, size ) \
                       char buf[limit * size]

 
#define             OS_BOX( box, limit, size )       \
                static char box##__buf[limit * size]; \
                       box_t box[] = { _BOX_INIT( limit, size, box##__buf ) }

/** static alias of OS_BOX() */
#define         static_BOX( box, limit, size )       \
                static char box##__buf[limit * size]; \
                static box_t box[] = { _BOX_INIT( limit, size, box##__buf ) }

 
#ifndef __cplusplus
#define                BOX_INIT( limit, size ) \
                      _BOX_INIT( limit, size, _BOX_DATA( limit, size ) )
#endif

 
#ifndef __cplusplus
#define                BOX_CREATE( limit, size ) \
                     { BOX_INIT  ( limit, size ) }
/** alias of BOX_CREATE() */
#define                BOX_NEW \
                       BOX_CREATE
#endif
 
#ifdef __cplusplus
extern "C" {
#endif

 
void box_init( box_t *box, size_t size, void *data, size_t bufsize );

 
void box_reset( box_t *box );

__STATIC_INLINE
void box_kill( box_t *box ) { box_reset(box); }

 
int box_take( box_t *box, void *data );

__STATIC_INLINE
int box_tryWait( box_t *box, void *data ) { return box_take(box, data); }
 
#if OS_ATOMICS
int box_takeAsync( box_t *box, void *data );
#endif

 
int box_waitFor( box_t *box, void *data, cnt_t delay );

 
int box_waitUntil( box_t *box, void *data, cnt_t time );

 
__STATIC_INLINE
int box_wait( box_t *box, void *data ) { return box_waitFor(box, data, INFINITE); }
 
#if OS_ATOMICS
int box_waitAsync( box_t *box, void *data );
#endif

 
int box_give( box_t *box, const void *data );
 
#if OS_ATOMICS
int box_giveAsync( box_t *box, const void *data );
#endif

 
int box_sendFor( box_t *box, const void *data, cnt_t delay );

 
int box_sendUntil( box_t *box, const void *data, cnt_t time );

 
__STATIC_INLINE
int box_send( box_t *box, const void *data ) { return box_sendFor(box, data, INFINITE); }
 
#if OS_ATOMICS
int box_sendAsync( box_t *box, const void *data );
#endif

 
void box_push( box_t *box, const void *data );

 
unsigned box_count( box_t *box );

 
unsigned box_space( box_t *box );

 
unsigned box_limit( box_t *box );

 
__STATIC_INLINE
size_t box_size( box_t *box ) { return box->size; }
 
#ifdef __cplusplus
}
#endif
 
/* -------------------------------------------------------------------------- */
 
#if defined(__cplusplus)
namespace intros {

 
template<unsigned limit_, size_t size_>
struct MailBoxQueueT : public __box
{
    constexpr
    MailBoxQueueT(): __box _BOX_INIT(limit_, size_, data_) {}
 
    ~MailBoxQueueT() { assert(__box::obj.queue == nullptr); }

    /// move constructor
    MailBoxQueueT( MailBoxQueueT&& _src ): __box _BOX_INIT(limit_, size_, data_)
    {
        assert(_src.__box::count == 0 && _src.obj.queue == nullptr);
        (void) _src;
    }
 
    MailBoxQueueT( const MailBoxQueueT& ) = delete;
    MailBoxQueueT& operator=( MailBoxQueueT&& ) = delete;
    MailBoxQueueT& operator=( const MailBoxQueueT& ) = delete;
 
    void     reset    ()                                     {        box_reset    (this); }                              
    void     kill     ()                                     {        box_kill     (this); }                              
    int      take     (       void *_data )                  { return box_take     (this, _data); }                       
    int      tryWait  (       void *_data )                  { return box_tryWait  (this, _data); }                       
    template<typename T>
    int      waitFor  (       void *_data, const T& _delay ) { return box_waitFor  (this, _data, Clock::count(_delay)); } 
    template<typename T>
    int      waitUntil(       void *_data, const T& _time )  { return box_waitUntil(this, _data, Clock::until(_time)); }  
    int      wait     (       void *_data )                  { return box_wait     (this, _data); }                       
    int      give     ( const void *_data )                  { return box_give     (this, _data); }                       
    template<typename T>
    int      sendFor  ( const void *_data, const T& _delay ) { return box_sendFor  (this, _data, Clock::count(_delay)); } 
    template<typename T>
    int      sendUntil( const void *_data, const T& _time )  { return box_sendUntil(this, _data, Clock::until(_time)); }  
    int      send     ( const void *_data )                  { return box_send     (this, _data); }                       
    void     push     ( const void *_data )                  {        box_push     (this, _data); }                       
    unsigned count    ()                                     { return box_count    (this); }                              
    unsigned space    ()                                     { return box_space    (this); }                              
    unsigned limit    ()                                     { return box_limit    (this); }                              
    size_t   size     ()                                     { return box_size     (this); }                              
#if OS_ATOMICS
    int      takeAsync(       void *_data )                  { return box_takeAsync(this, _data); }                       
    int      waitAsync(       void *_data )                  { return box_waitAsync(this, _data); }                       
    int      giveAsync( const void *_data )                  { return box_giveAsync(this, _data); }                       
    int      sendAsync( const void *_data )                  { return box_sendAsync(this, _data); }                       
#endif
 
    private:
    char data_[limit_ * size_];
};

 
template<unsigned limit_, class C>
struct MailBoxQueueTT : public MailBoxQueueT<limit_, sizeof(C)>
{
    constexpr
    MailBoxQueueTT(): MailBoxQueueT<limit_, sizeof(C)>() {}
};
 
}     //  namespace
#endif//__cplusplus
 
/* -------------------------------------------------------------------------- */

 
#endif//__INTROS_BOX_H