chan.hpp

Go to the documentation of this file.

//SPDX-License-Identifier: Apache-2.0
//Author: Blayne Dennis
#ifndef __MERCURY_COROUTINE_ENGINE_CHAN__
#define __MERCURY_COROUTINE_ENGINE_CHAN__ 
 
// c++
#include <type_traits>
#include <typeinfo>
#include <memory>
 
// local 
#include "base_channel.hpp"
#include "unbuffered_channel.hpp"
 
// test, only uncomment for development of this library
//#include "dev_print.hpp"
 
//-----------------------------------------------------------------------------
namespace mce {
 
//-----------------------------------------------------------------------------
template <typename T>
struct chan : public base_channel<T>,
              public channel_operators<T,chan<T>>
{
    inline chan() : 
        base_channel<T>(this),
        channel_operators<T,chan<T>>(this)
    { }
 
    inline chan(const chan<T>& rhs) : 
        base_channel<T>(this),
        channel_operators<T,chan<T>>(this),
        ctx(rhs.ctx) 
    { }
 
    inline chan(chan<T>&& rhs) : 
        base_channel<T>(this),
        channel_operators<T,chan<T>>(this),
        ctx(std::move(rhs.ctx)) 
    { }
 
    // operations
    template <typename CHANNEL>
    inline void construct(CHANNEL&& ch) const 
    { 
        ctx = std::unique_ptr<base_channel<T>>(
            allocate_context(std::forward<CHANNEL>(ch)));
    }
 
    inline void construct() const 
    {
        unbuffered_channel<T> ch;
        ch.construct();
        construct(std::move(ch));
    }
 
    inline void* context() const { return ctx ? ctx->context() : NULL; }
 
    inline const std::type_info& type_info() const { return typeid(*this); }
 
    inline const std::type_info& context_type_info() const 
    { 
        return ctx->type_info();
    }
 
    template <typename CHANNEL>
    inline CHANNEL cast() const 
    { 
        if(context() && ctx->type_info() == typeid(CHANNEL))
        {
            return *(dynamic_cast<CHANNEL*>(ctx.get()));
        } 
        else 
        {
            return CHANNEL();
        }
    }
 
    inline void close() const { ctx->close(); }
    
    inline bool closed() const { return ctx->closed(); }
 
    inline bool send(const T& s) const { return ctx->send(s); }
 
    inline bool send(T&& s) const { return ctx->send(std::move(s)); }
 
    inline bool recv(T& r) const { return ctx->recv(r); }
 
    inline result try_send(const T& s) const { return ctx->try_send(s); }
    
    inline result try_send(T&& s) const { return ctx->try_send(std::move(s)); }
 
    inline result try_recv(T& s) const { return ctx->try_recv(s); }
   
    inline void assign(const chan<T>& rhs) const { this->ctx = rhs.ctx; }
 
    inline void assign(chan<T>&& rhs) const { this->ctx = std::move(rhs.ctx); }
 
    // operators
    inline const chan<T>& operator=(const chan<T>& rhs) const
    {
        assign(rhs);
        return *this;
    }
 
    inline const chan<T>& operator=(chan<T>&& rhs) const 
    {
        assign(std::move(rhs));
        return *this;
    }
 
private:
    mutable std::shared_ptr<base_channel<T>> ctx;
 
    template <typename CHANNEL>
    base_channel<T>* allocate_context(CHANNEL&& ch) const
    {
        typedef typename std::decay<CHANNEL>::type DECAY_CH;
        return dynamic_cast<base_channel<T>*>(
                new DECAY_CH(std::forward<CHANNEL>(ch))
        );
    }
};
 
}
 
#endif