base_channel.hpp

Go to the documentation of this file.

//SPDX-License-Identifier: Apache-2.0
//Author: Blayne Dennis
#ifndef __MERCURY_COROUTINE_ENGINE_BASE_CHANNEL__
#define __MERCURY_COROUTINE_ENGINE_BASE_CHANNEL__
 
#include <typeinfo>
#include <iterator>
#include <exception>
#include <memory>
 
// Code in this header is shared by all Channels
 
namespace mce {
 
enum result 
{
    // ensure closed is convertable to `false`, allowing while(try_...()) operation loops
    closed = 0, 
    success, 
    failure 
};
 
template <typename T>
struct base_channel 
{
    typedef T value_type;
 
    base_channel(const base_channel<T>* rhs_bc) : bc(rhs_bc) { }
 
    virtual ~base_channel(){}
 
    /*
    derived channels should implement the following constructors:
    
    derived_channel();
    derived_channel(const derived_channel<T>& rhs);
    derived_channel(derived_channel<T>&& rhs);
    */
 
    // operations 
    
    virtual void construct() const = 0;
 
    virtual void* context() const = 0; 
 
    virtual const std::type_info& type_info() const = 0;
    
    virtual void close() const = 0; 
    
    virtual bool closed() const = 0; 
    
    virtual bool send(const T& s) const = 0; 
 
    virtual bool send(T&& s) const = 0; 
 
    virtual bool recv(T& r) const = 0; 
 
    virtual result try_send(const T& s) const = 0; 
 
    virtual result try_send(T&& s) const  = 0; 
 
    virtual result try_recv(T& r) const  = 0; 
 
    /*
    Derived channels should implement the following operators. They should 
    typically be implemented by directly calling the above pure virtual 
    operations:
 
    bool operator=(const derived_channel<T>& rhs) const;
    bool operator=(derived_channel<T>&& rhs) const;
    bool operator==(const derived_channel<T>& rhs) const;
    bool operator==(derived_channel<T>&& rhs) const;
    bool operator!=(const derived_channel<T>& rhs) const;
    bool operator!=(derived_channel<T>&& rhs) const;
    const derived_channel<T>& operator<<(const T& s) const;
    const derived_channel<T>& operator<<(T&& s) const;
    T& operator>>(T& r) const;
    */
 
    //TODO: There is potentially room to turn this into a virtual interface for 
    //large and small channel iterators. IE, rather than use a T for all values, 
    //can use a uptr<T> for large values and T for trivially small 
    //(wordsize?) values and convert this class to a pure virtual interface to 
    //the large & small iterator classes.
    class iterator : public std::input_iterator_tag
    {
    private:
        struct iterator_context 
        {
            iterator_context() : bc(NULL), good(false) { }
            iterator_context(const base_channel<T>* rhs_bc) : bc(rhs_bc), good(true) { }
 
            inline T& dereference() const { return t; }
            inline T* arrow() const { return &t; }
 
            inline bool increment() const 
            {
                if(good && !bc->recv(t)) { good=false; }
                return good;
            }
 
            const base_channel<T>* bc;
            mutable T t;
            mutable bool good;
        };
 
        inline void make(const base_channel<T>* bc)
        {
            ctx = std::make_shared<iterator::iterator_context>(bc);
        }
 
        mutable std::shared_ptr<iterator_context> ctx;
        friend struct base_channel<T>;
 
    public:
        typedef T value_type; //< iterator templated value type
        
        iterator(){ } //< default constructor
        iterator(const iterator& rhs) : ctx(rhs.ctx){ } //< copy constructor
        iterator(iterator&& rhs) noexcept : ctx(std::move(rhs.ctx)){ } //< move constructor
 
        inline const iterator& operator=(const iterator& rhs) const  
        {
            ctx = rhs.ctx;
            return *this;
        }
 
        inline const iterator& operator=(iterator&& rhs) const  
        {
            ctx = std::move(rhs.ctx);
            return *this;
        }
 
        inline bool operator==(const iterator& rhs) const  
        { 
            return ctx == rhs.ctx;
        }
 
        inline bool operator==(iterator&& rhs) const { return *this == rhs; }
 
        inline bool operator!=(const iterator& rhs) const { return !(*this == rhs); }
 
        inline bool operator!=(iterator&& rhs) const { return *this != rhs; }
 
        inline T& operator*() const { return ctx->dereference(); }
 
        inline T* operator->() const { return ctx->arrow(); }
 
        inline const iterator& operator++() const 
        {
            if(!ctx->increment()){ ctx.reset(); }
            return *this;
        }
 
        inline const iterator operator++(int) const 
        { 
            if(!ctx->increment()){ ctx.reset(); }
            return *this; 
        }
    };
 
    inline iterator begin() const
    {
        iterator it;
        it.make(bc);
        ++it; // get an initial value
        return it;
    }
 
    inline iterator end() const { return iterator(); } 
 
private: 
    const base_channel<T>* bc; // used for iterator
};
 
// CRTP (Curiously Recurring Template Pattern) for implementing shared channel 
// operator overloads
template <typename T, typename CHANNEL>
struct channel_operators
{
    channel_operators(CHANNEL* rhs_ch) : ch(rhs_ch) { }
 
    virtual ~channel_operators(){}
 
    virtual void assign(const CHANNEL& rhs) const = 0;
    virtual void assign(CHANNEL&& rhs) const = 0;
   
    template <typename... As>
    static CHANNEL make(As&&... as)
    {
        CHANNEL ch;
        ch.construct(std::forward<As>(as)...);
        return ch;
    }
 
    inline explicit operator bool() const 
    { 
        return ch->context() ? true : false; 
    }
 
    // operators
    inline const CHANNEL& operator=(const CHANNEL& rhs) const
    {
        ch->assign(rhs);
        return *ch;
    }
 
    inline const CHANNEL& operator=(CHANNEL&& rhs) const 
    {
        ch->assign(std::move(rhs));
        return *ch;
    }
    
    inline bool operator==(const CHANNEL& rhs) const
    {
        return ch->context() == rhs.context();
    }
 
    inline bool operator==(CHANNEL&& rhs) const
    {
        return *ch == rhs;
    }
 
    inline bool operator!=(const CHANNEL& rhs) const
    {
        return !(*ch == rhs);
    }
 
    inline bool operator!=(CHANNEL&& rhs) const
    {
        return *ch != rhs;
    }
 
    inline bool operator<(const CHANNEL& rhs) const 
    {
        return ch->context() < rhs.context();
    }
 
    inline bool operator<(CHANNEL&& rhs) const 
    {
        return ch->context() < rhs.context();
    }
 
    inline bool operator<=(const CHANNEL& rhs) const 
    {
        return ch->context() < rhs.context();
    }
 
    inline bool operator<=(CHANNEL&& rhs) const 
    {
        return ch->context() <= rhs.context();
    }
 
    inline bool operator>(const CHANNEL& rhs) const 
    {
        return ch->context() > rhs.context();
    }
 
    inline bool operator>(CHANNEL&& rhs) const 
    {
        return ch->context() > rhs.context();
    }
 
    inline bool operator>=(const CHANNEL& rhs) const 
    {
        return ch->context() > rhs.context();
    }
 
    inline bool operator>=(CHANNEL&& rhs) const 
    {
        return ch->context() >= rhs.context();
    }
 
private:
    CHANNEL* ch;
};
 
}
 
#endif