Namelist.hpp

Go to the documentation of this file.

#pragma ident "$Id: Namelist.hpp 1182 2008-04-04 14:07:43Z btolman $"

//============================================================================
//
//  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 CLASS_NAMELIST_INCLUDE
#define CLASS_NAMELIST_INCLUDE

//------------------------------------------------------------------------------------
// system includes
#include <string>
#include <vector>
#include <algorithm>
#include <iomanip>
#include <ostream>
#include <sstream>
// GPSTk
#include "Matrix.hpp"

namespace gpstk
{

//------------------------------------------------------------------------------------
class Namelist;
class LabelledVector {
public:
   int wid,prec,form;
   std::string msg;
   std::string tag;
   const Namelist& NL;
   Vector<double>& V;
   LabelledVector(const Namelist& nl, Vector<double>& v)
      : wid(12), prec(5), form(1), NL(nl), V(v) { }
   LabelledVector& setw(int w) { wid = w; return *this; }
   LabelledVector& setprecision(int p) { prec = p; return *this; }
   LabelledVector& fixed(void) { form = 1; return *this; }
   LabelledVector& scientific(void) { form = 2; return *this; }
   LabelledVector& message(const std::string& m) { msg=m; return *this; }
   LabelledVector& linetag(const std::string& m) { tag=m; return *this; }
};

class LabelledMatrix {
public:
   int wid,prec;
   int form;         // format: 1=fixed, 2=scientific
   int rc;           // rows only (1) columns only (2) or both (0)
   std::string msg;
   std::string tag;
   const Namelist& NLrows;
   const Namelist& NLcols;
   const Matrix<double>& M;
   LabelledMatrix(const Namelist& nl, const Matrix<double>& m)
      : wid(12), prec(5), form(1), rc(0), NLrows(nl), NLcols(nl), M(m) { }
   LabelledMatrix(const Namelist& nlr, const Namelist& nlc, const Matrix<double>& m)
      : wid(12), prec(5), form(1), rc(0), NLrows(nlr), NLcols(nlc), M(m) { }
   LabelledMatrix& setw(int w) { wid = w; return *this; }
   LabelledMatrix& setprecision(int p) { prec = p; return *this; }
   LabelledMatrix& fixed(void) { form = 1; return *this; }
   LabelledMatrix& scientific(void) { form = 2; return *this; }
   LabelledMatrix& both(void) { rc=0; return *this; }
   LabelledMatrix& rows(void) { rc=1; return *this; }
   LabelledMatrix& cols(void) { rc=2; return *this; }
   LabelledMatrix& message(const std::string& m) { msg=m; return *this; }
   LabelledMatrix& linetag(const std::string& m) { tag=m; return *this; }
};

std::ostream& operator<<(std::ostream&, const LabelledMatrix&);
std::ostream& operator<<(std::ostream&, const LabelledVector&);


//------------------------------------------------------------------------------------
class Namelist {
   friend class SRI;
   friend std::ostream& operator<<(std::ostream&, const LabelledMatrix&);
   friend std::ostream& operator<<(std::ostream&, const LabelledVector&);
public:
   Namelist(void) {}
   Namelist(const unsigned int&);
   Namelist(const std::vector<std::string>&);
   Namelist(const Namelist& names) { labels = names.labels; }
   ~Namelist(void) { labels.clear(); }

   Namelist& operator=(const Namelist& right)
      { labels = right.labels; return *this; }
   Namelist& operator+=(const std::string&);
   Namelist& operator-=(const std::string&);

   void swap(const unsigned int&, const unsigned int&);
   void sort(void);
   void resize(unsigned int);
   void randomize(long seed=0);
   void clear(void) { labels.clear(); }

   bool valid(void) const;
   bool contains(const std::string&) const;
   friend bool operator==(const Namelist&, const Namelist&);
   friend bool operator!=(const Namelist&, const Namelist&);
   friend bool identical(const Namelist&, const Namelist&);

   friend Namelist operator&(const Namelist&, const Namelist&);
   friend Namelist operator|(const Namelist&, const Namelist&);
   friend Namelist operator^(const Namelist&, const Namelist&);
   Namelist& operator&=(const Namelist&);
   Namelist& operator|=(const Namelist&);
   Namelist& operator^=(const Namelist&);

   LabelledMatrix operator()(Matrix<double>& m)
      { return LabelledMatrix(*this,m); }

   LabelledVector operator()(Vector<double>& v)
      { return LabelledVector(*this,v); }

      // member access

   inline unsigned int size(void) 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) const;

   bool setName(const unsigned int, const std::string&);

   int index(const std::string&) const;

   friend std::ostream& operator<<(std::ostream& s, const Namelist&);

   // member data

   std::vector<std::string> labels;

//private:
}; // end class Namelist

} // end of namespace gpstk

#endif

---