PvlFlatMap.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */ 
#include "PvlFlatMap.h"
 
#include <QDebug>
 
// other ISIS
#include "IException.h"
#include "FileName.h"
#include "Pvl.h"
#include "PvlContainer.h"
#include "PvlFlatMap.h"
#include "PvlGroup.h"
#include "PvlKeyword.h"
#include "PvlObject.h"
#include "TextFile.h"
 
using namespace std;
 
namespace Isis {
  
  PvlConstraints::PvlConstraints() {
  }
 
  
  PvlConstraints::PvlConstraints(const QString &keyListFile) {
    addKeyToList(FileName(keyListFile));
    return;
  }
  

  PvlConstraints PvlConstraints::withExcludes(const QStringList &excludes) {
    PvlConstraints constraints;
    constraints.addExclude(excludes);
    return (constraints);
  }
 

  PvlConstraints PvlConstraints::withIncludes(const QStringList &includes) {
   PvlConstraints constraints;
   constraints.addInclude(includes);
   return (constraints);
  }
  
  
  PvlConstraints::~PvlConstraints() {
  }
  
    
  int PvlConstraints::excludeSize() const {  
    return (m_excludes.size());  
  }
  
    
  int PvlConstraints::includeSize() const {  
    return (m_includes.size());  
  }
  
    
  int PvlConstraints::keyListSize() const {
      return (m_keylist.size());  
  }
  
    
  void PvlConstraints::addExclude(const QString &name) { 
     m_excludes.append(name); 
  }
  
    
  void PvlConstraints::addInclude(const QString &name) { 
     m_includes.append(name); 
  }
  
    
  void PvlConstraints::addKeyToList(const QString &name) { 
     m_keylist.append(name); 
  }
  
    
  void PvlConstraints::addExclude(const QStringList &other) { 
    m_excludes += other; 
  }
  
    
  void PvlConstraints::addInclude(const QStringList &other) { 
    m_includes += other; 
  }
  
    
  void PvlConstraints::addKeyToList(const QStringList &other) { 
    m_keylist += other;
  }
  
    
  void PvlConstraints::addKeyToList(const FileName &fileName) { 
    readKeyListFile(fileName); 
    return;
  }
  
    
  bool PvlConstraints::isExcluded(const QString &name) const {
    return (m_excludes.contains(name, Qt::CaseInsensitive));
  }
  
    
  bool PvlConstraints::isIncluded(const QString &name) const {
    return (m_includes.contains(name, Qt::CaseInsensitive));
  }
  
    
  bool PvlConstraints::isKeyInList(const QString &name) const {
    return (m_keylist.contains(name, Qt::CaseInsensitive));
  }
  
    
  const QStringList &PvlConstraints::excludes() const { 
    return (m_excludes);
  }
  
    
  const QStringList &PvlConstraints::includes() const { 
    return (m_includes);
  }
  
    
  const QStringList &PvlConstraints::keyList()  const { 
    return (m_keylist);
  }
 
  
  void PvlConstraints::readKeyListFile(const FileName &keyListFile) {
    // Pvl pvl(keyListFile.expanded());
    // 
    // if (pvl.hasObject("KeyList")) {
    //   PvlContainer keylist = pvl.findObject("KeyList");
    //   PvlContainer::ConstPvlKeywordIterator k = keylist.begin();
    //   while (k != keylist.end()) {
    //     addKeyToList(k->name());
    //     ++k;
    //   }
    // }
    // else {
    //   PvlContainer::ConstPvlKeywordIterator k = pvl.begin();
    //   while (k != pvl.end()) {
    //     addKeyToList(k->name());
    //     ++k;
    //   }
    // }
    // return;
 
//     Pvl pvl(keyListFile.expanded());
//     qDebug() << "INPUT FILE = ";
//     qDebug() << keyListFile.expanded();
//     for (int k = 0; k < pvl.keywords(); k++) {
//       cout << "HI!" << endl;
//       addKeyToList(pvl[k].name());
//     }
    TextFile keyList(keyListFile.expanded());
    QString keywordName = "";
    while (keyList.GetLine(keywordName)) {
      addKeyToList(keywordName);
    }
 
  }
    
        
  PvlFlatMap::PvlFlatMap() : QMap<QString, PvlKeyword> () { 
  }
  
    
  PvlFlatMap::PvlFlatMap(const PvlFlatMap &other) : 
                         QMap<QString, PvlKeyword> ()  { 
    merge(other);
  }
  
    
  PvlFlatMap::PvlFlatMap(const PvlFlatMap &pmap1, 
                         const PvlFlatMap &pmap2) :
                         QMap<QString, PvlKeyword> () {
    merge(pmap1);
    merge(pmap2);
  }
  
    
  PvlFlatMap::PvlFlatMap(const PvlObject &pvl, 
                         const PvlConstraints &constraints) : 
                         QMap<QString, PvlKeyword> () {
    loadObject(pvl, constraints);
  }
  
    
  PvlFlatMap::PvlFlatMap(const PvlContainer &pvl, 
                         const PvlConstraints &constraints) : 
                         QMap<QString, PvlKeyword> () {
    loadKeywords(pvl, constraints);
  }
  
    
  PvlFlatMap::~PvlFlatMap() {
  }
 
   
  bool PvlFlatMap::exists(const QString &key) const {
    return (contains(key.toLower()));
  }
  
    
  int PvlFlatMap::count(const QString &key) const {
    if ( !exists(key) ) { 
      return (0); 
    }
    return (keyword(key).size());
  }
  
    
  bool PvlFlatMap::isNull(const QString &key, 
                          const int index) const {
    if (exists(key)) {
      return (keyword(key).isNull(index));
    }
  
    // Always returns true if the keyword doesn't exist
    return (true);
  }
  
    
  void PvlFlatMap::add(const QString &key, 
                       const QString &value) {
    add(PvlKeyword(key, value));
  }
  
    
  void PvlFlatMap::add(const PvlKeyword &key) {
    insert(key.name().toLower(),  key);
  }
  
    
  void PvlFlatMap::append(const QString &key, 
                          const QString &value) {
    append(PvlKeyword(key, value));
    return;
  }
  
    
  void PvlFlatMap::append(const PvlKeyword &key) {
    if ( exists(key.name()) ) {
      PvlFlatMapIterator kw = find(key.name().toLower());
      // add all values to the map
      for (int i = 0; i < key.size(); i++) {
        kw.value().addValue(key[i]); 
      }
    }
    else {
      insert(key.name().toLower(),  PvlKeyword(key.name(), key[0]));
      // if there are more than one values in this keyword, insert the first
      // into the map and recursively call append to add the rest.
      for (int i = 1; i < key.size(); i++) {
        append(key.name(), key[i]);
      }
    }
    return;
  }
 
  
  bool PvlFlatMap::erase(const QString &key) {
    return (bool (remove(key.toLower())));
  }
  
    
  QString PvlFlatMap::get(const QString &key, 
                          const int &index) const {
    QMap<QString, PvlKeyword>::const_iterator k = find(key.toLower());
    if (end() == k) {
      QString mess = "Keyword " + key + " does not exist!";
      throw IException(IException::Programmer, mess, _FILEINFO_);
    }
    if (index >= k.value().size()) {
      QString mess = "Index " + toString(index) + " does not exist for keyword " + key + "!";
      throw IException(IException::Programmer, mess, _FILEINFO_);
    }
  
    return (k.value()[index]);
  }
  
    
  QString PvlFlatMap::get(const QString &key, 
                          const QString &defValue,
                          const int &index) const {
    QMap<QString, PvlKeyword>::const_iterator k = find(key.toLower());
    if (end() == k || index >= k.value().size()) {
      return (defValue);
    }
    else {
      return (k.value()[index]);
    }
  }
  
  
  QString PvlFlatMap::operator()(const QString &name) const {
    return (get(name));
  }
  
    
  QStringList PvlFlatMap::allValues(const QString &key) const {
    QStringList values;
    QMap<QString, PvlKeyword>::const_iterator k = find(key.toLower());
    if (end() != k) {  
      values = keywordValues(k.value());  
    }
    return (values);
  }
  
    
  PvlKeyword PvlFlatMap::keyword(const QString &key) const {
    QMap<QString, PvlKeyword>::const_iterator k = find(key.toLower());
    if (end() == k) {
      QString mess = "Keyword " + key + " does not exist!";
      throw IException(IException::Programmer, mess, _FILEINFO_);
    }
    return (k.value());
  }
  
    
  int PvlFlatMap::merge(const PvlFlatMap &other)  {
    int n = 0;
    QMap<QString, PvlKeyword>::const_iterator keys =  other.begin();
    while ( keys != other.end() ) {
      add(keys.value());
      n++;
      ++keys;
    }
  
    return (n);
  }
  
    
  QStringList PvlFlatMap::keywordValues(const PvlKeyword &keyword) {
    QStringList values;
    for (int i = 0 ; i < keyword.size() ; i++) {
      values << keyword[i];
    }
    return (values);
  }
  
    
  int PvlFlatMap::loadObject(const PvlObject &object, 
                             const PvlConstraints &constraints) {
    int total = 0;
  
    // Check constraints if specified
    int nconsts = constraints.excludeSize() + constraints.includeSize();
    if ( nconsts > 0 ) {
      bool isExcluded = constraints.isExcluded(object.name());
      bool isIncluded = constraints.isIncluded(object.name());
      bool hasBoth = (constraints.excludeSize() > 0) && 
                     (constraints.includeSize() > 0);
 
      // Check constraints
      // include object and its groups and keywords when both Includes and Excludes are specified
      // don't include an object if it isn't in Includes keyword
      if ( hasBoth ) {
        if ( !isIncluded ) { 
          return (total); 
        }  // At the object level
      } 
      else if ( isExcluded ) {
        return (total);
      }
      else if ( constraints.includeSize() > 0 ) {
        if ( !isIncluded ) { 
          return (total); 
        }
      }
    }
  
    // First load keys in the object, then existing groups followed by additional
    // objects
    total += loadKeywords(object, constraints);
    total += loadGroups(object, constraints);
  
    PvlObject::ConstPvlObjectIterator objs;
    for (objs = object.beginObject() ; objs != object.endObject() ; ++objs) {
      total += loadObject(*objs, constraints);
    }
    return (total);
  }
  
    
  int  PvlFlatMap::loadGroups(const PvlObject &object,
                              const PvlConstraints &constraints) {
    int total = 0;
  
    //  Load the PvlGroups contained in the PvlObject
    PvlObject::ConstPvlGroupIterator group;
    for (group = object.beginGroup() ; group != object.endGroup() ; group++) {
      total += loadGroup(*group, constraints);
    }
    return total;
  }
  
  
  int PvlFlatMap::loadGroup(const PvlGroup &group,
                            const PvlConstraints &constraints) {
    int total = 0;
    // Check constraints if specified
    int nconsts = constraints.excludeSize() + constraints.includeSize();
    if ( nconsts > 0 ) {
      bool isExcluded = constraints.isExcluded(group.name());
      bool isIncluded = constraints.isIncluded(group.name());
      bool hasBoth = (constraints.excludeSize() > 0) && 
                     (constraints.includeSize() > 0);
      // Check constraints
      // When both Includes and Excludes provided, Excludes applies to groups
      // If an object is included but one of its group is excluded, exclude the group
      if ( hasBoth ) {
        if ( isExcluded ) { 
          return (total); 
        } // at group level
      } 
      else if ( isExcluded ) {
        return (total);
      }
      else if ( constraints.includeSize() > 0 ) {
        if ( !isIncluded ) { 
          return (total); 
        }
      }
    }
    
    // load the PvlGroup's PvlKeywords
    total += loadKeywords(group, constraints);
    return (total);
  }
  
    
  int PvlFlatMap::loadKeywords(const PvlContainer &pvl, 
                               const PvlConstraints &constraints) {
    PvlContainer::ConstPvlKeywordIterator key;
    int n = 0;
  
    // if there are any keyword constraints, only load those PvlKeywords
    if ( constraints.keyListSize() > 0 ) {
      for (key = pvl.begin() ; key != pvl.end() ; ++key) {
        if ( constraints.isKeyInList(key->name()) ) {
          add(*key);
          n++;
        }
      }
    }
    // otherwise load all PvlKeywords in the PvlContainer provided
    else {
      for (key = pvl.begin() ; key != pvl.end() ; ++key) {
        add(*key);
        n++;
      }
    }
    return (n);
  }
 
} // namespace Isis