ObservationNumberList.cpp

#include "ObservationNumberList.h"

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

using namespace std;
namespace Isis {

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


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


  void ObservationNumberList::init(SerialNumberList *snlist) {

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

    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(pair<QString, int>(observationNumber, currentIndex));
        observationIndex = currentIndex++;
      }
      else {
        observationIndex = observationMap.find(observationNumber)->second;
      }

      add(isn, observationIndex, observationNumber);
    }
    m_numberObservations = currentIndex;
  }


  ObservationNumberList::~ObservationNumberList() {
  }


  void ObservationNumberList::remove(SerialNumberList *snlist) {

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

    m_sets.clear();
    m_indexMap.clear();

    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(pair<QString, int>(observationNumber, currentIndex));
        observationIndex = currentIndex++;
      }
      else {
        observationIndex = observationMap.find(observationNumber)->second;
      }

      add(isn, observationIndex, observationNumber);
    }
    m_numberObservations = currentIndex;
  }


  void ObservationNumberList::remove(const QString &listfile) {
    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;

    m_sets.push_back(nextset);
    m_indexMap.insert(pair<int, int>(isn, observationIndex));
  }


  int ObservationNumberList::observationSize() const {
    return m_numberObservations;
  }


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


  int ObservationNumberList::observationNumberMapIndex(int serialNumberIndex) {
    //    if (serialNumberIndex >= 0 && serialNumberIndex < (int) m_indexMap.size()) {
    if (serialNumberIndex >= 0) {
      return m_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 (m_fileMap.find(FileName(filename).expanded()) == m_fileMap.end()) {
      QString msg = "Requested filename [" + FileName(filename).expanded() + "] ";
      msg += "does not exist in the list";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    int index = fileNameIndex(filename);
    return m_pairs[index].observationNumber;
  }


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


  vector<QString> ObservationNumberList::possibleFileNames(const QString &on) {
    vector<QString> filenames;
    for (unsigned index = 0; index < m_pairs.size(); index++) {
      if (m_pairs[index].observationNumber == on) {
        filenames.push_back(m_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_);
    }
  }

}