SerialNumberList.cpp

#include "SerialNumberList.h"

#include <QString>

#include "IException.h"
#include "FileList.h"
#include "FileName.h"
#include "SerialNumber.h"
#include "ObservationNumber.h"
#include "IString.h"
#include "Pvl.h"

namespace Isis {
  SerialNumberList::SerialNumberList(bool checkTarget) {
    p_checkTarget = checkTarget;
    p_target.clear();
  }


  SerialNumberList::SerialNumberList(const QString &listfile, bool checkTarget, Progress *progress) {
    p_checkTarget = checkTarget;
    p_target.clear();
    try {
      FileList flist(listfile);
      if(progress != NULL) {
        progress->SetText("Creating Isis 3 serial numbers from list file.");
        progress->SetMaximumSteps((int) flist.size() + 1);
        progress->CheckStatus();
      }
      for(int i = 0; i < flist.size(); i++) {
        Add(flist[i].toString());
        if(progress != NULL) {
          progress->CheckStatus();
        }
      }
    }
    catch(IException &e) {
      QString msg = "Can't open or invalid file list [" + listfile + "]";
      throw IException(e, IException::User, msg, _FILEINFO_);
    }
  }

  SerialNumberList::~SerialNumberList() {
  }


  void SerialNumberList::Delete(const QString &sn)
  {
    int index = SerialNumberIndex(sn);
    QString sFileName = FileName(sn);

    // Delete the reference to this serial number in the
    // vector and the maps
    p_pairs.erase(p_pairs.begin() + index);
    p_serialMap.erase(sn);
    p_fileMap.erase(sFileName);
  }



  void SerialNumberList::Add(const QString &filename, bool def2filename) {

    Pvl p(Isis::FileName(filename).expanded());
    PvlObject cubeObj = p.FindObject("IsisCube");
    try {
      // Test the target name if desired
      if (p_checkTarget) {
        QString target;
        PvlGroup targetGroup;
        if (cubeObj.HasGroup("Instrument")) {
          targetGroup = cubeObj.FindGroup("Instrument");
        }
        else if (def2filename) {
          // No instrument, try Mapping
          if (cubeObj.HasGroup("Mapping")) {
            targetGroup = cubeObj.FindGroup("Mapping");
          }
          else {
            QString msg = "Unable to find Instrument or Mapping group in ";
            msg += filename + " for comparing target";
            throw IException(IException::User, msg, _FILEINFO_);
          }
        }
        else {
          // No Instrument group
          QString msg = "Unable to find Instrument group in " + filename;
          msg += " for comparing target";
          throw IException(IException::User, msg, _FILEINFO_);
        }

        target = targetGroup["TargetName"][0];
        target = target.toUpper();
        if (p_target.isEmpty()) {
          p_target = target;
        }
        else if (p_target != target) {
          QString msg = "Target name of [" + target + "] from file [";
          msg += filename + "] does not match [" + p_target + "]";
          throw IException(IException::User, msg, _FILEINFO_);
        }
      }

      // Create the SN
      QString sn = SerialNumber::Compose(p, def2filename);
      QString on = ObservationNumber::Compose(p, def2filename);
      if(sn == "Unknown") {
        QString msg = "Invalid serial number [Unknown] from file [";
        msg += filename + "]";
        throw IException(IException::User, msg, _FILEINFO_);
      }
      else if(HasSerialNumber(sn)) {
        int index = SerialNumberIndex(sn);
        QString msg = "Duplicate, serial number [" + sn + "] from files [";
        msg += SerialNumberList::FileName(sn) + "] and [" + FileName(index) + "].";
        throw IException(IException::User, msg, _FILEINFO_);
      }
      Pair nextpair;
      nextpair.filename = Isis::FileName(filename).expanded();
      nextpair.serialNumber = sn;
      nextpair.observationNumber = on;
      p_pairs.push_back(nextpair);
      p_serialMap.insert(std::pair<QString, int>(sn, (int)(p_pairs.size() - 1)));
      p_fileMap.insert(std::pair<QString, int>(nextpair.filename, (int)(p_pairs.size() - 1)));
    }
    catch(IException &e) {
      QString msg = "File [" + Isis::FileName(filename).expanded() +
                        "] can not be added to ";
      msg += "serial number list";
      throw IException(e, IException::User, msg, _FILEINFO_);
    }
  }


  void SerialNumberList::Add(const char *serialNumber, const char *filename) {

    Add((QString)serialNumber, (QString)filename);
  }


  void SerialNumberList::Add(const QString &serialNumber, const QString &filename) {

    Pvl p(Isis::FileName(filename).expanded());
    PvlObject cubeObj = p.FindObject("IsisCube");
    try {
      // Test the target name if desired
      if (p_checkTarget) {
        QString target;
        PvlGroup targetGroup;
        if (cubeObj.HasGroup("Instrument")) {
          targetGroup = cubeObj.FindGroup("Instrument");
        }
        else if (cubeObj.HasGroup("Mapping")) {
          // No instrument, try Mapping
          if (cubeObj.HasGroup("Mapping")) {
            targetGroup = cubeObj.FindGroup("Mapping");
          }
        else {
            QString msg = "Unable to find Instrument or Mapping group in ";
            msg += filename + " for comparing target";
            throw IException(IException::User, msg, _FILEINFO_);
          }
        }

        target = targetGroup["TargetName"][0];
        target = target.toUpper();
        if (p_target.isEmpty()) {
          p_target = target;
        }
        else if (p_target != target) {
          QString msg = "Target name of [" + target + "] from file [";
          msg += filename + "] does not match [" + p_target + "]";
          throw IException(IException::User, msg, _FILEINFO_);
        }
      }

      QString observationNumber = "Unknown";
      if (serialNumber == "Unknown") {
        QString msg = "Invalid serial number [Unknown] from file [";
        msg += filename + "]";
        throw IException(IException::User, msg, _FILEINFO_);
      }
      else if (HasSerialNumber(serialNumber)) {
        int index = SerialNumberIndex(serialNumber);
        QString msg = "Duplicate, serial number [" + serialNumber + "] from files [";
        msg += SerialNumberList::FileName(serialNumber) + "] and [" + FileName(index) + "].";
        throw IException(IException::User, msg, _FILEINFO_);
      }
      Pair nextpair;
      nextpair.filename = Isis::FileName(filename).expanded();
      nextpair.serialNumber = serialNumber;
      nextpair.observationNumber = observationNumber;
      p_pairs.push_back(nextpair);
      p_serialMap.insert(std::pair<QString, int>(serialNumber, (int)(p_pairs.size() - 1)));
      p_fileMap.insert(std::pair<QString, int>(nextpair.filename, (int)(p_pairs.size() - 1)));
    }
    catch(IException &e) {
      QString msg = "File [" + Isis::FileName(filename).expanded() +
                        "] can not be added to ";
      msg += "serial number list";
      throw IException(e, IException::User, msg, _FILEINFO_);
    }
  }


  bool SerialNumberList::HasSerialNumber(QString sn) {
    if(p_serialMap.find(sn) == p_serialMap.end()) return false;
    return true;
  }


  int SerialNumberList::Size() const {
    return p_pairs.size();
  }


  QString SerialNumberList::FileName(const QString &sn) {
    if(HasSerialNumber(sn)) {
      int index = p_serialMap.find(sn)->second;
      return p_pairs[index].filename;
    }
    else {
      QString msg = "Requested serial number [" + sn + "] ";
      msg += "does not exist in the list";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }

  QString SerialNumberList::SerialNumber(const QString &filename) {
    if(p_fileMap.find(Isis::FileName(filename).expanded()) == p_fileMap.end()) {
      QString msg = "Requested filename [" +
                        Isis::FileName(filename).expanded() + "]";
      msg += "does not exist in the list";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    int index = FileNameIndex(filename);
    return p_pairs[index].serialNumber;
  }

  QString SerialNumberList::SerialNumber(int index) {
    if(index >= 0 && index < (int) p_pairs.size()) {
      return p_pairs[index].serialNumber;
    }
    else {
      QString num = QString(index);
      QString msg = "Index [" + (QString) num + "] is invalid";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }

  QString SerialNumberList::ObservationNumber(int index) {
    if(index >= 0 && index < (int) p_pairs.size()) {
      return p_pairs[index].observationNumber;
    }
    else {
      QString num = QString(index);
      QString msg = "Index [" + (QString) num + "] is invalid";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }

  int SerialNumberList::SerialNumberIndex(const QString &sn) {
    if(HasSerialNumber(sn)) {
      return p_serialMap.find(sn)->second;
    }
    else {
      QString msg = "Requested serial number [" + sn + "] ";
      msg += "does not exist in the list";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }

  int SerialNumberList::FileNameIndex(const QString &filename) {

    std::map<QString, int>::iterator  pos;
    if((pos = p_fileMap.find(Isis::FileName(filename).expanded())) == p_fileMap.end()) {
      QString msg = "Requested filename [" +
                        Isis::FileName(filename).expanded() + "]";
      msg += "does not exist in the list";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    return pos->second;
  }

  QString SerialNumberList::FileName(int index) {
    if(index >= 0 && index < (int) p_pairs.size()) {
      return p_pairs[index].filename;
    }
    else {
      QString num = toString(index);
      QString msg = "Index [" + num + "] is invalid";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }


  std::vector<QString> SerialNumberList::PossibleSerialNumbers(const QString &on) {
    std::vector<QString> numbers;
    for(unsigned index = 0; index < p_pairs.size(); index++) {
      if(p_pairs[index].observationNumber == on) {
        numbers.push_back(p_pairs[index].serialNumber);
      }
    }
    if(numbers.size() > 0) {
      return numbers;
    }
    else {
      QString msg = "Requested observation number [" + on + "] ";
      msg += "does not exist in the list";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }


}