FilePacket.hpp

Go to the documentation of this file.

// ======================================================================
// \title  FilePacket.hpp
// \author bocchino
// \brief  hpp file for FilePacket
//
// \copyright
// Copyright 2009-2016, by the California Institute of Technology.
// ALL RIGHTS RESERVED.  United States Government Sponsorship
// acknowledged.
//
// ======================================================================

#ifndef Fw_FilePacket_HPP
#define Fw_FilePacket_HPP

#include <CFDP/Checksum/Checksum.hpp>
#include <Fw/Buffer/Buffer.hpp>
#include <Fw/FPrimeBasicTypes.hpp>
#include <Fw/Types/SerialBuffer.hpp>
#include <Fw/Types/Serializable.hpp>

// Forward declaration for UTs
namespace Svc {
class FileUplinkTester;
class FileDownlinkTester;
}  // namespace Svc

namespace Fw {

union FilePacket {
  public:
    // ----------------------------------------------------------------------
    // Types
    // ----------------------------------------------------------------------

    typedef enum { T_START = 0, T_DATA = 1, T_END = 2, T_CANCEL = 3, T_NONE = 255 } Type;

    class PathName {
        friend union FilePacket;
        friend class Svc::FileDownlinkTester;
        friend class Svc::FileUplinkTester;

      public:
        enum { MAX_LENGTH = 255 };

      private:
        U8 m_length;

        const char* m_value;

      public:
        void initialize(const char* const value  
        );

        U32 bufferSize() const;

        U32 getLength(void) const { return this->m_length; };

        const char* getValue(void) const { return this->m_value; };

      private:
        SerializeStatus fromSerialBuffer(SerialBuffer& serialBuffer);

        SerializeStatus toSerialBuffer(SerialBuffer& serialBuffer) const;
    };

    class Header {
        friend union FilePacket;
        friend class FilePacketTester;
        friend class Svc::FileDownlinkTester;
        friend class Svc::FileUplinkTester;

      private:
        Type m_type;

        U32 m_sequenceIndex;

      public:
        enum { HEADERSIZE = sizeof(U8) + sizeof(U32) };

      private:
        void initialize(const Type type,         
                        const U32 sequenceIndex  
        );

        U32 bufferSize() const;

        SerializeStatus fromSerialBuffer(SerialBuffer& serialBuffer);

        SerializeStatus toSerialBuffer(SerialBuffer& serialBuffer) const;

      public:
        Type getType(void) const { return this->m_type; };

        U32 getSequenceIndex(void) const { return this->m_sequenceIndex; };
    };

    struct StartPacket {
        friend union FilePacket;

      private:
        Header m_header;

        U32 m_fileSize;

        PathName m_sourcePath;

        PathName m_destinationPath;

      public:
        void initialize(const U32 fileSize,                
                        const char* const sourcePath,      
                        const char* const destinationPath  
        );

        U32 bufferSize() const;

        SerializeStatus toBuffer(Buffer& buffer) const;

        const FilePacket::Header& asHeader() const { return this->m_header; };

        const PathName& getDestinationPath() const { return this->m_destinationPath; };

        const PathName& getSourcePath() const { return this->m_sourcePath; };

        U32 getFileSize() const { return this->m_fileSize; };

      private:
        SerializeStatus fromSerialBuffer(SerialBuffer& serialBuffer);

        SerializeStatus toSerialBuffer(SerialBuffer& serialBuffer) const;
    };

    class DataPacket {
        friend union FilePacket;
        friend class Svc::FileDownlinkTester;
        friend class Svc::FileUplinkTester;

      private:
        Header m_header;

        U32 m_byteOffset;

        U16 m_dataSize;

        const U8* m_data;

      public:
        enum { HEADERSIZE = Header::HEADERSIZE + sizeof(U32) + sizeof(U16) };

        void initialize(const U32 sequenceIndex,  
                        const U32 byteOffset,     
                        const U16 dataSize,       
                        const U8* const data      
        );

        U32 bufferSize() const;

        SerializeStatus toBuffer(Buffer& buffer) const;

        const FilePacket::Header& asHeader() const { return this->m_header; };

        U32 getByteOffset() const { return this->m_byteOffset; };

        U32 getDataSize() const { return this->m_dataSize; };

        const U8* getData() const { return this->m_data; };

      private:
        SerializeStatus fromSerialBuffer(SerialBuffer& serialBuffer);

        U32 fixedLengthSize() const;

        SerializeStatus toSerialBuffer(SerialBuffer& serialBuffer) const;
    };

    class EndPacket {
        friend union FilePacket;
        friend class Svc::FileDownlinkTester;
        friend class Svc::FileUplinkTester;

      private:
        Header m_header;

      public:
        void setChecksum(const CFDP::Checksum& checksum);

        void getChecksum(CFDP::Checksum& checksum) const;

        U32 bufferSize() const;

        SerializeStatus toBuffer(Buffer& buffer) const;

        const FilePacket::Header& asHeader() const { return this->m_header; };

      public:
        void initialize(const U32 sequenceIndex,        
                        const CFDP::Checksum& checksum  
        );

      private:
        U32 m_checksumValue;

        SerializeStatus fromSerialBuffer(SerialBuffer& serialBuffer);

        SerializeStatus toSerialBuffer(SerialBuffer& serialBuffer) const;
    };

    class CancelPacket {
        friend union FilePacket;
        friend class Svc::FileDownlinkTester;
        friend class Svc::FileUplinkTester;

      private:
        Header m_header;

      public:
        void initialize(const U32 sequenceIndex  
        );

        U32 bufferSize() const;

        SerializeStatus toBuffer(Buffer& buffer) const;

        const FilePacket::Header& asHeader() const { return this->m_header; };

      private:
        SerializeStatus fromSerialBuffer(SerialBuffer& serialBuffer);
    };

  public:
    // ----------------------------------------------------------------------
    // Constructor
    // ----------------------------------------------------------------------

    FilePacket() { this->m_header.m_type = T_NONE; }

  public:
    // ----------------------------------------------------------------------
    // Public instance methods
    // ----------------------------------------------------------------------

    SerializeStatus fromBuffer(const Buffer& buffer);

    const Header& asHeader() const;

    const StartPacket& asStartPacket() const;

    const DataPacket& asDataPacket() const;

    const EndPacket& asEndPacket() const;

    const CancelPacket& asCancelPacket() const;

    void fromStartPacket(const StartPacket& startPacket);

    void fromDataPacket(const DataPacket& dataPacket);

    void fromEndPacket(const EndPacket& endPacket);

    void fromCancelPacket(const CancelPacket& cancelPacket);

    U32 bufferSize() const;

    SerializeStatus toBuffer(Buffer& buffer) const;

  private:
    // ----------------------------------------------------------------------
    // Private methods
    // ----------------------------------------------------------------------

    SerializeStatus fromSerialBuffer(SerialBuffer& serialBuffer);

  private:
    // ----------------------------------------------------------------------
    // Private data
    // ----------------------------------------------------------------------

    Header m_header;

    StartPacket m_startPacket;

    DataPacket m_dataPacket;

    EndPacket m_endPacket;

    CancelPacket m_cancelPacket;
};

}  // namespace Fw

#endif