Serializable.hpp

Go to the documentation of this file.

#ifndef SERIALIZABLE_HPP
#define SERIALIZABLE_HPP

#ifdef BUILD_UT
#include <iostream>
#endif

#include <Fw/FPrimeBasicTypes.hpp>
#include "Fw/Deprecate.hpp"

namespace Fw {

class StringBase;  
typedef enum {
    FW_SERIALIZE_OK,               
    FW_SERIALIZE_FORMAT_ERROR,     
    FW_SERIALIZE_NO_ROOM_LEFT,     
    FW_DESERIALIZE_BUFFER_EMPTY,   
    FW_DESERIALIZE_FORMAT_ERROR,   
    FW_DESERIALIZE_SIZE_MISMATCH,  
    FW_DESERIALIZE_TYPE_MISMATCH   
} SerializeStatus;
class SerializeBufferBase;  

struct Serialization {
    enum t {
        INCLUDE_LENGTH,  
        OMIT_LENGTH      
    };
};

enum class Endianness {
    BIG,    
    LITTLE  
};

class Serializable {
  public:
    // Size type for backwards compatibility
    using SizeType = FwSizeType;

  public:
    virtual SerializeStatus serializeTo(SerializeBufferBase& buffer,
                                        Endianness mode = Endianness::BIG) const = 0;  

    virtual SerializeStatus deserializeFrom(
        SerializeBufferBase& buffer,
        Endianness mode = Endianness::BIG) = 0;  

    // ----------------------------------------------------------------------
    // Legacy methods for backward compatibility
    // ----------------------------------------------------------------------

    DEPRECATED(SerializeStatus serialize(SerializeBufferBase& buffer) const,
               "Use serializeTo(SerializeBufferBase& buffer) instead") {
        return this->serializeTo(buffer);
    }

    DEPRECATED(SerializeStatus deserialize(SerializeBufferBase& buffer),
               "Use deserializeFrom(SerializeBufferBase& buffer) instead") {
        return this->deserializeFrom(buffer);
    }

#if FW_SERIALIZABLE_TO_STRING || FW_ENABLE_TEXT_LOGGING || BUILD_UT
    virtual void toString(StringBase& text) const;  
#endif

#ifdef BUILD_UT
    friend std::ostream& operator<<(std::ostream& os, const Serializable& val);
#endif

  protected:
    Serializable();           
    virtual ~Serializable();  
};

class SerializeBufferBase {
    friend class SerializeBufferBaseTester;

  protected:
    SerializeBufferBase& operator=(const SerializeBufferBase& src);  

  public:
    virtual ~SerializeBufferBase();  

    // Serialization for built-in types

    SerializeStatus serializeFrom(U8 val, Endianness mode = Endianness::BIG);  
    SerializeStatus serializeFrom(I8 val, Endianness mode = Endianness::BIG);  

#if FW_HAS_16_BIT == 1
    SerializeStatus serializeFrom(U16 val, Endianness mode = Endianness::BIG);  
    SerializeStatus serializeFrom(I16 val, Endianness mode = Endianness::BIG);  
#endif
#if FW_HAS_32_BIT == 1
    SerializeStatus serializeFrom(U32 val, Endianness mode = Endianness::BIG);  
    SerializeStatus serializeFrom(I32 val, Endianness mode = Endianness::BIG);  
#endif
#if FW_HAS_64_BIT == 1
    SerializeStatus serializeFrom(U64 val, Endianness mode = Endianness::BIG);  
    SerializeStatus serializeFrom(I64 val, Endianness mode = Endianness::BIG);  
#endif
    SerializeStatus serializeFrom(F32 val, Endianness mode = Endianness::BIG);   
    SerializeStatus serializeFrom(F64 val, Endianness mode = Endianness::BIG);   
    SerializeStatus serializeFrom(bool val, Endianness mode = Endianness::BIG);  

    SerializeStatus serializeFrom(const void* val,
                                  Endianness mode = Endianness::BIG);  

    SerializeStatus serializeFrom(const U8* buff, FwSizeType length, Endianness endianMode = Endianness::BIG);

    SerializeStatus serializeFrom(const U8* buff,
                                  FwSizeType length,
                                  Serialization::t lengthMode,
                                  Endianness endianMode = Endianness::BIG);

    SerializeStatus serializeFrom(const SerializeBufferBase& val,
                                  Endianness mode = Endianness::BIG);  

    SerializeStatus serializeFrom(
        const Serializable& val,
        Endianness mode = Endianness::BIG);  

    SerializeStatus serializeSize(const FwSizeType size,
                                  Endianness mode = Endianness::BIG);  

    // Deserialization for built-in types

    SerializeStatus deserializeTo(U8& val, Endianness mode = Endianness::BIG);  
    SerializeStatus deserializeTo(I8& val, Endianness mode = Endianness::BIG);  

#if FW_HAS_16_BIT == 1
    SerializeStatus deserializeTo(U16& val, Endianness mode = Endianness::BIG);  
    SerializeStatus deserializeTo(I16& val, Endianness mode = Endianness::BIG);  
#endif

#if FW_HAS_32_BIT == 1
    SerializeStatus deserializeTo(U32& val, Endianness mode = Endianness::BIG);  
    SerializeStatus deserializeTo(I32& val, Endianness mode = Endianness::BIG);  
#endif
#if FW_HAS_64_BIT == 1
    SerializeStatus deserializeTo(U64& val, Endianness mode = Endianness::BIG);  
    SerializeStatus deserializeTo(I64& val, Endianness mode = Endianness::BIG);  
#endif
    SerializeStatus deserializeTo(F32& val, Endianness mode = Endianness::BIG);   
    SerializeStatus deserializeTo(F64& val, Endianness mode = Endianness::BIG);   
    SerializeStatus deserializeTo(bool& val, Endianness mode = Endianness::BIG);  

    SerializeStatus deserializeTo(
        void*& val,
        Endianness mode = Endianness::BIG);  

    SerializeStatus deserializeTo(U8* buff,
                                  FwSizeType& length,
                                  Endianness endianMode = Endianness::BIG);  

    SerializeStatus deserializeTo(U8* buff,
                                  FwSizeType& length,
                                  Serialization::t lengthMode,
                                  Endianness endianMode = Endianness::BIG);

    SerializeStatus deserializeTo(
        Serializable& val,
        Endianness mode = Endianness::BIG);  

    SerializeStatus deserializeTo(SerializeBufferBase& val,
                                  Endianness mode = Endianness::BIG);  

    SerializeStatus deserializeSize(FwSizeType& size, Endianness mode = Endianness::BIG);  

    // ----------------------------------------------------------------------
    // Serialization methods
    // ----------------------------------------------------------------------

    DEPRECATED(SerializeStatus serialize(U8 val), "Use serializeFrom(U8 val) instead");
    DEPRECATED(SerializeStatus serialize(I8 val), "Use serializeFrom(I8 val) instead");
#if FW_HAS_16_BIT == 1
    DEPRECATED(SerializeStatus serialize(U16 val), "Use serializeFrom(U16 val) instead");
    DEPRECATED(SerializeStatus serialize(I16 val), "Use serializeFrom(I16 val) instead");
#endif
#if FW_HAS_32_BIT == 1
    DEPRECATED(SerializeStatus serialize(U32 val), "Use serializeFrom(U32 val) instead");
    DEPRECATED(SerializeStatus serialize(I32 val), "Use serializeFrom(I32 val) instead");
#endif
#if FW_HAS_64_BIT == 1
    DEPRECATED(SerializeStatus serialize(U64 val), "Use serializeFrom(U64 val) instead");
    DEPRECATED(SerializeStatus serialize(I64 val), "Use serializeFrom(I64 val) instead");
#endif

    DEPRECATED(SerializeStatus serialize(F32 val), "Use serializeFrom(F32 val) instead");
    DEPRECATED(SerializeStatus serialize(F64 val), "Use serializeFrom(F64 val) instead");
    DEPRECATED(SerializeStatus serialize(bool val), "Use serializeFrom(bool val) instead");
    DEPRECATED(SerializeStatus serialize(const void* val), "Use serializeFrom(const void* val) instead");
    DEPRECATED(SerializeStatus serialize(const U8* buff, FwSizeType length, bool noLength),
               "Use serialize(const U8* buff, FwSizeType length, Serialization::t mode) instead");
    DEPRECATED(SerializeStatus serialize(const U8* buff, FwSizeType length),
               "Use serializeFrom(const U8* buff, FwSizeType length) instead");
    DEPRECATED(SerializeStatus serialize(const U8* buff, FwSizeType length, Serialization::t mode),
               "Use serializeFrom(const U8* buff, FwSizeType length, Serialization::t mode) instead");
    DEPRECATED(SerializeStatus serialize(const Serializable& val),
               "Use serializeFrom(const Serializable& val) instead");
    DEPRECATED(SerializeStatus serialize(const SerializeBufferBase& val),
               "Use serializeFrom(const SerializeBufferBase& val) instead");

    DEPRECATED(SerializeStatus deserialize(U8& val), "Use deserializeTo(U8& val) instead");
    DEPRECATED(SerializeStatus deserialize(I8& val), "Use deserializeTo(I8& val) instead");
#if FW_HAS_16_BIT == 1
    DEPRECATED(SerializeStatus deserialize(U16& val), "Use deserializeTo(U16& val) instead");
    DEPRECATED(SerializeStatus deserialize(I16& val), "Use deserializeTo(I16& val) instead");
#endif
#if FW_HAS_32_BIT == 1
    DEPRECATED(SerializeStatus deserialize(U32& val), "Use deserializeTo(U32& val) instead");
    DEPRECATED(SerializeStatus deserialize(I32& val), "Use deserializeTo(I32& val) instead");
#endif
#if FW_HAS_64_BIT == 1
    DEPRECATED(SerializeStatus deserialize(U64& val), "Use deserializeTo(U64& val) instead");
    DEPRECATED(SerializeStatus deserialize(I64& val), "Use deserializeTo(I64& val) instead");
#endif

    DEPRECATED(SerializeStatus deserialize(F32& val), "Use deserializeTo(F32& val) instead");
    DEPRECATED(SerializeStatus deserialize(F64& val), "Use deserializeTo(F64& val) instead");
    DEPRECATED(SerializeStatus deserialize(bool& val), "Use deserializeTo(bool& val) instead");
    DEPRECATED(SerializeStatus deserialize(void*& val), "Use deserializeTo(void*& val) instead");
    DEPRECATED(SerializeStatus deserialize(U8* buff, FwSizeType& length, bool noLength),
               "Use deserialize(U8* buff, FwSizeType& length, Serialization::t mode) instead");
    DEPRECATED(SerializeStatus deserialize(U8* buff, FwSizeType& length),
               "Use deserializeTo(U8* buff, FwSizeType& length) instead");
    DEPRECATED(SerializeStatus deserialize(U8* buff, FwSizeType& length, Serialization::t mode),
               "Use deserializeTo(U8* buff, FwSizeType& length, Serialization::t mode) instead");
    DEPRECATED(SerializeStatus deserialize(Serializable& val), "Use deserializeTo(Serializable& val) instead");
    DEPRECATED(SerializeStatus deserialize(SerializeBufferBase& val),
               "Use deserializeTo(SerializeBufferBase& val) instead");

    void resetSer();    
    void resetDeser();  

    SerializeStatus moveSerToOffset(FwSizeType offset);    
    SerializeStatus moveDeserToOffset(FwSizeType offset);  

    SerializeStatus serializeSkip(
        FwSizeType numBytesToSkip);  
    SerializeStatus deserializeSkip(
        FwSizeType numBytesToSkip);  
    virtual Serializable::SizeType getBuffCapacity() const = 0;  
    Serializable::SizeType getBuffLength() const;                
    Serializable::SizeType getBuffLeft() const;                  
    virtual U8* getBuffAddr() = 0;                               
    virtual const U8* getBuffAddr() const = 0;  
    const U8* getBuffAddrLeft() const;          
    U8* getBuffAddrSer();  
    SerializeStatus setBuff(const U8* src, Serializable::SizeType length);  
    SerializeStatus setBuffLen(Serializable::SizeType length);  
    SerializeStatus copyRaw(
        SerializeBufferBase& dest,
        Serializable::SizeType size);  
                                       // Will increment deserialization pointer
    SerializeStatus copyRawOffset(
        SerializeBufferBase& dest,
        Serializable::SizeType size);  
                                       // Will increment deserialization pointer

#ifdef BUILD_UT
    bool operator==(const SerializeBufferBase& other) const;
    friend std::ostream& operator<<(std::ostream& os, const SerializeBufferBase& buff);
#endif

  protected:
    SerializeBufferBase();              
    Serializable::SizeType m_serLoc;    
    Serializable::SizeType m_deserLoc;  

  private:
    // Copy constructor can be used only by the implementation
    SerializeBufferBase(const SerializeBufferBase& src);  

    void copyFrom(const SerializeBufferBase& src);  
};

// Helper classes for building buffers with external storage

class ExternalSerializeBuffer : public SerializeBufferBase {
  public:
    ExternalSerializeBuffer(U8* buffPtr, Serializable::SizeType size);  
    ExternalSerializeBuffer();                                          
    ~ExternalSerializeBuffer() {}                                       
    void setExtBuffer(U8* buffPtr, Serializable::SizeType size);
    void clear();                                                          
    ExternalSerializeBuffer(const ExternalSerializeBuffer& src) = delete;  

    // pure virtual functions
    Serializable::SizeType getBuffCapacity() const;
    U8* getBuffAddr();
    const U8* getBuffAddr() const;

    ExternalSerializeBuffer& operator=(const SerializeBufferBase& src) = delete;

  protected:
    // data members
    U8* m_buff;                         
    Serializable::SizeType m_buffSize;  
};

class ExternalSerializeBufferWithDataCopy final : public ExternalSerializeBuffer {
  public:
    ExternalSerializeBufferWithDataCopy(U8* buffPtr, Serializable::SizeType size)
        : ExternalSerializeBuffer(buffPtr, size) {}
    ExternalSerializeBufferWithDataCopy() : ExternalSerializeBuffer() {}
    ~ExternalSerializeBufferWithDataCopy() {}
    ExternalSerializeBufferWithDataCopy(const SerializeBufferBase& src) = delete;
    ExternalSerializeBufferWithDataCopy& operator=(SerializeBufferBase& src) {
        (void)SerializeBufferBase::operator=(src);
        return *this;
    }
};

class ExternalSerializeBufferWithMemberCopy final : public ExternalSerializeBuffer {
  public:
    ExternalSerializeBufferWithMemberCopy(U8* buffPtr, Serializable::SizeType size)
        : ExternalSerializeBuffer(buffPtr, size) {}
    ExternalSerializeBufferWithMemberCopy() : ExternalSerializeBuffer() {}
    ~ExternalSerializeBufferWithMemberCopy() {}
    ExternalSerializeBufferWithMemberCopy(const ExternalSerializeBufferWithMemberCopy& src)
        : ExternalSerializeBuffer(src.m_buff, src.m_buffSize) {
        this->m_serLoc = src.m_serLoc;
        this->m_deserLoc = src.m_deserLoc;
    }
    ExternalSerializeBufferWithMemberCopy& operator=(const ExternalSerializeBufferWithMemberCopy& src) {
        // Ward against self-assignment
        if (this != &src) {
            this->setExtBuffer(src.m_buff, src.m_buffSize);
            this->m_serLoc = src.m_serLoc;
            this->m_deserLoc = src.m_deserLoc;
        }
        return *this;
    }
};

}  // namespace Fw
#endif