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 <FpConfig.hpp>
#include <Fw/Types/SerialBuffer.hpp>
#include <Fw/Types/Serializable.hpp>
 
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;
 
        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;
 
        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 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;
 
        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;
 
        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;
 
        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;
 
  };
 
}
 
#endif