serializers.h

Go to the documentation of this file.

 
#include "elementa/license.inc"
#include "elementa/checks.inc"
 
#ifndef ELEMENTA_BASE_SERIAL_CHANNELS_SERIALIZERS_H
#define ELEMENTA_BASE_SERIAL_CHANNELS_SERIALIZERS_H
 
#include <type_traits>
#include <utility>
#include "elementa/base/fundamentaltypes.h"
#include "elementa/base/strings.h"
#include "elementa/base/exceptions.h"
#include "elementa/base/serial_channels.h"
 
namespace elementa
{
 
namespace base
{
 
 
/* ======================================================================
 
    MISCELLANEOUS DEFINITIONS
 
    (since there are classes in here, we do not use \name to group because
     classes are not affected by \name)
 
========================================================================= */
 
/* ***************************************************************************
 
    Class: SzerError
 
*****************************************************************************/
 
 
class SzerError: public Exc
{
 public:
 
    SzerError(const std::string & explanation):
                        Exc{std::string{"Serializer error. "} + explanation}
        {}
        
    ELE_CLASS_EXCOVERRIDE(SzerError)
};
 
 
 
/* ======================================================================
 
    SERIALIZERS
 
========================================================================= */
 
/* ***************************************************************************
 
    Base template class: Serializer
 
*****************************************************************************/
 
 
template <class Sble, 
          class ReturnDeserType = void,     
          class ReturnSerType = void>// it's more common to need ReturnDeserType
class Serializer
{
 public:
 
    using SType = Sble;
 
    using RDeserType = Sble;
    
    using RSerType = Sble;
 
 
 
    virtual ReturnSerType ser(OutSerCh & chout, const Sble & obj)
        { ELE_CODE_UNIMPLEMENTED; }
 
 
    virtual ReturnDeserType deser(InSerCh & chin, Sble & obj) 
        { ELE_CODE_UNIMPLEMENTED; }
 
};
 
 
/* ======================================================================
 
    SERIALIZABLES
 
========================================================================= */
 
 
/* ***************************************************************************
 
    Base template class: Serializable
 
*****************************************************************************/
 
 
template <class DeserReturnType = void, 
          class SerReturnType = void>
class Serializable
{
 public:
 
 
    virtual SerReturnType serme(OutSerCh & chout) const
        { ELE_CODE_UNIMPLEMENTED; } 
 
    virtual DeserReturnType deserme(InSerCh & chin) 
        { ELE_CODE_UNIMPLEMENTED; }
 
};
 
 
/* ***************************************************************************
 
    Operators: << , >>
 
*****************************************************************************/
 
 
template <class DeserReturnType, 
          class SerReturnType>
OutSerCh & operator<<(OutSerCh & chout, 
                        const Serializable<DeserReturnType,SerReturnType> & o)
{ 
    o.serme(chout); 
    return(chout); 
}
 
 
 
template <class DeserReturnType, 
          class SerReturnType>
InSerCh & operator>>(InSerCh & chin, 
                        Serializable<DeserReturnType,SerReturnType> & o)
{ 
    o.deserme(chin); 
    return(chin); 
}
 
 
/* ***************************************************************************
 
    Template class (adapter): ClassSzer_, ClassSzer
 
*****************************************************************************/
 
template <class Sble, class DeserReturnType, class SerReturnType>
class ClassSzer_ final: public Serializer<Sble,DeserReturnType,SerReturnType>
{
 public:
 
    SerReturnType ser(OutSerCh & chout, const Sble & obj) 
        { return(obj.serme(chout)); }
 
    DeserReturnType deser(InSerCh & chin, Sble & obj) 
        { return(obj.deserme(chin)); }
};
 
 
template <class Sble, class SerReturnType>
class ClassSzer_<Sble,void,SerReturnType> final: 
                                    public Serializer<Sble,void,SerReturnType>
{
 public:
 
    SerReturnType ser(OutSerCh & chout, const Sble & obj) 
        { return(obj.serme(chout)); }
 
    void deser(InSerCh & chin, Sble & obj) 
        { obj.deserme(chin); }
};
 
template <class Sble, class DeserReturnType>
class ClassSzer_<Sble,DeserReturnType,void> final: 
                                    public Serializer<Sble,DeserReturnType,void>
{
 public:
 
    void ser(OutSerCh & chout, const Sble & obj) 
        { obj.serme(chout); }
 
    DeserReturnType deser(InSerCh & chin, Sble & obj) 
        { return(obj.deserme(chin)); }
};
 
template <class Sble>
class ClassSzer_<Sble,void,void> final: public Serializer<Sble,void,void>
{
 public:
 
    void ser(OutSerCh & chout, const Sble & obj) 
        { obj.serme(chout); }
 
    void deser(InSerCh & chin, Sble & obj) 
        { obj.deserme(chin); }
};
 
 
 
template <class Sble, class DeserReturnType = void, class SerReturnType = void>
using ClassSzer = ClassSzer_<Sble,DeserReturnType,SerReturnType>;
 
 
 
/* ======================================================================
 
    COMMON SERIALIZERS
 
========================================================================= */
 
 
/* ***************************************************************************
 
    Class: Szer_Char
 
*****************************************************************************/
 
class Szer_Char: public Serializer<char>
{
 public:
 
    void ser(OutSerCh & chout, const char & c) 
    { chout.put(c); serch_isgood(chout,ELE_CODE_PLACE); }
 
    void deser(InSerCh & chin, char & c)
    { if (serch_isexhausted(chin,ELE_CODE_PLACE))
        throw(SerChErr_Exhausted{""}.asEXC(ELE_CODE_PLACE));
      chin.get(c); }
 
};
 
 
/* ***************************************************************************
 
    Class: Szer_String
 
*****************************************************************************/
 
 
class Szer_String: public Serializer<std::string> 
{
 public:
 
 
    Szer_String(SerChSize size = 0, char c = ' '):  size_{size},
                                                            c_{c}
        {}
 
 
    void ser(OutSerCh & chout, const std::string & s);
 
 
    void deser(InSerCh & chin, std::string & s);
 
    SerChSize sersize(void) const { return(size_); }
 
 private:
 
    const SerChSize size_;
    const char c_;
};
 
 
/* ***************************************************************************
 
    Class template: Szer_NatBin
 
*****************************************************************************/
 
 
template <typename NatType>
class Szer_NatBin: public Serializer<NatType> 
{
 public:
 
    Szer_NatBin(SerChSize size = sizeof(NatType)): size_{size} 
        {}
 
    void ser(OutSerCh & chout, const NatType & obj);
 
    void deser(InSerCh & chin, NatType & obj);
 
    SerChSize sersize(void) const { return(size_); }
 
 private:
 
    const SerChSize size_;
 
    // Static assert at the end due to a bug in doxygen that stops generating
    // anything else when this is found.
    static_assert(std::is_integral<NatType>::value &&
                 !std::is_signed<NatType>::value,
                 "Szer_NatBin instantiated with a non-integral or signed type");
};
 
 
/* ***************************************************************************
 
    Class: Szer_IntText
 
*****************************************************************************/
 
 
class Szer_IntText: public Serializer<LongestInt> 
{
 public:
 
    Szer_IntText(SerChSize size = sizeof(LongestInt)):size_{size} 
        {}
 
    void ser(OutSerCh & chout, const LongestInt & obj);
 
    void deser(InSerCh & chin, LongestInt & obj);
 
    SerChSize sersize(void) const { return(size_); }
 
 private:
 
    const SerChSize size_;
};
 
 
/* ***************************************************************************
 
    Class: Szer_RealText
 
*****************************************************************************/
 
 
class Szer_RealText: public Serializer<LongestReal> 
{
 public:
 
    Szer_RealText(SerChSize size = sizeof(LongestReal)):    size_{size} 
        {}
 
    void ser(OutSerCh & chout, const LongestReal & obj);
 
    void deser(InSerCh & chin, LongestReal & obj);
 
    SerChSize sersize(void) const { return(size_); }
 
 private:
 
    const SerChSize size_;
};
 
 
/* ***************************************************************************
 
    Class: Szer_StringToken
 
*****************************************************************************/
 
 
class Szer_StringToken: public Serializer<std::string,int> 
{
 public:
 
    ELE_CLASS_ENUM(Type,
            kSeparators,    
            kNonSeparators, 
            kMultiComment,  
            kUniComment,    
            kNone           
          );
 
 
    Szer_StringToken(const std::string & multilinecomm = "/* */",
                     const std::string & unilinecomm = "// \n",
                     const std::string & seps = "\n\t \f\r\v\x00");
 
    void ser(OutSerCh & chout, const std::string & obj);
 
 
    int deser(InSerCh & chin, std::string & obj);
 
 private:
 
    std::string separators_;
    std::string multilinebeg_;
    std::string multilineend_;
    std::string unilinebeg_;
    std::string unilineend_;
 
    static void split_marks(const std::string & ms, 
                            std::string & beg, std::string & end);
 
    Type kind_of_begin(char c, int prio = 0);
};
 
 
 
/* ===========================================================================
 
        ========== IMPLEMENTATION OF TEMPLATES ==========
 
============================================================================= */
 
/* ***************************************************************************
 
    Class template: Szer_NatBin
 
*****************************************************************************/
 
template <typename NatType>
void Szer_NatBin<NatType>::ser(OutSerCh & chout, const NatType & obj)
{
    NatType rem = obj;
    if (size_>0) // fixed size
    {
        for (SerChSize f = 0; f < size_; ++f)
        {
            chout.put(rem & 0xff);
            serch_isgood(chout,ELE_CODE_PLACE);
            rem >>= 8;
        }
        if (rem!=0)
            throw(SzerError{"Serializing too long natural"}.
                    asEXC(ELE_CODE_PLACE));
    }
    else // dynamic size
    {
        do
        {
            chout.put(rem & 0xff);
            serch_isgood(chout,ELE_CODE_PLACE);
            rem >>= 8;
        } while (rem>0);
    }
}
 
template <typename NatType>
void Szer_NatBin<NatType>::deser(InSerCh & chin, NatType & obj)
{
    obj = 0;
    if (size_>0) // fixed size
    {
        char c;
        for (SerChSize f = 0; f < size_; ++f)
        {
            if (serch_isexhausted(chin,ELE_CODE_PLACE))
                throw(SerChErr_Exhausted{""}.asEXC(ELE_CODE_PLACE));
            chin.get(c);
            obj |= static_cast<NatType>(static_cast<uint8_t>(c)) << (8*f);
        }       
    }
    else throw(SzerError{"Deserializing natural in non-fixed size mode"}.
                   asEXC(ELE_CODE_PLACE)); 
}
 
 
 // Serializers
 
 
} // end namespace base
 
} // end namespace elementa
 
#endif