Serializable.hpp

Go to the documentation of this file.

#ifndef SERIALIZABLE_HPP
#define SERIALIZABLE_HPP
 
#ifdef BUILD_UT
#include <iostream>
#endif
 
#include <FpConfig.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:
            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 SerializeBufferBase {
        public:
 
            SerializeBufferBase& operator=(const SerializeBufferBase &src); 
 
            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 = false); 
 
            SerializeStatus serialize(const SerializeBufferBase& val); 
 
            SerializeStatus serialize(const Serializable &val); 
 
            // 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); 
 
            // length should be set to max, returned value is actual size stored. If noLength
            // is true, use the length variable as the actual number of bytes to deserialize
            SerializeStatus deserialize(U8* buff, NATIVE_UINT_TYPE& length, bool noLength = false); 
            // serialize/deserialize Serializable
 
 
            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 NATIVE_UINT_TYPE getBuffCapacity() const = 0; 
            NATIVE_UINT_TYPE getBuffLength() const; 
            NATIVE_UINT_TYPE getBuffLeft() const; 
            virtual U8* getBuffAddr() = 0; 
            virtual const U8* getBuffAddr() const = 0; 
            const U8* getBuffAddrLeft() const; 
            U8* getBuffAddrSer(); 
            SerializeStatus setBuff(const U8* src, NATIVE_UINT_TYPE length); 
            SerializeStatus setBuffLen(NATIVE_UINT_TYPE length); 
            SerializeStatus copyRaw(SerializeBufferBase& dest, NATIVE_UINT_TYPE size); 
                                                                                      // Will increment deserialization pointer
            SerializeStatus copyRawOffset(SerializeBufferBase& dest, NATIVE_UINT_TYPE 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:
            // A no-implementation copy constructor here will prevent the default copy constructor from being called
            // accidentally, and without an implementation it will create an error for the developer instead.
            SerializeBufferBase(const SerializeBufferBase &src); 
 
            void copyFrom(const SerializeBufferBase& src); 
            NATIVE_UINT_TYPE m_serLoc; 
            NATIVE_UINT_TYPE m_deserLoc; 
    };
 
    // Helper class for building buffers with external storage
 
    class ExternalSerializeBuffer : public SerializeBufferBase {
        public:
            ExternalSerializeBuffer(U8* buffPtr, NATIVE_UINT_TYPE size); 
            ExternalSerializeBuffer(); 
            void setExtBuffer(U8* buffPtr, NATIVE_UINT_TYPE size); 
            void clear(); 
 
            // pure virtual functions
            NATIVE_UINT_TYPE getBuffCapacity() const;
            U8* getBuffAddr();
            const U8* getBuffAddr() const ;
 
        PRIVATE:
 
            // no copying
            ExternalSerializeBuffer(ExternalSerializeBuffer& other);
            ExternalSerializeBuffer(ExternalSerializeBuffer* other);
 
            // private data
            U8* m_buff; 
            NATIVE_UINT_TYPE m_buffSize; 
    };
 
}
#endif