BinexData.hpp

Go to the documentation of this file.

#pragma ident "$Id: BinexData.hpp 1895 2009-05-12 19:34:29Z afarris $"

//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk 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 2.1 of the License, or
//  any later version.
//
//  The GPSTk 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 GPSTk; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  Copyright 2008, The University of Texas at Austin
//
//============================================================================

#ifndef GPSTK_BINEXDATA_HPP
#define GPSTK_BINEXDATA_HPP

#include "gpstkplatform.h"

#include "BinUtils.hpp"
#include "FFData.hpp"
#include "FFStream.hpp"

namespace gpstk
{

   class BinexData : public FFData
   {
   public:

      // Establish the endianness of the native platform
   #if BYTE_ORDER == LITTLE_ENDIAN
      static const bool nativeLittleEndian = true;
   #else
      static const bool nativeLittleEndian = false;
   #endif

      static const unsigned long INVALID_RECORD_ID    = 0xFFFFFFFF;

      static const unsigned char DEFAULT_RECORD_FLAGS = 0x20;
      static const unsigned char VALID_RECORD_FLAGS   = 0x38;

         // 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:

         static const unsigned long  MIN_VALUE = 0;
         static const unsigned long  MAX_VALUE = 536870911;
         static const unsigned char  MAX_BYTES = 4;

         UBNXI();

         UBNXI(const UBNXI& other)
         {
            *this = other;
         };

         UBNXI(unsigned long ul)
            throw(FFStreamError);

         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)
             throw(FFStreamError);

         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)
            throw(FFStreamError);

         size_t
         write(std::ostream& strm,
               std::string   *outBuffer   = NULL,
               size_t        offset       = 0,
               bool          reverseBytes = false,
               bool          littleEndian = false) const
            throw(FFStreamError);

      protected:

         unsigned long value;
         size_t        size;
      };

      class MGFZI
      {
      public:

         static const long long      MIN_VALUE = -1157442765409226759LL;
         static const long long      MAX_VALUE =  1157442765409226759LL;
         static const unsigned char  MAX_BYTES =  8;

         MGFZI();

         MGFZI(const MGFZI& other)
         {
            *this = other;
         };

         MGFZI(long long ll)
            throw(FFStreamError);

         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)
            throw(FFStreamError);

         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)
            throw(FFStreamError);

         size_t
         write(std::ostream& strm,
               std::string *outBuffer   = NULL,
               size_t      offset       = 0,
               bool        reverseBytes = false,
               bool        littleEndian = false) const
            throw(FFStreamError);

      protected:

         long long value;
         size_t    size;
      };



      BinexData();

      BinexData(const BinexData& other);

      BinexData(unsigned long recordID,
                unsigned char recordFlags = DEFAULT_RECORD_FLAGS)
         throw();

      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 unsigned char
      getRecordFlags() const
      {
            // Return only essential, valid flag bits listed in recordFlagMask
         return syncByte & VALID_RECORD_FLAGS;
      };

      BinexData&
      setRecordFlags(unsigned char flags = DEFAULT_RECORD_FLAGS);

      inline unsigned long
      getRecordID() const
      {
         return recID;         
      };

      BinexData&
      setRecordID(unsigned long id)
         throw(FFStreamError);

      size_t
      getRecordSize() const;

      BinexData&
      clearMessage();

      BinexData&
      ensureMessageCapacity(size_t cap)
         throw(FFStreamError);

      inline size_t
      getMessageLength() const
      {
         return msg.size();
      };

      inline size_t
      getMessageCapacity() const
      {
         return msg.capacity();
      };

      //inline const char*
      inline const std::string&
      getMessageData() const
      {
         //return msg.data();
         return msg;
      };

      BinexData&
      updateMessageData(
         size_t&      offset,
         const UBNXI& data)
            throw(FFStreamError, InvalidParameter);

      BinexData&
      updateMessageData(
         size_t&      offset,
         const MGFZI& data)
            throw(FFStreamError, InvalidParameter);

      BinexData&
      updateMessageData(
         size_t&            offset,
         const std::string& data,
         size_t             size)
            throw(FFStreamError, InvalidParameter);

      BinexData&
      updateMessageData(
         size_t&     offset,
         const char  *data,
         size_t      size)
            throw(FFStreamError, InvalidParameter);

      template<class T>
      BinexData&
      updateMessageData(
         size_t&      offset,
         const T&     data,
         size_t       size)
            throw(FFStreamError, InvalidParameter)
      {
         if (size > sizeof(T) )
         {
            std::ostringstream errStrm;
            errStrm << "Invalid data size: " << size;
            InvalidParameter ip(errStrm.str() );
            GPSTK_THROW(ip);
         }
         bool   littleEndian  = ( (syncByte & eBigEndian) == 0) ? true : false;
         if (littleEndian == nativeLittleEndian)
         {
            msg.replace(offset, size, reinterpret_cast<const char*>(&data), size);
         }
         else
         {
            T tmpData(data);
            BinUtils::twiddle(tmpData);
            msg.replace(offset, size, reinterpret_cast<const char*>(&tmpData), size);
         }
         offset += size;
         return *this;

      } // BinexData::updateMessageData()

      void
      extractMessageData(
         size_t& offset,
         UBNXI&  data)
            throw(FFStreamError, InvalidParameter);

      void
      extractMessageData(
         size_t& offset,
         MGFZI&  data)
            throw(FFStreamError, InvalidParameter);

      void
      extractMessageData(
         size_t&      offset,
         std::string& data,
         size_t       size) const
            throw(InvalidParameter);

      template<class T>
      void
      extractMessageData(
         size_t&      offset,
         T&           data,
         size_t       size) const
            throw(FFStreamError, InvalidParameter)
      {
         if (size > sizeof(T) )
         {
            std::ostringstream errStrm;
            errStrm << "Data size invalid: " << size;
            InvalidParameter ip(errStrm.str() );
            GPSTK_THROW(ip);
         }  
         if (offset + size > msg.size() )
         {
            std::ostringstream errStrm;
            errStrm << "Message buffer offset invalid: " << offset;
            InvalidParameter ip(errStrm.str() );
            GPSTK_THROW(ip);
         }  
         bool littleEndian  = ( (syncByte & eBigEndian) == 0) ? true : false;
         msg.copy(reinterpret_cast<char*>(&data), size, offset);
         if (littleEndian != nativeLittleEndian)
         {
            BinUtils::twiddle(data);
         }
         offset += size;

      } // BinexData::extractMessageData()


   protected:

      virtual void
      reallyPutRecord(FFStream& s) const
         throw(std::exception, FFStreamError, 
               StringUtils::StringException);     

      virtual void
      reallyGetRecord(FFStream& s) 
         throw(std::exception, FFStreamError,
               StringUtils::StringException);

      void getCRC(const std::string& head,
                  const std::string& message,
                  std::string&       crc) const;

      size_t
      getCRCLength(size_t crcDataLen) const;

      bool
      isHeadSyncByteValid(unsigned char  headSync,
                          unsigned char& expectedTailSync) const;

      bool
      isTailSyncByteValid(unsigned char  tailSync,
                          unsigned char& expectedHeadSync) const;
      static unsigned long long
      parseBuffer(const std::string&  buffer,
                  size_t              offset,
                  size_t              size)
         throw(FFStreamError);

      static void
      reverseBuffer(unsigned char *buffer,
                    size_t        bufferLength);

      static void
      reverseBuffer(std::string& buffer,
                    size_t       offset = 0,
                    size_t       n      = std::string::npos);

      unsigned char  syncByte;  
      unsigned long  recID;     
      std::string    msg;       


   private:

   };  // class BinexData


} // namespace gpstk


#endif // GPSTK_BINEXDATA_HPP

---