DataHeaders.hpp

Go to the documentation of this file.

#pragma ident "$Id: DataHeaders.hpp 1940 2009-06-13 11:10:37Z architest $"

#ifndef GPSTK_DATAHEADERS_HPP
#define GPSTK_DATAHEADERS_HPP

//============================================================================
//
//  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
//
//  Dagoberto Salazar - gAGE ( http://www.gage.es ). 2007, 2008, 2009
//
//============================================================================


#include <string>
#include "SatID.hpp"
#include "TypeID.hpp"
#include "SourceID.hpp"
#include "DayTime.hpp"
#include "Triple.hpp"



namespace gpstk
{



   struct sourceHeader
   {

      SourceID source;


      sourceHeader() {};


      sourceHeader( const SourceID::SourceType& st,
                    const std::string& name )
      { source.type = st; source.sourceName = name; };


      sourceHeader(const SourceID& sI)
         : source(sI)
      {};


      sourceHeader(const sourceHeader& sH)
      { source = sH.source; };


      virtual sourceHeader& operator=(const sourceHeader& right);


      virtual sourceHeader& operator=(const SourceID& right)
      { source = right; return *this; };


      virtual std::ostream& dump(std::ostream& s) const;


      virtual ~sourceHeader() {};


   }; // End of struct 'sourceHeader'



   std::ostream& operator<<( std::ostream& s,
                             const sourceHeader& sh );



   struct sourceEpochHeader : public sourceHeader
   {

      DayTime epoch;


      sourceEpochHeader() {};


      sourceEpochHeader( const SourceID::SourceType& st,
                         const std::string& sourcename,
                         const DayTime& time )
         : epoch(time)
      { source.type = st; source.sourceName = sourcename; };


      sourceEpochHeader( const SourceID& sI,
                         const DayTime& time )
         : epoch(time)
      { source = sI; };


      sourceEpochHeader( const sourceHeader& sh,
                         const DayTime& time )
         : sourceHeader(sh), epoch(time)
      {};


      sourceEpochHeader( const sourceEpochHeader& seh )
         : epoch(seh.epoch)
      { source = seh.source; };


      virtual sourceEpochHeader& operator=(const sourceEpochHeader& right);


      virtual sourceEpochHeader& operator=(const sourceHeader& right)
      { source = right.source; return (*this); };


      virtual sourceEpochHeader& operator=(const SourceID& right)
      { source = right; return (*this); };


      virtual std::ostream& dump(std::ostream& s) const;


      virtual ~sourceEpochHeader() {};


   }; // End of struct 'sourceEpochHeader'



   std::ostream& operator<<( std::ostream& s,
                             const sourceEpochHeader& seh );



   struct sourceEpochRinexHeader : public sourceEpochHeader
   {

      std::string antennaType;


      Triple antennaPosition;


      short epochFlag;


      sourceEpochRinexHeader() {};


      sourceEpochRinexHeader( const SourceID::SourceType& st,
                              const std::string& sourcename,
                              const DayTime& time,
                              const std::string& antType,
                              const Triple& antPos,
                              const short& flag )
         : antennaType(antType), antennaPosition(antPos), epochFlag(flag)
      { source.type = st; source.sourceName = sourcename; epoch = time; };


      sourceEpochRinexHeader( const SourceID& sI,
                              const DayTime& time,
                              const std::string& antType,
                              const Triple& antPos,
                              const short& flag )
         : antennaType(antType), antennaPosition(antPos), epochFlag(flag)
      { source = sI; epoch = time; };


      sourceEpochRinexHeader( const sourceHeader& sh,
                              const DayTime& time,
                              const std::string& antType,
                              const Triple& antPos,
                              const short& flag );


      sourceEpochRinexHeader(const sourceEpochHeader& seh)
         : sourceEpochHeader(seh)
      {};


      sourceEpochRinexHeader( const sourceEpochHeader& seh,
                              const std::string& antType,
                              const Triple& antPos,
                              const short& flag )
         : sourceEpochHeader(seh), antennaType(antType),
           antennaPosition(antPos), epochFlag(flag)
      {};


      sourceEpochRinexHeader(const sourceEpochRinexHeader& serh)
         : antennaType(serh.antennaType), antennaPosition(serh.antennaPosition),
           epochFlag(serh.epochFlag)
      { source = serh.source; epoch = serh.epoch; };


      virtual sourceEpochRinexHeader& operator=(
                                          const sourceEpochRinexHeader& right);


      virtual sourceEpochRinexHeader& operator=(const sourceEpochHeader& right)
      { source = right.source; epoch = right.epoch; return (*this); };


      virtual sourceEpochRinexHeader& operator=(const sourceHeader& right)
      { source = right.source; return (*this); };


      virtual sourceEpochRinexHeader& operator=(const SourceID& right)
      { source = right; return (*this); };


      virtual std::ostream& dump(std::ostream& s) const;


      virtual ~sourceEpochRinexHeader() {};


   }; // End of struct 'sourceEpochRinexHeader'



   std::ostream& operator<<( std::ostream& s,
                             const sourceEpochRinexHeader& serh );



   struct sourceTypeHeader : public sourceHeader
   {

      TypeID type;


      sourceTypeHeader() {};


      sourceTypeHeader( const SourceID::SourceType& st,
                        const std::string& sourcename,
                        const TypeID& datatype )
         : type(datatype)
      { source.type = st; source.sourceName = sourcename; };


      sourceTypeHeader( const SourceID& sI,
                        const TypeID& datatype )
         : type(datatype)
      { source = sI; };


      sourceTypeHeader( const sourceHeader& sh,
                        const TypeID& datatype )
         : sourceHeader(sh), type(datatype)
      {};


      sourceTypeHeader( const sourceTypeHeader& sth )
         : type(sth.type)
      { source = sth.source; };


      virtual sourceTypeHeader& operator=(const sourceTypeHeader& right);


      virtual sourceTypeHeader& operator=(const sourceHeader& right)
      { source = right.source; return (*this); };


      virtual sourceTypeHeader& operator=(const SourceID& right)
      { source = right; return (*this); };


      virtual std::ostream& dump(std::ostream& s) const;


      virtual ~sourceTypeHeader() {};


   }; // End of struct 'sourceTypeHeader'



   std::ostream& operator<<( std::ostream& s,
                             const sourceTypeHeader& sth );



   struct sourceSatHeader : public sourceHeader
   {

      SatID satellite;


      sourceSatHeader() {};


      sourceSatHeader( const SourceID::SourceType& st,
                       const std::string& sourcename,
                       const SatID& sat )
         : satellite(sat)
      { source.type = st; source.sourceName = sourcename; };


      sourceSatHeader( const SourceID& sI,
                       const SatID& sat )
         : satellite(sat)
      { source = sI; };


      sourceSatHeader( const sourceHeader& sh,
                       const SatID& sat )
         : sourceHeader(sh), satellite(sat)
      {};


      sourceSatHeader( const sourceSatHeader& ssh )
         : satellite(ssh.satellite)
      { source = ssh.source; };


      virtual sourceSatHeader& operator=(const sourceSatHeader& right);


      virtual sourceSatHeader& operator=(const sourceHeader& right)
      { source = right.source; return (*this); };


      virtual sourceSatHeader& operator=(const SourceID& right)
      { source = right; return (*this); };


      virtual std::ostream& dump(std::ostream& s) const;


      virtual ~sourceSatHeader() {};


   }; // End of struct 'sourceSatHeader'



   std::ostream& operator<<( std::ostream& s,
                             const sourceSatHeader& ssh );



   struct sourceEpochSatHeader : public sourceEpochHeader
   {

      SatID satellite;


      sourceEpochSatHeader() {};


      sourceEpochSatHeader( const SourceID::SourceType& st,
                            const std::string& sourcename,
                            const DayTime& time,
                            const SatID& sat )
         : satellite(sat)
      { source.type = st; source.sourceName = sourcename; epoch = time; };


      sourceEpochSatHeader( const SourceID& sI,
                            const DayTime& time,
                            const SatID& sat )
         : satellite(sat)
      { source = sI; epoch = time; };


      sourceEpochSatHeader( const sourceHeader& sh,
                            const DayTime& time,
                            const SatID& sat )
         : satellite(sat)
      { source = sh.source; epoch = time; };


      sourceEpochSatHeader( const sourceEpochHeader& seh,
                            const SatID& sat )
         : satellite(sat)
      { source = seh.source; epoch = seh.epoch; };


      sourceEpochSatHeader( const sourceEpochSatHeader& sesh )
         : satellite(sesh.satellite)
      { source = sesh.source; epoch = sesh.epoch; };


      virtual sourceEpochSatHeader& operator=(
                                          const sourceEpochSatHeader& right );


      virtual sourceEpochSatHeader& operator=(const sourceEpochHeader& right)
      { source = right.source; epoch = right.epoch; return (*this); };


      virtual sourceEpochSatHeader& operator=(const sourceHeader& right)
      { source = right.source; return (*this); };


      virtual sourceEpochSatHeader& operator=(const SourceID& right)
      { source = right; return (*this); };


      virtual std::ostream& dump(std::ostream& s) const;


      virtual ~sourceEpochSatHeader() {};


   }; // End of struct 'sourceEpochSatHeader'



   std::ostream& operator<<( std::ostream& s,
                             const sourceEpochSatHeader& sesh );



   struct sourceEpochTypeHeader : public sourceEpochHeader
   {

      TypeID type;


      sourceEpochTypeHeader() {};


      sourceEpochTypeHeader( const SourceID::SourceType& st,
                             const std::string& sourcename,
                             const DayTime& time,
                             const TypeID& datatype )
         : type(datatype)
      { source.type = st; source.sourceName = sourcename; epoch = time; };


      sourceEpochTypeHeader( const SourceID& sI,
                             const DayTime& time,
                             const TypeID& datatype )
         : type(datatype)
      { source = sI; epoch = time; };


      sourceEpochTypeHeader( const sourceHeader& sh,
                             const DayTime& time,
                             const TypeID& datatype )
         : type(datatype)
      { source = sh.source; epoch = time; };


      sourceEpochTypeHeader( const sourceEpochHeader& seh,
                             const TypeID& datatype )
         : type(datatype)
      { source = seh.source; epoch = seh.epoch; };


      sourceEpochTypeHeader( const sourceEpochTypeHeader& sesh )
         : type(sesh.type)
      { source = sesh.source; epoch = sesh.epoch; };


      virtual sourceEpochTypeHeader& operator=(
                                          const sourceEpochTypeHeader& right );


      virtual sourceEpochTypeHeader& operator=(const sourceEpochHeader& right)
      { source = right.source; epoch = right.epoch; return (*this); };


      virtual sourceEpochTypeHeader& operator=(const sourceHeader& right)
      { source = right.source; return (*this); };


      virtual sourceEpochTypeHeader& operator=(const SourceID& right)
      { source = right; return (*this); };


      virtual std::ostream& dump(std::ostream& s) const;


      virtual ~sourceEpochTypeHeader() {};


   }; // End of struct 'sourceEpochTypeHeader'



   std::ostream& operator<<( std::ostream& s,
                             const sourceEpochTypeHeader& seth );




}  // End of namespace gpstk

#endif   // GPSTK_DATAHEADERS_HPP

---