util.hpp

 
#pragma once
 
#ifdef ASRT_NODISCARD_ENABLED
#define ASRT_NODISCARD [[nodiscard]]
#else
#define ASRT_NODISCARD
#endif
 
#include "../asrtl/allocator.h"
#include "../asrtl/asrt_assert.h"
#include "../asrtl/chann.h"
#include "../asrtl/source.h"
 
#include <functional>
#include <memory>
#include <optional>
#include <span>
 
namespace asrt
{
using source    = asrt_source;
using chann_id  = asrt_chann_id;
using status    = asrt_status;
using allocator = asrt_allocator;
using span      = asrt_span;
using span_span = asrt_span_span;
template < typename T >
using uptr = std::unique_ptr< T >;
template < typename T >
using opt = std::optional< T >;
 
inline asrt_span cnv( std::span< uint8_t > buff )
{
        return {
            .b = buff.data(),
            .e = buff.data() + buff.size(),
        };
}
 
inline std::span< uint8_t > cnv( asrt_span buff )
{
        return { buff.b, buff.e };
}
 
ASRT_NODISCARD inline enum asrt_status dispatch( struct asrt_node& head, std::span< uint8_t > buff )
{
        return asrt_chann_dispatch(
            &head, asrt_span{ .b = buff.data(), .e = buff.data() + buff.size() } );
}
 
ASRT_NODISCARD inline enum asrt_status tick( struct asrt_node& head, uint32_t now )
{
        return asrt_chann_tick( &head, now );
}
 
inline asrt_node& node( auto* comp )
{
        return comp->node;
}
 
inline asrt_node& node( auto& comp )
{
        return comp.node;
}
 
ASRT_NODISCARD inline status recv( asrt_node& n, std::span< uint8_t > buff )
{
        return asrt_chann_recv( &n, cnv( buff ) );
}
 
ASRT_NODISCARD inline status recv( asrt_node& n, asrt_span buff )
{
        return asrt_chann_recv( &n, buff );
}
 
template < typename T >
struct ref
{
        T& operator*() { return *_p; }
        T* operator->() { return _p; }
 
        operator T&() { return *_p; }
        operator T*() { return _p; }
 
        ref( T& t )
          : _p( &t )
        {
        }
        ref( T* t )
          : _p( t )
        {
                ASRT_ASSERT( t != nullptr );
        }
 
private:
        T* _p;
};
 
// ---------------------------------------------------------------------------
// send_queue helper
 
struct send_req_ref
{
        explicit       operator bool() const noexcept { return _cur != nullptr; }
        asrt_send_req* operator->() const noexcept { return _cur; }
        asrt_send_req& operator*() const noexcept { return *_cur; }
 
        void finish( enum asrt_status s ) noexcept { asrt_send_req_list_done( _list, s ); }
 
private:
        asrt_send_req_list* _list;
        asrt_send_req*      _cur;
 
        friend send_req_ref next( asrt_send_req_list& ) noexcept;
        send_req_ref( asrt_send_req_list* l ) noexcept
          : _list( l )
          , _cur( l->head )
        {
        }
};
 
inline send_req_ref next( asrt_send_req_list& list ) noexcept
{
        return send_req_ref{ &list };
}
 
}  // namespace asrt