ObsID.hpp

Go to the documentation of this file.

#pragma ident "$Id: ObsID.hpp 1901 2009-05-20 12:47:43Z ocibu $"

//============================================================================
//
//  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 2004, The University of Texas at Austin
//
//============================================================================

//============================================================================
//
//This software 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 OBSID_HPP
#define OBSID_HPP

#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <map>

#include "Exception.hpp"
#include "SatID.hpp"

namespace gpstk
{
   class ObsID;
   namespace StringUtils
   {
      std::string asString(const ObsID& id);
      std::string asRinex3ID(const ObsID& id);
   }


   std::ostream& operator<<(std::ostream& s, const ObsID& p);


   class ObsID
   {
   public:
      enum ObservationType
      {
         otUnknown,
         otAny,       
         otRange,     
         otPhase,     
         otDoppler,   
         otSNR,       
         otChannel,   
         otIono,      
         otSSI,       
         otLLI,       
         otTrackLen,  
         otUndefined,
         otLast       
      };


      enum CarrierBand
      {
         cbUnknown,
         cbAny,  
         cbZero, 
         cbL1,   
         cbL2,   
         cbL5,   
         cbG1,   
         cbG2,   
         cbE5b,  
         cbE5ab, 
         cbE6,   
         cbL1L2, 
         cbUndefined,
         cbLast  
      };


      enum TrackingCode
      {
         tcUnknown,
         tcAny,     
         tcCA,      
         tcP,       
         tcY,       
         tcW,       
         tcN,       
         tcD,       
         tcM,       
         tcC2M,     
         tcC2L,     
         tcC2LM,    
         tcI5,      
         tcQ5,      
         tcIQ5,     

         tcGCA,     
         tcGP,      

         tcA,       
         tcB,       
         tcC,       
         tcBC,      
         tcABC,     
         tcIE5,     
         tcQE5,     
         tcIQE5,    
         tcUndefined,
         tcLast     
      };

      ObsID()
         : type(otUnknown), band(cbUnknown), code(tcUnknown) {};

      ObsID(ObservationType ot, CarrierBand cb, TrackingCode tc)
         : type(ot), band(cb), code(tc) {};

      ObsID(const std::string& id) throw(InvalidParameter);
      ObsID(const char* id) throw(InvalidParameter)
      { *this=ObsID(std::string(id));};

      virtual bool operator==(const ObsID& right) const;

      virtual bool operator<(const ObsID& right) const;

      bool operator!=(const ObsID& right) const
      { return !(operator==(right)); };

      bool operator>(const ObsID& right) const
      {  return (!operator<(right) && !operator==(right)); };

      bool operator<=(const ObsID& right) const
      { return (operator<(right) || operator==(right)); };

      bool operator>=(const ObsID& right) const
      { return !(operator<(right)); };

      std::string asRinex3ID() const;

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

      virtual ~ObsID() {};

      static ObservationType newObservationType(const std::string& s);
      static CarrierBand newCarrierBand(const std::string& s);
      static TrackingCode newTrackingCode(const std::string& s);

      // Extend the standard identifiers with a new Rinex 3 style identifier. If
      // the specified id is already defined, an exception is thrown and the
      // existing definitions are not touched. If not then each character of the
      // specification is examined and the new ones are created. The returned
      // ObsID can then be examined for the assigned values.
      static ObsID newID(const std::string& id,
                         const std::string& desc="") throw(InvalidParameter);

      // Note that these are the only data members of objects of this class.
      ObservationType  type;
      CarrierBand      band;
      TrackingCode     code;

      static std::map< TrackingCode,    std::string > tcDesc;
      static std::map< CarrierBand,     std::string > cbDesc;
      static std::map< ObservationType, std::string > otDesc;

      static std::map< char, ObservationType> rinex2ot;
      static std::map< char, CarrierBand> rinex2cb;
      static std::map< char, TrackingCode> rinex2tc;
      static std::map< ObservationType, char > ot2Rinex;
      static std::map< CarrierBand, char > cb2Rinex;
      static std::map< TrackingCode, char> tc2Rinex;

      class Initializer
      {
      public:
         Initializer();
      };
      
      static Initializer singleton;

   private:
      static ObsID idCreator(const std::string& id, const std::string& desc="");

   }; // class ObsID

} // namespace gpstk
#endif   // OBSID_HPP

---