Variable.hpp

Go to the documentation of this file.

#pragma ident "$Id: Variable.hpp 2595 2011-05-14 17:22:04Z yanweignss $"

#ifndef GPSTK_VARIABLE_HPP
#define GPSTK_VARIABLE_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 "DataStructures.hpp"
#include "StochasticModel.hpp"



namespace gpstk
{



   class Variable
   {
   public:

      Variable();


      Variable( const TypeID& type,
                StochasticModel* pModel   = &Variable::defaultModel,
                bool sourceIndexed        = true,
                bool satIndexed           = false,
                double variance           = 4.0e14,
                double coef               = 1.0,
                bool forceCoef            = false );


      TypeID getType() const
      { return varType; };


      Variable& setType(const TypeID& type)
      { varType = type; return (*this); };


      StochasticModel* getModel() const
      { return pVarModel; };


      Variable& setModel(StochasticModel* pModel)
      { pVarModel = pModel; return (*this); };


      bool getSourceIndexed() const
      { return isSourceIndexed; };


      Variable& setSourceIndexed(bool sourceIndexed)
      { isSourceIndexed = sourceIndexed; return (*this); };


      bool getSatIndexed() const
      { return isSatIndexed; };


      Variable& setSatIndexed(bool satIndexed)
      { isSatIndexed = satIndexed; return (*this); };


          bool getTypeIndexed() const
          { return isTypeIndexed; };


      Variable& setTypeIndexed(bool typeIndexed)
      { isTypeIndexed = typeIndexed; return (*this); };


      double getInitialVariance() const
      { return initialVariance; };


      Variable& setInitialVariance(double variance)
      { initialVariance = variance; return (*this); };


      double getDefaultCoefficient() const
      { return defaultCoefficient; };


      Variable& setDefaultCoefficient(double coef)
      { defaultCoefficient = coef; return (*this); };


      bool isDefaultForced() const
      { return forceDefault; };


      Variable& setDefaultForced(bool forceCoef)
      { forceDefault = forceCoef; return (*this); };


      SourceID getSource() const
      { return varSource; };


      Variable& setSource(const SourceID& source)
      { varSource = source; return (*this); };



      SatID getSatellite() const
      { return varSat; };


      Variable& setSatellite(const SatID& satellite)
      { varSat = satellite; return (*this); };


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


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


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


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


      static SourceID allSources;


      static SourceID someSources;


      static SatID noSats;


      static SatID allSats;


      static SatID allGPSSats;


      static SatID allGalileoSats;


      static SatID allGlonassSats;


      static WhiteNoiseModel defaultModel;


      virtual ~Variable() {};


   private:


      TypeID varType;


      StochasticModel* pVarModel;


      bool isSourceIndexed;


      bool isSatIndexed;

      
      bool isTypeIndexed;        


      double initialVariance;


      double defaultCoefficient;


      bool forceDefault;


      SourceID varSource;


      SatID varSat;


      void Init( const TypeID& type,
                 StochasticModel* pModel = &Variable::defaultModel,
                 double variance = 4.0e14,
                 double coef     = 1.0,
                 bool forceCoef  = false,
                 bool typeIndex  = true);


   }; // End of class 'Variable'



   typedef std::set<Variable> VariableSet;

   typedef std::list<Variable> VariableList;

   typedef std::map<Variable, double> VariableDataMap;


   namespace StringUtils
   {
      inline std::string asString(const Variable& v)
      {
         std::ostringstream oss;
         oss << v.getType() << "   "
             << v.getSource() << "   "
             << v.getSatellite() << "   "
             << v.getTypeIndexed() << " "
             << v.getSourceIndexed() << " "
             << v.getSatIndexed();

         return oss.str();
      }
   }

}  // End of namespace gpstk
#endif   // GPSTK_VARIABLE_HPP

---