Kernel.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "Kernel.h"
 
#include <QString>
#include <QStringList>
 
using namespace std;
namespace Isis {
  Kernel::Kernel() {
    m_kernelType = static_cast<Type>(0);
    m_kernels.clear();
  }
 
  Kernel::~Kernel() {
  }
 
  Kernel::Kernel(Type type, const QStringList &data) {
    m_kernelType = type;
    m_kernels = data;
  }
 
  Kernel::Type Kernel::typeEnum(const QString &type) {
    QString strng = type.simplified().trimmed().toUpper();
    if (strng == "PREDICTED") return Predicted;
    if (strng == "NADIR") return Nadir;
    if (strng == "RECONSTRUCTED") return Reconstructed;
    if (strng == "SMITHED") return Smithed;
 
    return static_cast<Kernel::Type>(0);
  };
 
  const char *Kernel::typeEnum(const Type &type) {
    if (type == Predicted) return "Predicted";
    if (type == Nadir) return "Nadir";
    if (type == Reconstructed) return "Reconstructed";
    if (type == Smithed) return "Smithed";
 
    return "Unknown";
  };
 
  QStringList Kernel::kernels() {
    return m_kernels;
  }
 
  Kernel::Type Kernel::type() {
    return m_kernelType;
  }
 
  void Kernel::setKernels(QStringList data) {
    m_kernels = data;
  }
 
  void Kernel::setType(const Type &type) {
    m_kernelType = type;
  }
 
  int Kernel::size() {
    return m_kernels.size();
  }
 
  void Kernel::push_back(const QString &str) {
    m_kernels.push_back(str);
  }
 
  QString &Kernel::operator[](const int index) {
    return m_kernels[index];
  }
 
  QString Kernel::operator[](const int index) const {
    return m_kernels[index];
  }
 
  bool Kernel::operator<(const Kernel &other) const {
    return (this->m_kernelType < other.m_kernelType);
  }
 
 
  Kernel::Type operator|(Kernel::Type a, Kernel::Type b) {
      return static_cast<Kernel::Type>(static_cast<int>(a) | static_cast<int>(b));
  }
} //end namespace isis