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;  

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

  public:
    virtual SerializeStatus serializeTo(SerializeBufferBase& buffer) const = 0;  

    virtual SerializeStatus deserializeFrom(SerializeBufferBase& buffer) = 0;  

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

    SerializeStatus serialize(SerializeBufferBase& buffer) const { return this->serializeTo(buffer); }

    SerializeStatus deserialize(SerializeBufferBase& buffer) { 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 Serialization {
  public:
    enum t {
        INCLUDE_LENGTH,  
        OMIT_LENGTH      
    };
};

class SerializeBufferBase {
    friend class SerializeBufferBaseTester;

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

  public:
    virtual ~SerializeBufferBase();  

    // Serialization for built-in types

    SerializeStatus serializeFrom(U8 val);  
    SerializeStatus serializeFrom(I8 val);  

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

    SerializeStatus serializeFrom(
        const void* val);  

    SerializeStatus serializeFrom(const U8* buff, FwSizeType length);

    SerializeStatus serializeFrom(const U8* buff, FwSizeType length, Serialization::t mode);

    SerializeStatus serializeFrom(const SerializeBufferBase& val);  

    SerializeStatus serializeFrom(
        const Serializable& val);  

    SerializeStatus serializeSize(const FwSizeType size);  

    // Deserialization for built-in types

    SerializeStatus deserializeTo(U8& val);  
    SerializeStatus deserializeTo(I8& val);  

#if FW_HAS_16_BIT == 1
    SerializeStatus deserializeTo(U16& val);  
    SerializeStatus deserializeTo(I16& val);  
#endif

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

    SerializeStatus deserializeTo(void*& val);  

    SerializeStatus deserializeTo(U8* buff, FwSizeType& length);  

    SerializeStatus deserializeTo(U8* buff, FwSizeType& length, Serialization::t mode);

    SerializeStatus deserializeTo(Serializable& val);  

    SerializeStatus deserializeTo(SerializeBufferBase& val);  

    SerializeStatus deserializeSize(FwSizeType& size);  

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

    SerializeStatus serialize(U8 val);
    SerializeStatus serialize(I8 val);
#if FW_HAS_16_BIT == 1
    SerializeStatus serialize(U16 val);
    SerializeStatus serialize(I16 val);
#endif
#if FW_HAS_32_BIT == 1
    SerializeStatus serialize(U32 val);
    SerializeStatus serialize(I32 val);
#endif
#if FW_HAS_64_BIT == 1
    SerializeStatus serialize(U64 val);
    SerializeStatus serialize(I64 val);
#endif
    SerializeStatus serialize(F32 val);
    SerializeStatus serialize(F64 val);
    SerializeStatus serialize(bool val);
    SerializeStatus serialize(const void* val);
    DEPRECATED(SerializeStatus serialize(const U8* buff, FwSizeType length, bool noLength),
               "Use serialize(const U8* buff, FwSizeType length, Serialization::t mode) instead");
    SerializeStatus serialize(const U8* buff, FwSizeType length);
    SerializeStatus serialize(const U8* buff, FwSizeType length, Serialization::t mode);
    SerializeStatus serialize(const Serializable& val);
    SerializeStatus serialize(const SerializeBufferBase& val);

    SerializeStatus deserialize(U8& val);
    SerializeStatus deserialize(I8& val);
#if FW_HAS_16_BIT == 1
    SerializeStatus deserialize(U16& val);
    SerializeStatus deserialize(I16& val);
#endif
#if FW_HAS_32_BIT == 1
    SerializeStatus deserialize(U32& val);
    SerializeStatus deserialize(I32& val);
#endif
#if FW_HAS_64_BIT == 1
    SerializeStatus deserialize(U64& val);
    SerializeStatus deserialize(I64& val);
#endif
    SerializeStatus deserialize(F32& val);
    SerializeStatus deserialize(F64& val);
    SerializeStatus deserialize(bool& val);
    SerializeStatus deserialize(void*& val);
    DEPRECATED(SerializeStatus deserialize(U8* buff, FwSizeType& length, bool noLength),
               "Use deserialize(U8* buff, FwSizeType& length, Serialization::t mode) instead");
    SerializeStatus deserialize(U8* buff, FwSizeType& length);
    SerializeStatus deserialize(U8* buff, FwSizeType& length, Serialization::t mode);
    SerializeStatus deserialize(Serializable& val);
    SerializeStatus deserialize(SerializeBufferBase& val);

    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