SatID.hpp

Go to the documentation of this file.

#pragma ident "$Id: SatID.hpp 3184 2012-07-01 13:11:07Z yanweignss $"

#ifndef GPSTK_SATID_HPP
#define GPSTK_SATID_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., 51 Franklin Street, Fifth Floor, Boston, MA 02110, 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.
//
//=============================================================================

#include <iostream>
#include <iomanip>
#include <sstream>
#include "gps_constants.hpp"

namespace gpstk
{
   // forward declarations
   class SatID;
//   std::istream& operator<<(std::istream& s, SatID& p);

   class SatID
   {
   public:
      enum SatelliteSystem
      {
         systemGPS = 1,
         systemGalileo,
         systemGlonass,
         systemGeosync,
         systemLEO,
         systemTransit,
         systemCompass,
         systemMixed,
         systemUserDefined,
         systemUnknown
      };

      SatID() { id=-1; system=systemGPS; }

      SatID(int p, SatelliteSystem s) { id=p; system=s; }

      // operator=, copy constructor and destructor built by compiler

      static std::string convertSatelliteSystemToString(SatelliteSystem s)
      {
         switch(s)
         {
            case systemGPS:     return "GPS";           break;
            case systemGalileo: return "Galileo";       break;
            case systemGlonass: return "GLONASS";       break;
            case systemGeosync: return "Geostationary"; break;
            case systemLEO:     return "LEO";           break;
            case systemTransit: return "Transit";       break;
            case systemCompass: return "Compass";       break;
            case systemMixed:   return "Mixed";         break;
            case systemUserDefined:   return "UserDefined";         break;
            case systemUnknown: return "Unknown";       break;
            default:            return "??";            break;
         };
      }

      void dump(std::ostream& s) const
      {
         s << convertSatelliteSystemToString(system) << " " << id;
      }

      bool operator==(const SatID& right) const
      { return ((system == right.system) && (id == right.id)); }

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

      bool operator<(const SatID& right) const
      {
         if (system==right.system)
            return (id<right.id);
         return (system<right.system);
      }

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

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

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

      bool isValid() const
      {
         switch(system)
         {
            case systemGPS: return (id > 0 && id <= MAX_PRN_GPS);
            //case systemGalileo:
            //case systemGlonass:
            //case systemGeosync:
            //case systemLEO:
            //case systemTransit:
            default: return (id > 0 && id < 100);
         }
      }

      int id;                   
      SatelliteSystem system;   

   }; // class SatID

   namespace StringUtils
   {
      inline std::string asString(const SatID& p)
      {
         std::ostringstream oss;
         p.dump(oss);
         return oss.str();
      }
   }

   inline std::ostream& operator<<(std::ostream& s, const SatID& p)
   {
      p.dump(s);
      return s;
   }

} // namespace gpstk

#endif

---