Namelist.hpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk 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 3.0 of the License, or
//  any later version.
//
//  The GNSSTk 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 GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was 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 CLASS_NAMELIST_INCLUDE
#define CLASS_NAMELIST_INCLUDE
 
//------------------------------------------------------------------------------------
// system includes
#include <algorithm>
#include <iomanip>
#include <ostream>
#include <sstream>
#include <string>
#include <vector>
// GNSSTk
#include "Matrix.hpp"
 
namespace gnsstk
{
 
   //---------------------------------------------------------------------------------
   class Namelist;            
 
   class LabeledVector
   {
   public:
      int wid;                
      int prec;               
      int form;               
      std::string msg;        
      std::string tag;        
      const Namelist &NL;     
      const Vector<double> &V;
 
      LabeledVector(const Namelist& nl, const Vector<double>& v)
         : wid(12), prec(5), form(1), NL(nl), V(v)
      {
      }
 
      LabeledVector& setw(int w)
      {
         wid = w;
         return *this;
      }
 
      LabeledVector& setprecision(int p)
      {
         prec = p;
         return *this;
      }
 
      LabeledVector& fixed()
      {
         form = 1;
         return *this;
      }
 
      LabeledVector& scientific()
      {
         form = 2;
         return *this;
      }
 
      LabeledVector& message(const std::string& m)
      {
         msg = m;
         return *this;
      }
 
      LabeledVector& linetag(const std::string& m)
      {
         tag = m;
         return *this;
      }
   };
 
   class LabeledMatrix
   {
   public:
      int wid;                
      int prec;               
      int form;               
      int rc;                 
      bool sym;               
      bool cln;               
      std::string msg;        
      std::string tag;        
      const Namelist &NLrows; 
      const Namelist &NLcols; 
      const Matrix<double> &M;
 
      LabeledMatrix(const Namelist& nl, const Matrix<double>& m)
         : sym(false), cln(false), wid(12), prec(5), form(1), rc(0), M(m),
           NLrows(nl), NLcols(nl)
      {
      }
 
      LabeledMatrix(const Namelist& nr, const Namelist& nc,
                    const Matrix<double>& m)
         : sym(false), cln(false), wid(12), prec(5), form(1), rc(0), M(m),
           NLrows(nr), NLcols(nc)
      {
      }
 
      LabeledMatrix& setw(int w)
      {
         wid = w;
         return *this;
      }
 
      LabeledMatrix& setprecision(int p)
      {
         prec = p;
         return *this;
      }
 
      LabeledMatrix& fixed()
      {
         form = 1;
         return *this;
      }
 
      LabeledMatrix& scientific()
      {
         form = 2;
         return *this;
      }
 
      LabeledMatrix& symmetric(bool s = true)
      {
         sym = s;
         return *this;
      }
 
      LabeledMatrix& clean(bool s = true)
      {
         cln = s;
         return *this;
      }
 
      LabeledMatrix& both()
      {
         rc = 0;
         return *this;
      }
 
      LabeledMatrix& rows()
      {
         rc = 1;
         return *this;
      }
 
      LabeledMatrix& cols()
      {
         rc = 2;
         return *this;
      }
 
      LabeledMatrix& message(const std::string& m)
      {
         msg = m;
         return *this;
      }
 
      LabeledMatrix& linetag(const std::string& m)
      {
         tag = m;
         return *this;
      }
   };
 
   std::ostream& operator<<(std::ostream& os, const LabeledMatrix& lm);
 
   std::ostream& operator<<(std::ostream& os, const LabeledVector& lv);
 
   //---------------------------------------------------------------------------------
   class Namelist
   {
      friend class SRI;
      friend std::ostream& operator<<(std::ostream& os, const LabeledMatrix& N);
      friend std::ostream& operator<<(std::ostream& os, const LabeledVector& N);
 
   public:
      Namelist() {}
 
      Namelist(const unsigned int& n);
 
      Namelist(const std::vector<std::string>& names);
 
      Namelist(const Namelist& names) { labels = names.labels; }
 
      ~Namelist() { labels.clear(); }
 
      Namelist& operator=(const Namelist& right)
      {
         labels = right.labels;
         return *this;
      }
 
      Namelist& operator+=(const std::string& name);
 
      Namelist& operator+=(const Namelist& right)
      {
         try
         {
            for (unsigned int i = 0; i < right.size(); i++)
               this->operator+=(right.getName(i));
         }
         catch (gnsstk::Exception& e)
         {
            GNSSTK_RETHROW(e);
         }
         return *this;
      }
 
      Namelist& operator-=(const std::string& name);
 
      void swap(const unsigned int& i, const unsigned int& j);
 
      void sort();
 
      void resize(unsigned int n);
 
      void randomize(long seed = 0);
 
      void clear() { labels.clear(); }
 
      bool valid() const;
 
      bool contains(const std::string& name) const;
 
      friend bool operator==(const Namelist& N1, const Namelist& N2);
 
      friend bool operator!=(const Namelist& N1, const Namelist& N2);
 
      friend bool identical(const Namelist& N1, const Namelist& N2);
 
      friend Namelist operator&(const Namelist& N1, const Namelist& N2);
 
      friend Namelist operator|(const Namelist& N1, const Namelist& N2);
 
      friend Namelist operator^(const Namelist& N1, const Namelist& N2);
 
      Namelist& operator&=(const Namelist& N);
 
      Namelist& operator|=(const Namelist& N);
 
      Namelist& operator^=(const Namelist& N);
 
      LabeledMatrix operator()(Matrix<double>& m)
      {
         return LabeledMatrix(*this, m);
      }
 
      LabeledVector operator()(Vector<double>& v)
      {
         return LabeledVector(*this, v);
      }
 
      // member access
 
      inline unsigned int size() const { return labels.size(); }
 
      /* std::string& operator[](const unsigned int);
         Don't do this, b/c it means user could create invalid Namelists,
         and b/c passing an invalid int would require a throw
      */
 
      std::string getName(const unsigned int in) const;
 
      bool setName(const unsigned int in, const std::string& name);
 
      int index(const std::string& name) const;
 
      friend std::ostream& operator<<(std::ostream& os, const Namelist& N);
 
      // member data
 
      std::vector<std::string> labels;
 
   }; // end class Namelist
 
} // end of namespace gnsstk
 
#endif