CubeAttribute.h

Go to the documentation of this file.

#ifndef CubeAttribute_h
#define CubeAttribute_h

#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