FileSpec.cpp

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.
//
//==============================================================================
 
#include <algorithm>
 
#include "FileSpec.hpp"
#include "TimeString.hpp"
#include "StringUtils.hpp"
 
using namespace std;
using namespace gnsstk;
using namespace gnsstk::StringUtils;
 
namespace gnsstk
{
      // operator-- for FileSpecType
   FileSpec::FileSpecType& operator-- (FileSpec::FileSpecType& fst, int)
   {
      return fst = (fst == FileSpec::unknown) ?
         FileSpec::end : FileSpec::FileSpecType(fst-1);
   }
 
      // operator++ for FileSpecType
   FileSpec::FileSpecType& operator++ (FileSpec::FileSpecType& fst, int)
   {
      return fst = (fst == FileSpec::end) ?
         FileSpec::unknown : FileSpec::FileSpecType(fst+1);
   }
 
 
   bool FileSpec::FileSpecSort::operator() (const std::string& l,
                                            const std::string& r)
      const
   {
         // This sort operator compares all fields in the order
         // defined in the FileSpecType enum.
      for(FileSpecType fst = FileSpecType(unknown+1); fst < end; fst++)
      {
         if (fileSpec.hasField(fst))
         {
            for (unsigned i = 0; i < fileSpec.fileSpecList.size(); i++)
            {
               std::string::size_type offset = fileSpec.fileSpecList[i].offset;
               std::string::size_type numCh = fileSpec.fileSpecList[i].numCh;
               if (fileSpec.fileSpecList[i].type == fst)
               {
                  std::string lsub(l.substr(offset, numCh));
                  std::string rsub(r.substr(offset, numCh));
                  if (((sortDir == ascending) && (lsub < rsub)) ||
                      ((sortDir == descending) && (lsub > rsub)))
                  {
                     return true; // l comes before r
                  }
                  if (lsub == rsub)
                  {
                     continue; // l and r are the same for this field
                  }
                  return false; // r comes before l
               }
            }
         }
      }
      return false; // r and l are the same
   }
 
   string FileSpec::convertFileSpecType(const FileSpecType fst)
   {
      if (fst == station)          return string("n");
      else if (fst == receiver)    return string("r");
      else if (fst == prn)         return string("p");
      else if (fst == selected)    return string("t");
      else if (fst == sequence)    return string("I");
      else if (fst == version)     return string("v");
      else if (fst == fixed)       return string("");
      else if (fst == clock)       return string("k");
      else if (fst == text)        return string("x");
 
      else if (fst == year)        return string("y");
      else if (fst == month)       return string("m");
      else if (fst == dayofmonth)  return string("d");
      else if (fst == hour)        return string("H");
      else if (fst == minute)      return string("M");
      else if (fst == second)      return string("S");
      else if (fst == fsecond)     return string("f");
      else if (fst == gpsweek)     return string("G");
      else if (fst == fullgpsweek) return string("F");
      else if (fst == gpssecond)   return string("g");
      else if (fst == mjd)         return string("Q");
      else if (fst == dayofweek)   return string("w");
      else if (fst == day)         return string("j");
      else if (fst == doysecond)   return string("s");
      else if (fst == zcount)      return string("Z");
      else if (fst == zcountfloor) return string("z");
      else if (fst == unixsec)     return string("U");
      else if (fst == unixusec)    return string("u");
      else if (fst == fullzcount)  return string("C");
      else
      {
         FileSpecException fse("Unknown FileSpecType: " + asString(fst));
         GNSSTK_THROW(fse);
      }
   }
 
   FileSpec::FileSpecType FileSpec::convertFileSpecType(const std::string& fst)
   {
      if (fst == string("n"))        return station;
      else if (fst == string("r"))   return receiver;
      else if (fst == string("p"))   return prn;
      else if (fst == string("t"))   return selected;
      else if (fst == string("I"))   return sequence;
      else if (fst == string("v"))   return version;
      else if (fst == string("k"))   return clock;
      else if (fst == string("x"))   return text;
 
      else if (fst == string("Y") ||
               fst == string("y"))   return year;
      else if (fst == string("m"))   return month;
      else if (fst == string("d"))   return dayofmonth;
      else if (fst == string("H"))   return hour;
      else if (fst == string("M"))   return minute;
      else if (fst == string("S"))   return second;
      else if (fst == string("f"))   return fsecond;
      else if (fst == string("G"))   return gpsweek;
      else if (fst == string("F"))   return fullgpsweek;
      else if (fst == string("g"))   return gpssecond;
      else if (fst == string("Q"))   return mjd;
      else if (fst == string("w"))   return dayofweek;
      else if (fst == string("j"))   return day;
      else if (fst == string("s"))   return doysecond;
      else if (fst == string("Z"))   return zcount;
      else if (fst == string("z"))   return zcountfloor;
      else if (fst == string("U"))   return unixsec;
      else if (fst == string("u"))   return unixusec;
      else if (fst == string("C") ||
               fst == string("c"))   return fullzcount;
      else
      {
         FileSpecException fse("Unknown FileSpecType: " + fst);
         GNSSTK_THROW(fse);
      }
   }
 
 
   string FileSpec::createSearchString() const
   {
      string searchString;
 
         // go through the file spec element list...
      vector<FileSpecElement>::const_iterator itr = fileSpecList.begin();
      while (itr != fileSpecList.end())
      {
            // the error case first...
         if ( ((*itr).type <= unknown) || ((*itr).type >= end) )
         {
            FileSpecException fse("Unknown FileSpecType: " +
                                  asString((*itr).type));
            GNSSTK_THROW(fse);
         }
            // just add the fixed fields
         else if ((*itr).type == fixed)
         {
            searchString += (*itr).field;
         }
            // replace all the others with question marks for searching
         else
         {
            searchString += string((*itr).numCh, '?');
         }
 
         itr++;
      }
 
      return searchString;
   }
 
   string FileSpec::extractField(const string& filename,
                                 const FileSpecType fst) const
   {
         // stupidity check - is it a valid FST?
      if ((fst <= unknown) || (fst >= end))
      {
         FileSpecException fse("Unknown FileSpecType: " +
                               convertFileSpecType(fst));
         GNSSTK_THROW(fse);
      }
 
         // check the FileSpec for this type of FST
      vector<FileSpecElement>::const_iterator itr = fileSpecList.begin();
      while (itr != fileSpecList.end())
      {
            // found it - get the substring and return
         if ((*itr).type == fst)
         {
            return filename.substr((*itr).offset, (*itr).numCh);
         }
 
            // didn't find it on this iteration
         itr++;
      }
         // oops - didn't find it.
      FileSpecException fse("Couldn't find specified FileSpecType: " +
                            convertFileSpecType(fst));
      GNSSTK_THROW(fse);
   }
 
 
   CommonTime FileSpec::extractCommonTime(const string& filename) const
   {
         // this uses CommonTime::setToString to get the time out
      try
      {
         CommonTime dt;
         mixedScanTime(dt, filename, fileSpecString);
         return dt;
      }
      catch(Exception& exc)
      {
            // too ambiguous - throw an exception
         FileSpecException fse(exc);
         fse.addText("Can't generate a CommonTime for this FileSpec");
         GNSSTK_THROW(fse);
      }
      catch(std::exception& exc)
      {
         FileSpecException fse("std::exception: " + string(exc.what()));
         fse.addText("Can't generate a CommonTime for this FileSpec");
         GNSSTK_THROW(fse);
      }
      catch(...)
      {
         FileSpecException fse("unknown exception");
         fse.addText("Can't generate a CommonTime for this FileSpec");
         GNSSTK_THROW(fse);
      }
 
   }
 
   std::string FileSpec::toString(const gnsstk::CommonTime& dt,
                                  const FSTStringMap& fstsMap) const
   {
      string toReturn;
 
         // Go through the list and insert all the non-date elements
         // into the string.  In other words, fill in the string with data
         // from the FSTSMap first.. For date elements, put the FileSpec string
         // directly into the file name (i.e. '%3j').  Then use CommonTime::printf
         // to fill in all the date elements at the end.
      vector<FileSpecElement>::const_iterator fslItr = fileSpecList.begin();
      while (fslItr != fileSpecList.end())
      {
         FSTStringMap::const_iterator fstsItr = fstsMap.find((*fslItr).type);
            // once again, it its found in the map, replace that part of
            // the file spec. otherwise, just put the fixed field in.
         if (fstsItr != fstsMap.end())
         {
            if ((*fstsItr).first == text)
            {
                  // Don't fill text fields with "0".  Filling with
                  // space isn't the best idea either but it's better
                  // than the original implementation which simply
                  // didn't set the field width even if one was
                  // specified (which would cause RTT failures).
                  // Also, if width is unspecified (0), copy the
                  // entire text field into the file spec.
               if ((*fslItr).numCh == 0)
               {
                     // Use as much space as necessary
                  toReturn += (*fstsItr).second;
               }
               else
               {
                     // Use at most numCh characters
                  toReturn +=
                     leftJustify((*fstsItr).second, (*fslItr).numCh);
               }
            }
            else
            {
               toReturn +=
                  rightJustify((*fstsItr).second, (*fslItr).numCh, '0');
            }
         }
         else
         {
            toReturn += (*fslItr).field;
         }
 
         fslItr++;
      }
 
      toReturn = printTime(dt,toReturn);
 
      return toReturn;
   }
 
   void FileSpec::sortList(vector<string>& fileList,
                           const FileSpecSortType fsst) const
   {
      FileSpecSort q(*this, fsst);
      stable_sort(fileList.begin(), fileList.end(), q);
 
         // to filter out versions, generate a list of the version FSEs first
         // and copy the file list.  then make a map of the file name without
         // the version field to the name with the version field. since its
         // sorted, the highest version will be the last one set and the map
         // will only have the latest versions...
         //
         // ex.  a1a a2a a3a a4a a5a     file spec: a%1va
         // copyOfFileList after versions removed:  aa aa aa aa aa
         // versionMap[aa] = a1a then a2a, a3a, a4a, and finally a5a
         //
         // note that this only handles 1 version field right now, not that
         // it couldnt do more but it gets very difficult...
 
         // filter out older versions here
      if (hasField(version))
      {
            // copy the file list
         vector<string> copyOfFileList = fileList;
 
            // find all the version elements in this file spec
         vector<FileSpecElement>::const_iterator itr = fileSpecList.begin();
         vector<FileSpecElement> versionVec;
         while (itr != fileSpecList.end())
         {
            if ((*itr).type == version)
               versionVec.push_back(*itr);
            itr++;
         }
            // remove the version fields from the copied list, but only for the
            // last directory/file entry in this name
         vector<string>::size_type index;
         for (index = 0; index < copyOfFileList.size(); index++)
         {
            string::size_type slashpos = copyOfFileList[index].rfind(slash);
            if (slashpos != string::npos)
               copyOfFileList[index].erase(0, slashpos + 1);
            copyOfFileList[index].erase(versionVec[0].offset,
                                        versionVec[0].numCh);
         }
 
            // now make one more pass on the copied list. whenever two strings
            // match, go to the original list and compare the version numbers.
            // erase the lower version.
 
            // FIX: this will only compare the first version field encountered.
            // it could be changed to do more, but it's not essential now...
         map<string, string> versionMap;
         for (index = 0; index < copyOfFileList.size(); index++)
            versionMap[copyOfFileList[index]] = fileList[index];
 
         fileList.erase(fileList.begin(), fileList.end());
         map<string, string>::iterator mapitr = versionMap.begin();
         while (mapitr != versionMap.end())
         {
            fileList.push_back((*mapitr).second);
            mapitr++;
         }
      }
   }
 
   void FileSpec::dump(ostream& o) const
   {
      o << "FileSpec string: " << fileSpecString << endl;
 
      o << "offset numch  type  field" << endl;
      vector<FileSpecElement>::const_iterator itr = fileSpecList.begin();
      while (itr != fileSpecList.end())
      {
         o << setw(6) << (*itr).offset << setw(6) << (*itr).numCh
           << setw(6) << convertFileSpecType((*itr).type)
               // this makes the field bigger if the string is
               // bigger than 5 characters
           << setw(6 + ((*itr).field.size() > 5 ? ((*itr).field.size()-5): 0))
           << (*itr).field << endl;
         itr++;
      }
   }
 
   void FileSpec::init(const string& fileSpec)
   {
      try
      {
         fileSpecList.clear();
         fileSpecString.clear();
 
         fileSpecString = fileSpec;
 
            // holds the offset for where we would be in the real file
            // name
         string::size_type offset = 0;
 
            // copy the string so we can mess with it
         string fs(fileSpec);
 
            // bit by bit, parse out the string into FileSpecElements,
            // stripping out the used parts as we go
         while (!fs.empty())
         {
            string atom;
               // if fs[0] == '%', then stop to parse.  also stop at
               // the end of the string
            string::size_type pos = fs.find('%');
            atom = fs.substr(0,pos);
            fs.erase(0,pos);
 
               // if it's at the end of the string...
               // make a FileSpecElement of any remaining
               // characters and return (fall through the while loop)
            if (fs.empty())
            {
               if (!atom.empty())
               {
                  FileSpecElement fse(atom.size(), offset, fixed, atom);
                  fileSpecList.push_back(fse);
               }
            }
               // found a '%' so parse out this little bit of a file spec,
               // but make sure to add atom to the FileSpec (if there is any)
            else
            {
               if (!atom.empty())
               {
                  FileSpecElement fse(atom.size(), offset, fixed, atom);
                  fileSpecList.push_back(fse);
                  offset += atom.size();
                  atom.erase(atom.begin(), atom.end());
               }
 
                  // erase the '%'
                  // also make sure that atom holds the string that
                  // makes up this element.
               atom += fs[0];
               fs.erase(0,1);
 
                  // get any integers that come before the letter we're lookin
                  // for, then erase them
               int rawNumChs = asInt(fs);
               int numChs = (rawNumChs == 0) ? 1 : rawNumChs;
 
               if (fs[0] == '0')
                  atom += '0';
 
               stripLeading(fs, "0");
               stripLeading(fs, asString(numChs));
 
                  // get the file spec type
               FileSpecType fst = convertFileSpecType(fs.substr(0,1));
 
                  // super special case - %x -> %0x
               if ((fs.substr(0,1) == string("x")) && (rawNumChs == 0))
                  numChs = 0;
 
                  // super special case - %Y -> %4y
               if ((fs.substr(0,1) == string("Y")) && (numChs < 4))
                  numChs = 4;
 
               atom += asString(numChs);
               atom += fs[0];
 
                  // erase the file spec element type character
               fs.erase(0,1);
 
               FileSpecElement fse(numChs, offset, fst, atom);
               fileSpecList.push_back(fse);
               fileSpecSet.insert(fst);
               offset += numChs;
            }
 
         } // while !fs.empty()
      }
      catch(FileSpecException& e)
      {
         e.addText("Check your file spec for errors: " + fileSpec);
         GNSSTK_RETHROW(e);
      }
      catch(StringException& e)
      {
         FileSpecException fse(e);
         fse.addText("String exception: Check the file spec for errors: " + fileSpec);
         GNSSTK_THROW(fse);
      }
      catch(std::exception& e)
      {
         FileSpecException fse("std::exception: " + string(e.what()));
         fse.addText("Check the file spec for errors: " + fileSpec);
         GNSSTK_THROW(fse);
      }
      catch(...)
      {
         FileSpecException fse("Unknown exception: Check the file spec for errors: " + fileSpec);
         GNSSTK_THROW(fse);
      }
   }
 
} // namespace