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