TableField.cpp

Go to the documentation of this file.

#include "TableField.h"

#include "IException.h"
#include "PvlGroup.h"
#include "PvlKeyword.h"

using namespace std;
namespace Isis {

  TableField::TableField(const QString &name, TableField::Type type,
                         int size) {
    m_name = name;
    m_type = type;
    m_size = size;
    if (m_type == TableField::Integer) {
      m_bytes = 4 * m_size;
      m_ivalues.resize(m_size);
    }
    else if (m_type == TableField::Double) {
      m_bytes = 8 * m_size;
      m_dvalues.resize(m_size);
    }
    else if (m_type == TableField::Text) {
      m_bytes = 1 * m_size;
      m_svalue.resize(m_size);
    }
    else if (m_type == TableField::Real) {
      m_bytes = 4 * m_size;
      m_rvalues.resize(m_size);
    }
  }

  TableField::TableField(PvlGroup &field) {
    m_name = (QString) field["Name"];
    m_size = (int) field["Size"];
    if ((QString) field["Type"] == "Integer") {
      m_type = TableField::Integer;
      m_bytes = 4 * m_size;
      m_ivalues.resize(m_size);
    }
    else if ((QString) field["Type"] == "Double") {
      m_type = TableField::Double;
      m_bytes = 8 * m_size;
      m_dvalues.resize(m_size);
    }
    else if ((QString) field["Type"] == "Text") {
      m_type = TableField::Text;
      m_bytes = 1 * m_size;
      m_svalue.resize(m_size);
    }
    else if ((QString) field["Type"] == "Real") {
      m_type = TableField::Real;
      m_bytes = 4 * m_size;
      m_rvalues.resize(m_size);
    }
    else {
      QString msg = "Field [" + m_name + "] has invalid type.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }

  TableField::~TableField() {
  }

  QString TableField::name() const {
    return m_name;
  }

  TableField::Type TableField::type() const {
    return m_type;
  }

  bool TableField::isInteger() const {
    return (m_type == TableField::Integer);
  }

  bool TableField::isDouble() const {
    return (m_type == TableField::Double);
  }

  bool TableField::isText() const {
    return (m_type == TableField::Text);
  }

  bool TableField::isReal() const {
    return (m_type == TableField::Real);
  }

  int TableField::bytes() const {
    return m_bytes;
  }

  int TableField::size() const {
    return m_size;
  }

  TableField::operator int() const {
    if (m_type != TableField::Integer) {
      QString msg = "Field [" + m_name + "] is not Integer.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    if (m_ivalues.size() > 1) {
      QString msg = "Field [" + m_name + "] has multiple Integer values. "
                   "Use std::vector<int>().";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    return m_ivalues[0];
  }

  TableField::operator double() const {
    if (m_type != TableField::Double) {
      QString msg = "Field [" + m_name + "] is not a Double.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    if (m_dvalues.size() > 1) {
      QString msg = "Field [" + m_name + "] has multiple Double values. "
                   "Use std::vector<double>().";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    return m_dvalues[0];
  }

  TableField::operator float() const {
    if (m_type != TableField::Real) {
      QString msg = "Field [" + m_name + "] is not Real.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    if (m_rvalues.size() > 1) {
      QString msg = "Field [" + m_name + "] has multiple Real values. "
                   "Use std::vector<float>().";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    return m_rvalues[0];
  }

  TableField::operator QString() const {
    if (m_type != TableField::Text) {
      QString msg = "Field [" + m_name + "] is not Text.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    return QString(m_svalue.toAscii().data());
  }

  TableField::operator std::vector<int>() const {
    if (m_type != TableField::Integer) {
      QString msg = "Field [" + m_name + "] is not an Integer array.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    return m_ivalues;
  }

  TableField::operator std::vector<double>() const {
    if (m_type != TableField::Double) {
      QString msg = "Field [" + m_name + "] is not a Double array.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    return m_dvalues;
  }

  TableField::operator std::vector<float>() const {
    if (m_type != TableField::Real) {
      QString msg = "Field [" + m_name + "] is not a Real array.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    return m_rvalues;
  }

  void TableField::operator=(const int value) {
    if (m_type != TableField::Integer) {
      QString msg = "Unable to set field to the given int value. Field [" 
                   + m_name + "] Type is not Integer.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    if (m_size > 1) {
      QString msg = "Unable to set field to the given int value. "
                    "Field [" + m_name + "] has [" + Isis::toString(m_size) + "] "
                    "Integer values. Use operator=(vector<int>).";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    m_ivalues[0] = value;
  }

  void TableField::operator=(const double value) {
    if (m_type != TableField::Double) {
      QString msg = "Unable to set field to the given double value. Field [" 
                   + m_name + "] Type is not Double.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    if (m_size > 1) {
      QString msg = "Unable to set field to the given double value. "
                    "Field [" + m_name + "] has [" + Isis::toString(m_size) + "] "
                    "Double values. Use operator=(vector<double>).";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    m_dvalues[0] = value;
  }

  void TableField::operator=(const float value) {
    if (m_type != TableField::Real) {
      QString msg = "Unable to set field to the given float value. Field [" 
                   + m_name + "] Type is not Real.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    if (m_size > 1) {
      QString msg = "Unable to set field to the given float value. "
                    "Field [" + m_name + "] has [" + Isis::toString(m_size) + "] "
                    "Real values. Use operator=(vector<float>).";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    m_rvalues[0] = value;
  }

  void TableField::operator=(const QString &value) {
    QString val = value;
    if (m_type != TableField::Text) {
      QString msg = "Unable to set field to the given string value. Field [" 
                    + m_name + "] Type is not Text.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    if (m_size < (int) val.size()) {// automos with tracking ???
      for (int i = m_size; i < val.size(); i++) {
        // if the extra characters are not spaces or nulls, throw an erro
        if (val[i] != ' ' && val[i] != '\0') {
          QString msg = "Unable to set the Text TableField to the given string. "
                        "The number of bytes allowed for this field value [" 
                        + Isis::toString(m_size) + "] is less than the length of the "
                        "given string [" + value + "].";
          throw IException(IException::Unknown, msg, _FILEINFO_);
        }
      }
      // if the extra characters are spaces and nulls, concatenate the string 
      val.resize(m_size);
    }
    m_svalue = val;
  }

  void TableField::operator=(const std::vector<int> &values) {
    if (m_type != TableField::Integer) {
      QString msg = "Unable to set field to the given vector of int values. "
                    "Field [" + m_name + "] Type is not Integer.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    else if ((int) values.size() != m_size) {
      QString msg = "Unable to set field to the given vector of int values. "
                    "Field [" + m_name + "] values has size [" 
                    + Isis::toString(m_size) + "].";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    m_ivalues = values;
  }

  void TableField::operator=(const std::vector<double> &values) {
    if (m_type != TableField::Double) {
      QString msg = "Unable to set field to the given vector of double values. "
                    "Field [" + m_name + "] Type is not Double.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    else if ((int) values.size() != m_size) {
      QString msg = "Unable to set field to the given vector of double values. "
                    "Field [" + m_name + "] values has size [" 
                    + Isis::toString(m_size) + "].";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    m_dvalues = values;
  }

  void TableField::operator=(const std::vector<float> &values) {
    if (m_type != TableField::Real) {
      QString msg = "Unable to set field to the given vector of float values. "
                    "Field [" + m_name + "] Type is not Real.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    else if ((int) values.size() != m_size) {
      QString msg = "Unable to set field to the given vector of float values. "
                    "Field [" + m_name + "] values has size [" 
                    + Isis::toString(m_size) + "].";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    m_rvalues = values;
  }

  void TableField::operator=(const void *ibuf) {
    char *buf = (char *) ibuf;
    if (m_type == TableField::Double) {
      for (unsigned int i = 0; i < m_dvalues.size(); i++) {
        // m_dvalues[i] = ((double *) buf)[i];
        double bufDouble;
        memmove(&bufDouble, buf + i * 8, 8);
        m_dvalues[i] = bufDouble;
      }
    }
    else if (m_type == TableField::Integer) {
      for (unsigned int i = 0; i < m_ivalues.size(); i++) {
        // m_ivalues[i] = ((int *) buf)[i];
        int bufInt;
        memmove(&bufInt, buf + i * 4, 4);
        m_ivalues[i] = bufInt;
      }
    }
    else if (m_type == TableField::Text) {
      m_svalue.resize(bytes());
      for (int i = 0; i < bytes(); i++) {
        m_svalue[i] = buf[i];
      }
    }
    else if (m_type == TableField::Real) {
      for (unsigned int i = 0; i < m_rvalues.size(); i++) {
        // m_ivalues[i] = ((int *) buf)[i];
        float bufFloat;
        memmove(&bufFloat, buf + i * 4, 4);
        m_rvalues[i] = bufFloat;
      }
    }
    else {
      string msg = "Undefined field type [" + IString(m_type) + "].";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }

  void TableField::operator=(const char *buf) {
    if (m_type != TableField::Text) {
      QString msg = "Unable to set field to the given string value. Field [" + m_name + "] Type is not Text.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    m_svalue = buf;
  }

  PvlGroup TableField::pvlGroup() {
    PvlGroup group("Field");
    group += PvlKeyword("Name", m_name);
    if (m_type == TableField::Double) {
      group += PvlKeyword("Type", "Double");
    }
    else if (m_type == TableField::Integer) {
      group += PvlKeyword("Type", "Integer");
    }
    else if (m_type == TableField::Text) {
      group += PvlKeyword("Type", "Text");
    }
    else if (m_type == TableField::Real) {
      group += PvlKeyword("Type", "Real");
    }
    group += PvlKeyword("Size", Isis::toString(m_size));

    return group;
  }


  QString TableField::toString(const TableField &field, QString delimiter){
    QString fieldValues = "";
    if (field.size()== 1){
      if (field.isText()){
        fieldValues = (QString)field;
      }
      else if (field.isInteger()){
        fieldValues = Isis::toString((int)field);
      }
      else if (field.isDouble()){
        fieldValues = Isis::toString((double)field);
      }
      else { //real
        fieldValues = Isis::toString((float)field);
      }
    }
    // Otherwise, build a vector to contain the entries
    else {
      if (field.isText()){
        fieldValues +=(QString)field;
      }
      else if (field.isInteger()){
        vector< int > currField = field;
        for (int i = 0;i <(int)currField.size();i++){
          fieldValues += Isis::toString(currField[i]);
          if (i <(int)currField.size()- 1){
            // add delimiter for all but the last element of the field
            fieldValues += delimiter;
          }
        }
      }
      else if (field.isDouble()){
        vector< double > currField = field;
        for (int i = 0;i <(int)currField.size();i++){
          fieldValues += Isis::toString(currField[i]);
          if (i <(int)currField.size()- 1){
            fieldValues += delimiter;
          }
        }
      }
      else { //if (field.isReal()) {
        vector< float > currField = field;
        for (int i = 0;i <(int)currField.size();i++){
          fieldValues += Isis::toString(currField[i]);
          if (i <(int)currField.size()- 1){
            fieldValues += delimiter;
          }
        }
      }
    }
    return fieldValues;
  }
} // end namespace isis