CubeAttribute.h

#ifndef CubeAttribute_h
#define CubeAttribute_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <typeinfo>
 
#include <QDebug>
#include <QStringList>
 
#include "Cube.h"
#include "Endian.h"
#include "FileName.h"
#include "IException.h"
#include "PixelType.h"
 
 
namespace Isis {
  enum LabelAttachment {
    AttachedLabel,  
    DetachedLabel,  
 
    ExternalLabel
  };
 
 
  inline QString LabelAttachmentName(LabelAttachment labelType) {
    if(labelType == AttachedLabel) return "Attached";
    if(labelType == DetachedLabel) return "Detached";
    if(labelType == ExternalLabel) return "External";
 
    QString msg = "Invalid label attachment type [" + QString::number(labelType) + "]";
    throw IException(IException::Programmer, msg, _FILEINFO_);
  }
 
 
  inline LabelAttachment LabelAttachmentEnumeration(const QString &labelType) {
    QString temp = labelType.toUpper();
    if(temp == "ATTACHED") return AttachedLabel;
    if(temp == "DETACHED") return DetachedLabel;
    if(temp == "External") return ExternalLabel;
 
    QString msg = "Invalid label attachment type string [" + labelType + "]";
    throw IException(IException::Unknown, msg, _FILEINFO_);
  }
 
 
 
  template<typename ChildClass> class CubeAttribute {
    public:
 
      CubeAttribute(QList< bool (ChildClass::*)(QString) const > testers) {
        m_attributeTypeTesters = testers;
      }
 
 
      CubeAttribute(QList< bool (ChildClass::*)(QString) const > testers,
                    const FileName &fileName) {
        m_attributeTypeTesters = testers;
        setAttributes(fileName);
      }
 
 
      virtual ~CubeAttribute() {
      }
 
 
      QString toString() const {
        QString result;
 
        if (!m_attributes.isEmpty())
          result = "+" + m_attributes.join("+");
 
        return result;
      }
 
 
      void addAttribute(QString attribute) {
        QString upcaseAtt = attribute.toUpper();
 
        if (attribute.contains("+")) {
          throw IException(IException::Unknown,
                           "Individual attributes (for example, BSQ) cannot contain the '+' "
                           "character because that is used to denote the separation of individual "
                           "attributes",
                           _FILEINFO_);
        }
 
        // Verify this attribute is legal
        bool legal = false;
        bool (ChildClass::*tester)(QString) const;
        foreach (tester, m_attributeTypeTesters) {
          if ( (static_cast<const ChildClass *>(this)->*tester)(upcaseAtt) ) {
            if (legal) {
              throw IException(IException::Unknown,
                               QObject::tr("Attribute [%1] is ambiguous").arg(attribute),
                               _FILEINFO_);
            }
 
            legal = true;
          }
        }
 
        if (!legal) {
          throw IException(IException::Unknown,
                           QObject::tr("Attribute [%1] is not recognized").arg(attribute),
                           _FILEINFO_);
        }
 
        m_attributes.append(attribute);
      }
 
 
      void addAttributes(const FileName &fileNameWithAtts) {
        addAttributes(fileNameWithAtts.attributes());
      }
 
 
      void addAttributes(const char *attributesString) {
        addAttributes(QString(attributesString));
      }
 
 
      void addAttributes(const QString &attributesString) {
        setAttributes(toString() + "+" + attributesString);
      }
 
 
      void setAttributes(const FileName &fileName) {
        QStringList attributes = fileName.attributes().split("+", QString::SkipEmptyParts);
 
        m_attributes.clear();
        foreach (QString attribute, attributes)
          addAttribute(attribute);
      }
 
 
    protected:
      QStringList attributeList(bool (ChildClass::*tester)(QString) const) const {
        QStringList relevantAttributes;
 
        foreach (QString attribute, m_attributes) {
          QString upcaseAtt = attribute.toUpper();
          if ( (static_cast<const ChildClass *>(this)->*tester)(upcaseAtt) ) {
            relevantAttributes.append(upcaseAtt);
          }
        }
 
        return relevantAttributes;
      }
 
 
      void setAttribute(QString newValue, bool (ChildClass::*tester)(QString) const) {
        QMutableListIterator<QString> it(m_attributes);
 
        bool found = false;
        while (it.hasNext()) {
          QString &attribute = it.next();
 
          QString upcaseAtt = attribute.toUpper();
          if ( (static_cast<const ChildClass *>(this)->*tester)(upcaseAtt) ) {
            if (found || newValue == "") {
              // already found one (remove the duplicate) or just deleting it
              it.remove();
            }
            else {
              // modify existing attribute value
              attribute = newValue;
            }
 
            found = true;
          }
        }
 
        // Attribute doesn't exist, add it
        if (!found && newValue != "") {
          m_attributes.append(newValue);
        }
      }
 
    private:
      QStringList m_attributes;
 
      QList< bool (ChildClass::*)(QString) const > m_attributeTypeTesters;
  };
 
 
  class CubeAttributeInput : public CubeAttribute<CubeAttributeInput> {
 
    public:
 
      CubeAttributeInput();
 
 
      CubeAttributeInput(const FileName &fileName);
 
 
      ~CubeAttributeInput();
 
 
      std::vector<QString> bands() const;
 
      QString bandsString() const;
 
      void setBands(const std::vector<QString> &bands);
 
      using CubeAttribute<CubeAttributeInput>::toString;
 
    private:
      bool isBandRange(QString attribute) const;
 
      static QString toString(const std::vector<QString> &bands);
      static QList<bool (CubeAttributeInput::*)(QString) const> testers();
 
    private:
      std::vector<QString> m_bands; 
  };
 
 
  class CubeAttributeOutput : public CubeAttribute<CubeAttributeOutput> {
 
    public:
 
      CubeAttributeOutput();
 
      CubeAttributeOutput(const FileName &fileName);
 
 
      ~CubeAttributeOutput();
 
 
      bool propagatePixelType() const;
 
      bool propagateMinimumMaximum() const;
 
      Cube::Format fileFormat() const;
 
      QString fileFormatString() const;
 
      void setFileFormat(Cube::Format fmt);
 
      ByteOrder byteOrder() const;
 
      QString byteOrderString() const;
 
      void setByteOrder(ByteOrder order);
 
      double minimum() const;
 
      double maximum() const;
 
      void setMinimum(double min);
 
      void setMaximum(double max);
 
      PixelType pixelType() const;
 
      void setPixelType(PixelType type);
 
      void setLabelAttachment(LabelAttachment attachment);
 
      LabelAttachment labelAttachment() const;
 
      using CubeAttribute<CubeAttributeOutput>::toString;
 
 
    private:
      bool isByteOrder(QString attribute) const;
      bool isFileFormat(QString attribute) const;
      bool isLabelAttachment(QString attribute) const;
      bool isPixelType(QString attribute) const;
      bool isRange(QString attribute) const;
 
      static QString toString(Cube::Format);
 
      enum RangeType {
        PropagateRange, 
        RangeSet,       
      };
 
      static QList<bool (CubeAttributeOutput::*)(QString) const> testers();
  };
};
 
#endif