channels.h

Go to the documentation of this file.

 
#include "elementa/license.inc"
#include "elementa/checks.inc"
 
#ifndef ELEMENTA_BASE_SERIALCHANNELS_CHANNELS_H
#define ELEMENTA_BASE_SERIALCHANNELS_CHANNELS_H
 
 
#include <streambuf>
#include <vector>
#include <array>
#include <string>
#include "elementa/base/serial_channels/basics.h"
 
 
namespace elementa
{
 
namespace base
{
 
 
/* ***************************************************************************
 
    Class: SerChO_Null
 
*****************************************************************************/
 
 
class SerChO_Null: public OutSerCh 
{
 public:
 
    SerChO_Null(void):  sbuf_{}, // first create buffer
                                OutSerCh{&sbuf_} // then use it in base ctror
        {}
 
 private:
 
    class NullOutStreamBuf: public std::streambuf
    {
        using BaseStreamBuf = std::streambuf;
 
     public:
 
        // all constructors/destructors by default (by default writing cursors 
        // are all null, thus forcing overflow)
 
     private:
 
        SerChDatum overflow(SerChDatum c = kSerChEOF) override;
    };
 
    NullOutStreamBuf sbuf_;
};
 
 
/* ***************************************************************************
 
    Class: SerChO_NullCoBuf
 
*****************************************************************************/
 
 
class SerChO_NullCoBuf: public OutSerCh 
{
 public:
 
    SerChO_NullCoBuf(SerChSize buffer = 0): sbuf_{buffer}, 
                                                   OutSerCh{&sbuf_} 
        {}
 
    SerChSize size(void) const { return(sbuf_.size()); }
 
    void reset(void) { sbuf_.reset(); }
 
    SerChSize count(void) const { return(sbuf_.count()); }
 
    const char * buffer(void) const { return(sbuf_.buffer()); }
 
 private:
 
    class NullOutStreamBuf: public std::streambuf
    {
        using BaseStreamBuf = std::streambuf;
 
     public:
 
        NullOutStreamBuf(SerChSize buffer);
        ~NullOutStreamBuf(void);
 
        SerChSize size(void) const { return(size_); }
        void reset(void) { count_ = 0; }
        SerChSize count(void) const { return(count_); }
        const char * buffer(void) const { return(buffer_); }
 
     private:
 
        SerChDatum overflow(SerChDatum c = kSerChEOF) override;
 
        SerChSize count_,size_;
        char * buffer_;
    };
 
    NullOutStreamBuf sbuf_;
};
 
 
/* ***************************************************************************
 
    Template class: SerChO_AppCont
 
*****************************************************************************/
 
 
template <class Cont>
class SerChO_AppCont: public OutSerCh 
{
 public:
 
 
    SerChO_AppCont(Cont & cont):sbuf_{cont},OutSerCh{&sbuf_} 
        {}
        
    Cont & container(void) noexcept { return(sbuf_.container()); }
 
 
 private:
 
    class AppContOutStreamBuf: public std::streambuf
    {
        using BaseStreamBuf = std::streambuf;
 
     public:
 
        AppContOutStreamBuf(Cont & cont):cont_{cont} {}
        ~AppContOutStreamBuf(void) = default;
        
        Cont & container(void) noexcept { return(cont_); }
 
     private:
 
        SerChDatum overflow(SerChDatum c = kSerChEOF) override
        {
            cont_.push_back(c);
            // keep cursors in overflow
            return(c == kSerChEOF ? 0 : c); 
        }
 
        Cont & cont_;
    };
 
    AppContOutStreamBuf sbuf_;
};
 
 
/* ***************************************************************************
 
    Class: SerChI_Constant
    Object: serchI_dummy
 
*****************************************************************************/
 
 
class SerChI_Constant: public InSerCh 
{
 public:
 
    SerChI_Constant(char c):    sbuf_{c}, // first create buffer
                                InSerCh{&sbuf_} // then use it in base ctror
        {}
 
 private:
 
    class ConstInStreamBuf: public std::streambuf
    {
        using BaseStreamBuf = std::streambuf;
 
     public:
 
        ConstInStreamBuf(char c):c_{c} // pointers null to force uflow()
            {}
 
     private:
 
        char c_;
 
        SerChDatum uflow(void) override;
        SerChDatum underflow(void) override;
        SerChDatum pbackfail (SerChDatum c = kSerChEOF) override;
    };
 
    ConstInStreamBuf sbuf_;
};
 
 
extern SerChI_Constant serchI_dummy;
 
 
/* ***************************************************************************
 
    Class: SerChI_Procedural
 
*****************************************************************************/
 
 
class SerChI_Procedural: public InSerCh 
{
 public:
 
 
    using Procedure = std::function< SerChDatum(void) >;
 
    SerChI_Procedural(Procedure & p):   sbuf_{p}, // first create buffer
                                        InSerCh{&sbuf_} // then use it 
        {}
 
 private:
 
    class ProcInStreamBuf: public std::streambuf
    {
        using BaseStreamBuf = std::streambuf;
 
     public:
 
        ProcInStreamBuf(Procedure & p):p_{p},lastc_{kSerChEOF},
                                       alreadyread_{false} 
            {} // pointers null to force uflow()
 
     private:
 
        Procedure & p_;
        SerChDatum lastc_;
        bool alreadyread_;
 
        SerChDatum uflow(void) override;
        SerChDatum underflow(void) override;
        SerChDatum pbackfail(SerChDatum c = kSerChEOF) override;
    };
 
    ProcInStreamBuf sbuf_;
};
 
 
 
/* ======================================================================
 
    MEMORY CHANNELS
 
========================================================================= */
 
 
/* ***************************************************************************
 
    Non-usable classes: InOutStreamBuf_MemoryPriv, InStreamBuf_MemoryPriv
 
*****************************************************************************/
 
class SerChI_Memory;
 
 
class InOutStreamBuf_MemoryPriv;
 
 
class InStreamBuf_MemoryPriv: public std::streambuf
{
 public:
 
    void reset(const char * begin, const char * end);
    SerChSize transfer(InOutStreamBuf_MemoryPriv & other, SerChSize count);
 
 private:
 
    const char * begin_;
    const char * end_;
 
    std::streamsize xsgetn(char *s, std::streamsize n) override;
    SerChDatum pbackfail (SerChDatum c = kSerChEOF) override;
    SerChSize copyTo(const char * itorg, char * dest, SerChSize n) noexcept;
    SerChSize copyFrom(const char * org, char * itdest,SerChSize n)noexcept;
};
 
class InOutStreamBuf_MemoryPriv: public std::streambuf
{
 friend InStreamBuf_MemoryPriv; // for InStreamBuf_MemoryPriv to access my ptrs
                                // during transfers from there
 
 public:
 
    void reset(char * begin, char * end);
    SerChSize transfer(InOutStreamBuf_MemoryPriv & other, SerChSize count);
 
 private:
 
    char * begin_;
    char * end_;
 
    std::streamsize xsgetn(char *s, std::streamsize n) override;
    std::streamsize xsputn(const char* s, std::streamsize n) override;
    SerChDatum pbackfail (SerChDatum c = kSerChEOF) override;
    SerChSize copyTo(const char * itorg, char * dest, SerChSize n) noexcept;
    SerChSize copyFrom(const char * org, char * itdest,SerChSize n)noexcept;
};
 
 
/* ***************************************************************************
 
    Class: SerChIO_Memory
 
*****************************************************************************/
 
 
class SerChIO_Memory: public InOutSerCh
{
 friend SerChI_Memory;
 
 public:
 
 
    template <typename T>
    SerChIO_Memory(void * begin, T n) noexcept;
 
 
    SerChIO_Memory(std::string & str, 
                   std::string::size_type offbegin = 0,
                   std::string::size_type offend = 0);
 
 
    template <typename T>
    SerChIO_Memory(std::vector<T> & v, 
                   typename std::vector<T>::size_type offbegin = 0,
                   typename std::vector<T>::size_type offend = 0);
 
 
    template <typename T, std::size_t N>
    SerChIO_Memory(std::array<T,N> & a, 
                   typename std::array<T,N>::size_type offbegin = 0,
                   typename std::array<T,N>::size_type offend = 0);
 
 
    SerChIO_Memory(const SerChIO_Memory &) = delete;
    SerChIO_Memory(SerChIO_Memory &&) = delete;
    SerChIO_Memory & operator=(SerChIO_Memory &) = delete;
    SerChIO_Memory & operator=(SerChIO_Memory &&) = delete;
 
    void reset(void);
 
 
    SerChSize transfer(SerChIO_Memory & chout, SerChSize count = 0)
        { if (good() && chout.good()) return(sbuf_.transfer(chout.sbuf_,count)); 
          return(0); }
 
 private:
 
    char * begin_;
    char * end_;
    InOutStreamBuf_MemoryPriv sbuf_;
};
 
 
 
template <>
inline 
SerChSize serch_transfer<SerChIO_Memory,SerChIO_Memory>(SerChIO_Memory & chin,
                                                        SerChIO_Memory & chout,
                                                        SerChSize count)
{
 ELE_CODE_TRACE_OFF; 
 
    ELE_CODE_TRACE({},"both containers case of serch_transfer (chin state={"<< 
                      serch_st_to_string(chin) <<
                      "}, chout state={" << 
                      serch_st_to_string(chout) << 
                      "}, count = " << count);
    return(chin.transfer(chout,count));
}
 
 
/* ***************************************************************************
 
    Class: SerChI_Memory
 
*****************************************************************************/
 
 
class SerChI_Memory: public InSerCh
{
 public:
 
 
    template <typename T>
    SerChI_Memory(const void * begin, T n) noexcept;    
    
 
    SerChI_Memory(const std::string & str, 
                   std::string::size_type offbegin = 0,
                   std::string::size_type offend = 0);
 
 
    template <typename T>
    SerChI_Memory(const std::vector<T> & v, 
                   typename std::vector<T>::size_type offbegin = 0,
                   typename std::vector<T>::size_type offend = 0);
    
 
    template <typename T, std::size_t N>
    SerChI_Memory(const std::array<T,N> & a, 
                   typename std::array<T,N>::size_type offbegin = 0,
                   typename std::array<T,N>::size_type offend = 0);
 
    SerChI_Memory(const SerChI_Memory &) = delete;
    SerChI_Memory(SerChI_Memory &&) = delete;
    SerChI_Memory & operator=(SerChI_Memory &) = delete;
    SerChI_Memory & operator=(SerChI_Memory &&) = delete;
 
    void reset(void);
 
 
    SerChSize transfer(SerChIO_Memory & chout, SerChSize count = 0)
        { if (good() && chout.good()) return(sbuf_.transfer(chout.sbuf_,count)); 
          return(0); }
 
 private:
 
    const char * begin_;
    const char * end_;
    InStreamBuf_MemoryPriv sbuf_;
};
 
 
 
template <>
inline 
SerChSize serch_transfer<SerChI_Memory,SerChIO_Memory>(SerChI_Memory & chin,
                                                        SerChIO_Memory & chout,
                                                        SerChSize count)
{
 ELE_CODE_TRACE_OFF; 
 
    ELE_CODE_TRACE({},"both containers case of serch_transfer (chin state={"<< 
                      serch_st_to_string(chin) <<
                      "}, chout state={" << 
                      serch_st_to_string(chout) << 
                      "}, count = " << count);
    return(chin.transfer(chout,count));
}
 
 
 
/* ======================================================================
 
    TEMPLATE IMPLEMENTATIONS
 
========================================================================= */
 
/* ***************************************************************************
 
    Class: SerChIO_Memory
 
*****************************************************************************/
 
template <typename T>
SerChIO_Memory::SerChIO_Memory(void * begin, T n) noexcept:     
                                    begin_{reinterpret_cast<char *>(begin)},
                                    end_{reinterpret_cast<char *>(begin) + n},
                                    sbuf_{}, 
                                    InOutSerCh{&sbuf_}
{ 
    reset(); 
    static_assert(std::is_integral<T>::value,
                    "The size type must be integral in the "
                    "SerChIO_Memory constructor");
}
 
template <typename T>
SerChIO_Memory::SerChIO_Memory(std::vector<T> & v, 
                   typename std::vector<T>::size_type offbegin,
                   typename std::vector<T>::size_type offend):
                                                    sbuf_{}, 
                                                    InOutSerCh{&sbuf_}
{
    if ( (v.size() > 0) && (offbegin < v.size()) && 
         (offend < v.size()) && (offbegin + offend < v.size()) )
    {
        begin_ = reinterpret_cast<char *>(v.data() + offbegin); 
        end_ = reinterpret_cast<char *>(v.data() + (v.size() - offend));
        reset(); 
    }
    else ELE_CODE_INVARG("Empty vector or invalid offsets");
}
 
template <typename T, std::size_t N>
SerChIO_Memory::SerChIO_Memory(std::array<T,N> & a, 
                   typename std::array<T,N>::size_type offbegin,
                   typename std::array<T,N>::size_type offend):
                                                    sbuf_{}, 
                                                    InOutSerCh{&sbuf_}
{
    if ( (a.size() > 0) && (offbegin < a.size()) && 
         (offend < a.size()) && (offbegin + offend < a.size()) )
    {
        begin_ = reinterpret_cast<char *>(a.data() + offbegin); 
        end_ = reinterpret_cast<char *>(a.data() + (a.size() - offend));
        reset(); 
    }
    else ELE_CODE_INVARG("Empty vector or invalid offsets");
}
 
 
/* ***************************************************************************
 
    Class: SerChI_Memory
 
*****************************************************************************/
 
template <typename T>
SerChI_Memory::SerChI_Memory(const void * begin, T n) noexcept:     
                                begin_{reinterpret_cast<const char *>(begin)},
                                end_{reinterpret_cast<const char *>(begin) + n},
                                sbuf_{}, 
                                InSerCh{&sbuf_}
{ 
    reset(); 
    static_assert(std::is_integral<T>::value,
                    "The size type must be integral in the "
                    "SerChI_Memory constructor");
}
 
template <typename T>
SerChI_Memory::SerChI_Memory(const std::vector<T> & v, 
                   typename std::vector<T>::size_type offbegin,
                   typename std::vector<T>::size_type offend):
                                                    sbuf_{}, 
                                                    InOutSerCh{&sbuf_}
{
    if ( (v.size() > 0) && (offbegin < v.size()) && 
         (offend < v.size()) && (offbegin + offend < v.size()) )
    {
        begin_ = reinterpret_cast<const char *>(v.data() + offbegin); 
        end_ = reinterpret_cast<const char *>(v.data() + 
                                              (v.size() - offend));
        reset(); 
    }
    else ELE_CODE_INVARG("Empty vector or invalid offsets");
}
 
template <typename T, std::size_t N>
SerChI_Memory::SerChI_Memory(const std::array<T,N> & a, 
                   typename std::array<T,N>::size_type offbegin,
                   typename std::array<T,N>::size_type offend):
                                                    sbuf_{}, 
                                                    InOutSerCh{&sbuf_}
{
    if ( (a.size() > 0) && (offbegin < a.size()) && 
         (offend < a.size()) && (offbegin + offend < a.size()) )
    {
        begin_ = reinterpret_cast<const char *>(a.data() + offbegin); 
        end_ = reinterpret_cast<const char *>(a.data() + 
                                              (a.size() - offend));
        reset(); 
    }
    else ELE_CODE_INVARG("Empty vector or invalid offsets");
}
 
 
 
 // SerCh_channels
 
 
} // end namespace base
 
} // end namespace elementa
 
#endif