CubeAttribute.h

#ifndef CubeAttribute_h
#define CubeAttribute_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <typeinfo>
 
#include <QDebug>
#include <QStringList>
 
#include "Cube.h"
#include "IEndian.h"
#include "FileName.h"
#include "IException.h"
#include "PixelType.h"
 
 
namespace Isis {
  inline QString LabelAttachmentName(Cube::LabelAttachment labelType) {
    if(labelType == Cube::AttachedLabel) return "Attached";
    if(labelType == Cube::DetachedLabel) return "Detached";
    if(labelType == Cube::ExternalLabel) return "External";
    if(labelType == Cube::GdalLabel) return "Gdal";
 
    QString msg = "Invalid label attachment type [" + QString::number(labelType) + "]";
    throw IException(IException::Programmer, msg, _FILEINFO_);
  }
 

  inline Cube::LabelAttachment LabelAttachmentEnumeration(const QString &labelType) {
    QString temp = labelType.toUpper();
    if(temp == "ATTACHED") return Cube::AttachedLabel;
    if(temp == "DETACHED") return Cube::DetachedLabel;
    if(temp == "EXTERNAL") return Cube::ExternalLabel;
    if(temp == "GDAL") return Cube::GdalLabel;
 
    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("+", Qt::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;

      bool propagateFileFormat() 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(Cube::LabelAttachment attachment);
 
      Cube::LabelAttachment labelAttachment() const;
 
      using CubeAttribute<CubeAttributeOutput>::toString;
 
      static QString toString(Cube::Format);
 
    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;

      enum RangeType {
        PropagateRange, 
        RangeSet,       
      };
 
      static QList<bool (CubeAttributeOutput::*)(QString) const> testers();
  };
};
 
#endif