ObservationNumberList.cpp

#include "ObservationNumberList.h"
#include "IException.h"
#include "FileName.h"
#include "SerialNumberList.h"
#include "IString.h"
#include "Pvl.h"

namespace Isis {
  ObservationNumberList::ObservationNumberList(const QString &listfile, bool checkTarget) :
    SerialNumberList(listfile, checkTarget) {
    init(this);
  }

  ObservationNumberList::ObservationNumberList(Isis::SerialNumberList *snlist) :
    SerialNumberList(*snlist) {
    init(snlist);
  }

  void ObservationNumberList::init(Isis::SerialNumberList *snlist) {

    if(snlist->Size() == 0) {
      QString msg = "Serial number list is empty";
      throw IException(IException::User, msg, _FILEINFO_);
    }

    std::map<QString, int> observationMap;
    QString observationNumber;
    int currentIndex = 0;
    int observationIndex;

    // Fill the temporary map to generate observation sets
    for(int isn = 0; isn < snlist->Size(); isn++) {
      observationNumber = snlist->ObservationNumber(isn);

      if(observationMap.find(observationNumber) == observationMap.end()) {
        observationMap.insert(std::pair<QString, int>(observationNumber, currentIndex));
        observationIndex = currentIndex++;
      }
      else {
        observationIndex = observationMap.find(observationNumber)->second;
      }

      Add(isn, observationIndex, observationNumber);
    }
    p_numberObservations = currentIndex;
  }

  ObservationNumberList::~ObservationNumberList() {
  }

  void ObservationNumberList::Remove(Isis::SerialNumberList *snlist) {

    if(snlist->Size() == 0) {
      QString msg = "Removing serial number list is empty";
      throw IException(IException::User, msg, _FILEINFO_);
    }

    p_sets.clear();
    p_indexMap.clear();

    std::map<QString, int> observationMap;
    QString observationNumber;
    int currentIndex = 0;
    int observationIndex;

    // Fill the temporary map to generate observation sets
    for(int isn = 0; isn < this->Size(); isn++) {
      if((snlist->HasSerialNumber(this->SerialNumber(isn)))) continue;
      observationNumber = this->ObservationNumber(isn);

      if(observationMap.find(observationNumber) == observationMap.end()) {
        observationMap.insert(std::pair<QString, int>(observationNumber, currentIndex));
        observationIndex = currentIndex++;
      }
      else {
        observationIndex = observationMap.find(observationNumber)->second;
      }

      Add(isn, observationIndex, observationNumber);
    }
    p_numberObservations = currentIndex;
  }


  void ObservationNumberList::Remove(const QString &listfile) {
    Isis::SerialNumberList snlist(listfile);
    Remove(&snlist);
  }


  void ObservationNumberList::Add(const int isn, const int observationIndex,
                                  QString observationNumber) {

    ObservationSet nextset;
    nextset.serialNumberIndex = isn;
    nextset.observationNumberIndex = observationIndex;
    nextset.observationNumber = observationNumber;

    p_sets.push_back(nextset);
    p_indexMap.insert(std::pair<int, int>(isn, observationIndex));
  }

  int ObservationNumberList::ObservationSize() const {
    return p_numberObservations;
  }


  bool ObservationNumberList::HasObservationNumber(const QString &on) {
    for(unsigned index = 0; index < p_pairs.size(); index++) {
      if(p_pairs[index].observationNumber == on) {
        return true;
      }
    }
    return false;
  }

  int ObservationNumberList::ObservationNumberMapIndex(int serialNumberIndex) {
    //    if (serialNumberIndex >= 0 && serialNumberIndex < (int) p_indexMap.size()) {
    if(serialNumberIndex >= 0) {
      return p_indexMap.find(serialNumberIndex)->second;
    }
    else {
      QString msg = "Serial Number Index [" + toString(serialNumberIndex) + "] is invalid";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }


  QString ObservationNumberList::ObservationNumber(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].observationNumber;
  }

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

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

}