basics.h

Go to the documentation of this file.

 
#include "elementa/license.inc"
#include "elementa/checks.inc"
 
#ifndef ELEMENTA_BASE_SERIALCHANNELS_BASICS_H
#define ELEMENTA_BASE_SERIALCHANNELS_BASICS_H
 
#include <iostream>
#include <string>
#include "elementa/base/exceptions.h"
#include "elementa/base/debugging.h"
#include "elementa/base/strings.h"
#include "elementa/patterns/clonable.h"
 
namespace elementa
{
 
namespace base
{
 
/* ======================================================================
 
    GENERAL DEFINITIONS
 
    (since there are classes in here, we do not use \name to group because
     classes are not affected by \name)
 
========================================================================= */
 
 
/* ***************************************************************************
 
    Types, consts, etc.
 
*****************************************************************************/
 
 
using SerChSize = std::streamsize;
 
using SerChDatum = std::streambuf::int_type;
 
 
using SerChCharTraits = std::char_traits<char>;
 
constexpr SerChDatum kSerChEOF = std::streambuf::traits_type::eof();
 
 
using RootSerCh = std::ios;
 
 
/* ***************************************************************************
 
    Base class: OutSerCh
 
*****************************************************************************/
 
 
using OutSerCh = std::ostream;
 
 
/* ***************************************************************************
 
    Base class: InSerCh
 
*****************************************************************************/
 
 
using InSerCh = std::istream;
 
 
/* ***************************************************************************
 
    Base class: InOutSerCh
 
*****************************************************************************/
 
 
using InOutSerCh = std::iostream;
 
 
 
/* ======================================================================
 
    TRAITS MANAGEMENT
 
========================================================================= */
 
 
/* ***************************************************************************
 
    Template classes: is_SerCh, is_InSerCh, is_OutSerCh, is_InOutSerCh
 
*****************************************************************************/
 
template <class T>
class is_InSerCh
{
 public:
 
    static constexpr bool value = 
        ( std::is_base_of<InSerCh,T>::value &&
          std::is_same<typename T::char_type,char>::value
        );
};
 
 
template <class T>
class is_In_InOut_SerCh
{
 public:
 
    static constexpr bool value = 
        ( ( std::is_base_of<InSerCh,T>::value || 
            std::is_base_of<InOutSerCh,T>::value ) &&
          std::is_same<typename T::char_type,char>::value
        );
};
 
 
template <class T>
class is_OutSerCh
{
 public:
 
    static constexpr bool value = 
        ( std::is_base_of<OutSerCh,T>::value &&
          std::is_same<typename T::char_type,char>::value
        );
};
 
 
template <class T>
class is_Out_InOut_SerCh
{
 public:
 
    static constexpr bool value = 
        ( ( std::is_base_of<OutSerCh,T>::value || 
            std::is_base_of<InOutSerCh,T>::value ) &&
          std::is_same<typename T::char_type,char>::value
        );
};
 
 
template <class T>
class is_InOutSerCh
{
 public:
 
    static constexpr bool value = 
        ( std::is_base_of<InOutSerCh,T>::value &&
          std::is_same<typename T::char_type,char>::value
        );
};
 
 
template <class T>
class is_SerCh
{
 public:
 
    static constexpr bool value = ( is_InSerCh<T>::value || 
                                    is_OutSerCh<T>::value || 
                                    is_InOutSerCh<T>::value );
};
 
 
 
/* ======================================================================
 
    STATE MANAGEMENT
 
========================================================================= */
 
 
/* ***************************************************************************
 
    Functions: serch_isgood, serch_iseofbutok, serch_isexhausted,
               serch_hasreadN, serch_haswrittenN
 
*****************************************************************************/
 
 
void serch_isgood(RootSerCh & serchconst, 
                  const std::string & place = "",
                  const RTTextWithEnum::Combination & flags 
                        = {RTTextWith::kAll_});
 
 
bool serch_iseofbutok(RootSerCh & serchconst, 
                      const std::string & place = "",
                      const RTTextWithEnum::Combination & flags 
                        = {RTTextWith::kAll_});
 
 
bool serch_isexhausted(InSerCh & serch,
                      const std::string & place = "",
                      const RTTextWithEnum::Combination & flags 
                        = {RTTextWith::kAll_});
 
void serch_hasreadN(InSerCh & chin, char * dest, SerChSize n,
                    const std::string & place = "",
                    const RTTextWithEnum::Combination & flags 
                        = {RTTextWith::kAll_});
 
void serch_haswrittenN(OutSerCh & chout, const char * org, SerChSize n,
                    const std::string & place = "",
                    const RTTextWithEnum::Combination & flags 
                        = {RTTextWith::kAll_});
 
 
/* ***************************************************************************
 
    Function: serch_st_to_string
 
*****************************************************************************/
 
 
std::string serch_st_to_string(std::ios_base::iostate st) noexcept;
 
inline std::string serch_st_to_string(RootSerCh & ch) noexcept 
    { return(serch_st_to_string(ch.rdstate())); }
 
std::ios_base::iostate serch_copy_st(RootSerCh & chorg, RootSerCh & chdest);
 
 
 
/* ======================================================================
 
    ERROR MANAGEMENT
 
========================================================================= */
 
 
/* ***************************************************************************
 
    Classes: SerChError, SerChErr_Exhausted
 
*****************************************************************************/
 
class SerChError: public Exc
{
 public:
 
    SerChError(const std::string & explanation):
                    Exc{std::string{"Serial channel error: "} + 
                                       explanation}
        {}
        
    ELE_CLASS_EXCOVERRIDE(SerChError);
};
 
 
class SerChErr_Exhausted: public SerChError
{
 public:
 
    SerChErr_Exhausted(const std::string & explanation):
                    SerChError{concatWithMiddle("Channel exhausted",
                                                explanation)}
        {}
 
    ELE_CLASS_EXCOVERRIDE(SerChErr_Exhausted);
};
 
 
class SerChErr_FewData: public SerChError
{
 public:
 
    SerChErr_FewData(const std::string & explanation):
            SerChError{concatWithMiddle(
                        "Channel provided less data than expected",
                        explanation)}
        {}
        
    ELE_CLASS_EXCOVERRIDE(SerChErr_FewData)
};
 
class SerChErr_TooManyData: public SerChError
{
 public:
 
    SerChErr_TooManyData(const std::string & explanation):
            SerChError{concatWithMiddle(
                        "Too many data in channel",
                        explanation)}
        {}
        
    ELE_CLASS_EXCOVERRIDE(SerChErr_TooManyData)
};
 
 
class SerChErr_State: public SerChError
{
 public:
 
    SerChErr_State(const std::string & explanation):
                    SerChError{concatWithMiddle("Not good channel state",
                                                explanation)}
        {}
        
    ELE_CLASS_EXCOVERRIDE(SerChErr_State)
};
 
 
class SerChErr_Unopened: public SerChError
{
 public:
 
    SerChErr_Unopened(const std::string & explanation):
                    SerChError{concatWithMiddle("Unopened channel",
                                                explanation)}
        {}
        
    ELE_CLASS_EXCOVERRIDE(SerChErr_Unopened)
};
 
 
class SerChErr_Loc: public SerChError
{
 public:
 
    SerChErr_Loc(const std::string & explanation):
                    SerChError{concatWithMiddle("Location error",explanation)}
        {}
        
    ELE_CLASS_EXCOVERRIDE(SerChErr_Loc)
};
 
 
class SerChErr_Cont: public SerChError
{
 public:
 
    SerChErr_Cont(const std::string & explanation):
                    SerChError{concatWithMiddle("Container channel error",
                                                explanation)}
        {}
        
    ELE_CLASS_EXCOVERRIDE(SerChErr_Cont)
};
 
 
 
/* ======================================================================
 
    ADDITIONAL CHANNEL FUNCTIONALITY
 
========================================================================= */
 
 
/* ***************************************************************************
 
    Function template: serch_transfer
 
*****************************************************************************/
 
 
template <class SCOrg, class SCDest>
SerChSize serch_transfer(SCOrg & chin, SCDest & chout, SerChSize count = 0)
{ 
 static_assert(is_In_InOut_SerCh<SCOrg>::value && 
               is_Out_InOut_SerCh<SCDest>::value,
               "Cannot instantiate general serch_transfer with non-channel");
 
 ELE_CODE_TRACE_OFF; 
 
    ELE_CODE_TRACE({},"general case of serch_transfer (chin state={" << 
                      serch_st_to_string(chin) <<
                      "}, chout state={" << 
                      serch_st_to_string(chout) << 
                      "}, count = " << count);
    SerChSize res = 0;
    if ( (chin.good()) && (chout.good()) )  
    {
        ELE_CODE_UNTRACE({},"Both channels good for transfer " << count);
        char c;
        bool finish{false};
        while (!finish)
        {
            c = chin.get();
            ELE_CODE_UNTRACE({},"Transferring '" << c << "' (" << to_number(c) <<
                              ")");
            if (!chin.good()) 
            {
                ELE_CODE_UNTRACE({},"chin channel not good. res = " << res);
                break;
            }
            chout.put(c);
            if (!chout.good()) 
            {
                ELE_CODE_UNTRACE({},"chout channel not good. res = " << res);
                break;
            }
            ++res;          
            finish = (count == 0 ? false : (res >= count));
        }
        ELE_CODE_UNTRACE({},"Transferred " << res);
    }
    return(res);
}
 
 
 
template <class SCOrg, class SCDest>
SerChSize serch_transfer(SCOrg && chin,
                         SCDest && chout,
                         SerChSize count = 1)
{ 
 ELE_CODE_TRACE_OFF; 
 
    ELE_CODE_TRACE({},"rvalue version of serch_transfer - redirecting");
    return(serch_transfer(chin,chout,count)); 
}
 
 
/* *************************************************************************
 
        Class: SerChLoc
 
*****************************************************************************/
 
 
class SerChLoc: public elementa::patterns::Clonable
{
 public:
 
    using Ptr = std::shared_ptr<SerChLoc>;
 
    SerChLoc(void) noexcept { reset(); }
 
    SerChLoc(const SerChLoc & oth)
        { copyFrom(oth); }
 
    SerChLoc & operator=(const SerChLoc & oth) 
        { copyFrom(oth); return(*this); }
 
    SerChLoc(SerChLoc && oth)  { moveFrom(oth); }
 
    SerChLoc & operator=(SerChLoc && oth) { moveFrom(oth); return(*this); }
 
    virtual ~SerChLoc(void) {}
 
    SerChSize linear(void) const noexcept { return(lpos_); }
 
    virtual SerChLoc * clone(void) const
        { return(new SerChLoc{*this}); }
 
    virtual void reset(void) noexcept
        { lpos_ = 0; }
 
 
    virtual void inc(char c = ' ') { ++lpos_; }
 
 
    virtual void inc(const char * t, SerChSize n) 
        { if ((t==nullptr)||(n==0)) return;
          lpos_ += n; }
 
 
    virtual void dec(char c);
 
 
    virtual void dec(const char * t, SerChSize n);
    
    virtual bool operator==(const SerChLoc & o) const
        { return(lpos_ == o.lpos_); }
        
    virtual bool operator!=(const SerChLoc & o) const
        { return(!operator==(o)); }
 
 
    virtual std::string to_string(bool compact = false) const noexcept;
 
 protected:
 
    SerChSize lpos_;
 
 private:
 
    void copyFrom(const SerChLoc & oth)
        { if (this != &oth) lpos_ = oth.lpos_; }
 
    void moveFrom(SerChLoc & oth)
        { if (this != &oth) copyFrom(oth); }
 
};
 
 
/* *************************************************************************
 
        Class: SerChLocText
 
*****************************************************************************/
 
 
class SerChLocText: public SerChLoc
{
 public:
 
    SerChLocText(char endofline = '\n') noexcept: eol_{endofline}
        { reset(); }
 
    SerChLocText(const SerChLocText & oth)
        { copyFrom(oth); }
 
    SerChLocText & operator=(const SerChLocText & oth) 
        { copyFrom(oth); return(*this); }
 
    SerChLocText(SerChLocText && oth)  
        { moveFrom(oth); }
 
    SerChLocText & operator=(SerChLocText && oth) 
        { moveFrom(oth); return(*this); }
 
    virtual ~SerChLocText(void) {}
 
    SerChSize row(void) const noexcept { return(row_); }
 
    SerChSize column(void) const noexcept { return(col_); }
 
    SerChLocText * clone(void) const
        { return(new SerChLocText{*this}); }
    void reset(void) noexcept override;
    void inc(char c) override;
    void inc(const char * t, SerChSize n) override;
    void dec(char c) override;
    void dec(const char * t, SerChSize n) override;
    bool operator==(const SerChLocText & o) 
        { return((eol_ == o.eol_)&&(row_ == o.row_)&&(col_ == o.col_)); }
    bool operator!=(const SerChLocText & o) 
        { return(!operator==(o)); }
    bool operator==(const SerChLoc & o) const override
        { return(operator==(dynamic_cast<const SerChLocText &>(o))); }
    bool operator!=(const SerChLoc & o) const override
        { return(!operator==(o)); }
    std::string to_string(bool compact = false) const noexcept override;
 
 
 private:
 
    using RowInfo = std::vector<std::pair<SerChSize, SerChSize>>;
 
    char eol_;
    SerChSize row_,col_;
    RowInfo row_info_;
 
    void copyFrom(const SerChLocText & oth);
    void moveFrom(SerChLocText & oth)
        { if (this != &oth) copyFrom(oth); }
 
    std::string rowinfotostring(void) const;
};
 // SerCh_basics
 
 
} // end namespace base
 
} // end namespace elementa
 
#endif