BinexData.hpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 3.0 of the License, or
//  any later version.
//
//  The GNSSTk is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin, under contract to an agency or agencies
//  within the U.S. Department of Defense. The U.S. Government retains all
//  rights to use, duplicate, distribute, disclose, or release this software.
//
//  Pursuant to DoD Directive 523024
//
//  DISTRIBUTION STATEMENT A: This software has been approved for public
//                            release, distribution is unlimited.
//
//==============================================================================
 
#ifndef GNSSTK_BINEXDATA_HPP
#define GNSSTK_BINEXDATA_HPP
 
#include "gnsstkplatform.h"
#include "gnsstk_export.h"
#include "BinUtils.hpp"
#include "FFData.hpp"
#include "FFStream.hpp"
 
namespace gnsstk
{
 
 
   class BinexData : public FFData
   {
   public:
 
         // The endianness of the native platform
      GNSSTK_EXPORT static const bool nativeLittleEndian;
 
      typedef uint32_t  RecordID;  
      typedef uint8_t   SyncByte;  
 
      GNSSTK_EXPORT static const RecordID  INVALID_RECORD_ID;     
 
      GNSSTK_EXPORT static const SyncByte  DEFAULT_RECORD_FLAGS;  
      GNSSTK_EXPORT static const SyncByte  VALID_RECORD_FLAGS;    
 
         // Flags indicating whether a record is reversed, whether a record
         // is big endian, and whether a record contains an enhanced CRC.
         // Combining these flags (via bitwise-or) helps create the
         // synchronization byte(s) for a BINEX record.
      enum recordFlagsEnum
      {
         eReverseReadable = 0x10,
         eBigEndian       = 0x20,
         eEnhancedCRC     = 0x08
      };
 
      class UBNXI
      {
      public:
 
         GNSSTK_EXPORT static const unsigned long  MIN_VALUE;  
         GNSSTK_EXPORT static const unsigned long  MAX_VALUE;  
         GNSSTK_EXPORT static const unsigned char  MAX_BYTES;  
 
         UBNXI();
 
         UBNXI(const UBNXI& other)
         {
            *this = other;
         };
 
         UBNXI(unsigned long ul);
 
         inline UBNXI&
         operator=(const UBNXI& right)
         {
            value = right.value;
            size  = right.size;
            return *this;
         };
 
         inline bool
         operator==(const UBNXI& other) const
         {
            return (value == other.value);
         };
 
         inline bool
         operator!=(const UBNXI& other) const
         {
            return (value != other.value);
         };
 
         inline bool
         operator<(const UBNXI& other) const
         {
            return (value < other.value);
         };
 
         inline bool
         operator<=(const UBNXI& other) const
         {
            return (value <= other.value);
         };
 
         inline bool
         operator>(const UBNXI& other) const
         {
            return (value > other.value);
         };
 
         inline bool
         operator>=(const UBNXI& other) const
         {
            return (value >= other.value);
         };
 
         inline
         operator unsigned long() const
         {
            return value;
         };
 
         inline size_t
         getSize() const
         {
            return size;
         };
 
         size_t
         decode(const std::string& inBuffer,
                size_t             offset       = 0,
                bool               littleEndian = false);
 
         size_t
         encode(std::string& outBuffer,
                size_t       offset       = 0,
                bool         littleEndian = false) const;
 
         size_t
         read(std::istream& strm,
              std::string   *outBuffer   = NULL,
              size_t        offset       = 0,
              bool          reverseBytes = false,
              bool          littleEndian = false);
 
         size_t
         write(std::ostream& strm,
               std::string   *outBuffer   = NULL,
               size_t        offset       = 0,
               bool          reverseBytes = false,
               bool          littleEndian = false) const;
 
      protected:
 
         unsigned long value;
         size_t        size;
      };
 
      class MGFZI
      {
      public:
 
         GNSSTK_EXPORT static const long long      MIN_VALUE;  
         GNSSTK_EXPORT static const long long      MAX_VALUE;  
         GNSSTK_EXPORT static const unsigned char  MAX_BYTES;  
 
         MGFZI();
 
         MGFZI(const MGFZI& other)
         {
            *this = other;
         };
 
         MGFZI(long long ll);
 
         inline MGFZI&
         operator=(const MGFZI& right)
         {
            value = right.value;
            size  = right.size;
            return *this;
         };
 
         inline bool
         operator==(const MGFZI& other) const
         {
            return (value == other.value);
         };
 
         inline bool
         operator!=(const MGFZI& other) const
         {
            return (value != other.value);
         };
 
         inline bool
         operator<(const MGFZI& other) const
         {
            return (value < other.value);
         };
 
         inline bool
         operator<=(const MGFZI& other) const
         {
            return (value <= other.value);
         };
 
         inline bool
         operator>(const MGFZI& other) const
         {
            return (value > other.value);
         };
 
         inline bool
         operator>=(const MGFZI& other) const
         {
            return (value >= other.value);
         };
 
         inline
         operator long long() const
         {
            return value;
         };
 
         inline size_t
         getSize() const
         {
            return size;
         };
 
         size_t
         decode(const std::string& inBuffer,
                size_t             offset       = 0,
                bool               littleEndian = false);
 
         size_t
         encode(std::string& outBuffer,
                size_t       offset       = 0,
                bool         littleEndian = false) const;
 
         size_t
         read(std::istream& strm,
              std::string *outBuffer   = NULL,
              size_t      offset       = 0,
              bool        reverseBytes = false,
              bool        littleEndian = false);
 
         size_t
         write(std::ostream& strm,
               std::string *outBuffer   = NULL,
               size_t      offset       = 0,
               bool        reverseBytes = false,
               bool        littleEndian = false) const;
 
      protected:
 
         long long value;
         size_t    size;
      };
 
      BinexData();
 
      BinexData(const BinexData& other);
 
      BinexData(RecordID recordID,
                SyncByte recordFlags = DEFAULT_RECORD_FLAGS)
         noexcept;
 
      BinexData&
      operator=(const BinexData& right);
 
      virtual
      ~BinexData() {};
 
      virtual bool
      isData(void) const
      {
         return true;
      }
 
      virtual void
      dump(std::ostream& s) const;
 
      bool
      operator==(const BinexData& b) const;
 
      inline SyncByte
      getRecordFlags() const
      {
            // Return only essential, valid flag bits listed in recordFlagMask
         return syncByte & VALID_RECORD_FLAGS;
      };
 
      BinexData&
      setRecordFlags(SyncByte flags = DEFAULT_RECORD_FLAGS);
 
      inline RecordID
      getRecordID() const
      {
         return recID;
      };
 
      BinexData&
      setRecordID(RecordID id);
 
      size_t
      getRecordSize() const;
 
      BinexData&
      clearMessage();
 
      BinexData&
      ensureMessageCapacity(size_t cap);
 
      size_t
      getHeadLength() const;
 
      inline size_t
      getMessageLength() const
      {
         return msg.size();
      };
 
      inline size_t
      getTailLength() const
      {
         return getRecordSize() - getHeadLength() - getMessageLength();
      };
 
      inline const std::string&
      getMessageData() const
      {
         return msg;
      };
 
      BinexData&
      updateMessageData(
         size_t&      offset,
         const UBNXI& data);
 
      BinexData&
      updateMessageData(
         size_t&      offset,
         const MGFZI& data);
 
      BinexData&
      updateMessageData(
         size_t&            offset,
         const std::string& data,
         size_t             size);
 
      BinexData&
      updateMessageData(
         size_t&     offset,
         const char  *data,
         size_t      size);
 
      template<class T>
      BinexData&
      updateMessageData(
         size_t&      offset,
         const T&     data,
         size_t       size)
      {
         if (size > sizeof(T) )
         {
            std::ostringstream errStrm;
            errStrm << "Invalid data size: " << size;
            InvalidParameter ip(errStrm.str() );
            GNSSTK_THROW(ip);
         }
         bool   littleEndian  = ( (syncByte & eBigEndian) == 0) ? true : false;
         msg.replace(offset, size, reinterpret_cast<const char*>(&data), size);
         if (littleEndian != nativeLittleEndian)
         {
               // host endian-ness does not match file endian-ness, so
               // reverse the bytes
            std::reverse(msg.begin()+offset, msg.begin()+offset+size);
         }
         offset += size;
         return *this;
 
      } // BinexData::updateMessageData()
 
      void
      extractMessageData(
         size_t& offset,
         UBNXI&  data);
 
      void
      extractMessageData(
         size_t& offset,
         MGFZI&  data);
 
      void
      extractMessageData(
         size_t&      offset,
         std::string& data,
         size_t       size) const;
 
      template<class T>
      void
      extractMessageData(
         size_t&      offset,
         T&           data,
         size_t       size) const
      {
         if (size > sizeof(T) )
         {
            std::ostringstream errStrm;
            errStrm << "Data size invalid: " << size;
            InvalidParameter ip(errStrm.str() );
            GNSSTK_THROW(ip);
         }
         if (offset + size > msg.size() )
         {
            std::ostringstream errStrm;
            errStrm << "Message buffer offset invalid: " << offset;
            InvalidParameter ip(errStrm.str() );
            GNSSTK_THROW(ip);
         }
         bool littleEndian  = ( (syncByte & eBigEndian) == 0) ? true : false;
         if (littleEndian)
            data = BinUtils::decodeVarLE<T>(msg, offset);
         else
            data = BinUtils::decodeVar<T>(msg, offset);
         offset += size;
 
      } // BinexData::extractMessageData()
 
 
      virtual void
      putRecord(std::ostream& s) const;
 
      virtual size_t
      getRecord(std::istream& s);
 
   protected:
 
      virtual void
      reallyPutRecord(FFStream& s) const;
 
      virtual void
      reallyGetRecord(FFStream& s);
 
      void getCRC(const std::string& head,
                  const std::string& message,
                  std::string&       crc) const;
 
      size_t
      getCRCLength(size_t crcDataLen) const;
 
      bool
      isHeadSyncByteValid(SyncByte  headSync,
                          SyncByte& expectedTailSync) const;
 
      bool
      isTailSyncByteValid(SyncByte  tailSync,
                          SyncByte& expectedHeadSync) const;
      static unsigned long long
      parseBuffer(const std::string&  buffer,
                  size_t              offset,
                  size_t              size);
 
   private:
 
      template <class T>
      static void reverseBytes(T& val);
 
      static void
      reverseBuffer(std::string& buffer,
                    size_t       offset = 0,
                    size_t       n      = std::string::npos);
 
      SyncByte     syncByte;  
      RecordID     recID;     
      std::string  msg;       
 
   };  // class BinexData
 
 
} // namespace gnsstk
 
 
#endif // GNSSTK_BINEXDATA_HPP