Serializable.hpp

Go to the documentation of this file.

#ifndef SERIALIZABLE_HPP
#define SERIALIZABLE_HPP
 
#ifdef BUILD_UT
#include <iostream>
#endif
 
#include <FpConfig.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 = NATIVE_UINT_TYPE;
 
  public:
    virtual SerializeStatus serialize(SerializeBufferBase& buffer) const = 0;  
    virtual SerializeStatus deserialize(SerializeBufferBase& buffer) = 0;      
#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 {
  protected:
    SerializeBufferBase& operator=(const SerializeBufferBase& src);  
 
  public:
    virtual ~SerializeBufferBase();  
 
    // Serialization for built-in types
 
    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);  
#if FW_HAS_F64
    SerializeStatus serialize(F64 val);  
#endif
    SerializeStatus serialize(bool val);  
 
    SerializeStatus serialize(
        const void* val);  
 
    SerializeStatus serialize(const U8* buff, NATIVE_UINT_TYPE length, bool noLength);
    SerializeStatus serialize(const U8* buff, NATIVE_UINT_TYPE length);
 
    SerializeStatus serialize(const U8* buff, FwSizeType length, Serialization::t mode);
 
    SerializeStatus serialize(const SerializeBufferBase& val);  
 
    SerializeStatus serialize(const Serializable& val);  
 
    SerializeStatus serializeSize(const FwSizeType size);  
 
    // Deserialization for built-in types
 
    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);  
#if FW_HAS_F64
    SerializeStatus deserialize(F64& val);  
#endif
    SerializeStatus deserialize(bool& val);  
 
    SerializeStatus deserialize(void*& val);  
 
    SerializeStatus deserialize(U8* buff, NATIVE_UINT_TYPE& length, bool noLength);
 
    SerializeStatus deserialize(U8* buff, NATIVE_UINT_TYPE& length);
    SerializeStatus deserialize(U8* buff, FwSizeType& length, Serialization::t mode);
 
    SerializeStatus deserialize(Serializable& val);  
 
    SerializeStatus deserialize(SerializeBufferBase& val);  
 
    SerializeStatus deserializeSize(FwSizeType& size);  
 
    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();  
 
  PRIVATE:
    // Copy constructor can be used only by the implementation
    SerializeBufferBase(const SerializeBufferBase& src);  
 
 
    void copyFrom(const SerializeBufferBase& src);  
    Serializable::SizeType m_serLoc;                
    Serializable::SizeType m_deserLoc;              
};
 
// 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() {}
    explicit ExternalSerializeBufferWithMemberCopy(const ExternalSerializeBufferWithMemberCopy& src)
        : ExternalSerializeBuffer(src.m_buff, src.m_buffSize) {}
    ExternalSerializeBufferWithMemberCopy& operator=(const ExternalSerializeBufferWithMemberCopy& src) {
        // Ward against self-assignment
        if (this != &src) {
            this->m_buff = src.m_buff;
            this->m_buffSize = src.m_buffSize;
        }
        return *this;
    }
};
 
}  // namespace Fw
#endif