Table.cpp

Go to the documentation of this file.

#include "Table.h"

#include <fstream>
#include <string>

#include "Endian.h"
#include "IException.h"
#include "Pvl.h"
#include "TableField.h"

using namespace std;
namespace Isis {

  Table::Table(const QString &tableName, Isis::TableRecord &rec) :
    Blob(tableName, "Table") {
    p_assoc = Table::None;
    p_blobPvl += Isis::PvlKeyword("Records", 0);
    p_blobPvl += Isis::PvlKeyword("ByteOrder", "NULL");
    for (int f = 0; f < rec.Fields(); f++) p_blobPvl.addGroup(rec[f].pvlGroup());
    p_record = rec;
  }

  Table::Table(const QString &tableName) :
    Isis::Blob(tableName, "Table") {
    p_assoc = Table::None;
  }

  Table::Table(const QString &tableName, const QString &file) :
    Blob(tableName, "Table") {
    p_assoc = Table::None;
    Read(file);
  }

  Table::Table(const QString &tableName, const QString &file,
      const Pvl &fileHeader) : Blob(tableName, "Table") {
    p_assoc = Table::None;
    Read(file, fileHeader);
  }


  Table::Table(const Table &other) : Blob(other) {
    p_record = other.p_record;
    p_records = other.p_records;
    p_assoc = other.p_assoc;
    p_swap = other.p_swap;

    for (unsigned int i = 0; i < other.p_recbufs.size(); i++) {
      char *data = new char[RecordSize()];

      for (int j = 0; j < RecordSize(); j++) {
        data[j] = other.p_recbufs[i][j];
      }

      p_recbufs.push_back(data);
    }
  }

  Table &Table::operator=(const Isis::Table &other) {
    Clear();
    *((Isis::Blob *)this) = *((Isis::Blob *)&other);
    p_record = other.p_record;
    p_records = other.p_records;
    p_assoc = other.p_assoc;
    p_swap = other.p_swap;

    for (unsigned int i = 0; i < other.p_recbufs.size(); i++) {
      char *data = new char[RecordSize()];

      for (int j = 0; j < RecordSize(); j++) {
        data[j] = other.p_recbufs[i][j];
      }

      p_recbufs.push_back(data);
    }

    return *this;
  }

  Table::~Table() {
    Clear();
  }

  void Table::SetAssociation(const Table::Association assoc) {
    p_assoc = assoc;
  }

  bool Table::IsSampleAssociated() {
    return (p_assoc == Table::Samples);
  }

  bool Table::IsLineAssociated() {
    return (p_assoc == Table::Lines);
  }

  bool Table::IsBandAssociated() {
    return (p_assoc == Table::Bands);
  }

  int Table::Records() const {
    return p_recbufs.size();
  }

  int Table::RecordFields() const {
    return p_record.Fields();
  }

  int Table::RecordSize() const {
    return p_record.RecordSize();
  }

  Isis::TableRecord &Table::operator[](const int index) {
    p_record.Unpack(p_recbufs[index]);
    return p_record;
  }

  void Table::operator+=(Isis::TableRecord &rec) {
    if (RecordSize() == 0) {
      IString msg = "Unable to add records to Isis Table [" 
                    + p_blobName + "]. Bytes per record = [0 bytes].";
      throw IException(IException::Unknown, msg, _FILEINFO_);
    }

     if (RecordSize() != rec.RecordSize()) {
       QString msg = "Unable to add the given record with size = [" 
                     + Isis::toString(rec.RecordSize()) + " bytes] to to Isis Table [" 
                     + p_blobName + "] with record size = [" 
                     + Isis::toString(RecordSize()) + " bytes]. Record sizes must match.";
       throw IException(IException::Unknown, msg, _FILEINFO_);
     }
    char *newbuf = new char[RecordSize()];
    rec.Pack(newbuf);
    p_recbufs.push_back(newbuf);
  }

  void Table::Update(const Isis::TableRecord &rec, const int index) {
    rec.Pack(p_recbufs[index]);
  }

  void Table::Delete(const int index) {
    vector<char *>::iterator it = p_recbufs.begin();
    for (int i = 0; i < index; i++, it++);
    delete [] p_recbufs[index];
    p_recbufs.erase(it);
  }

  void Table::Clear() {
    for (int i = 0; i < (int)p_recbufs.size(); i++) delete [] p_recbufs[i];
    p_recbufs.clear();
  }

  void Table::ReadInit() {
    p_records = p_blobPvl["Records"];

    Isis::TableRecord rec;
    for (int g = 0; g < p_blobPvl.groups(); g++) {
      if (p_blobPvl.group(g).isNamed("Field")) {
        Isis::TableField f(p_blobPvl.group(g));
        rec += f;
      }
    }

    p_record = rec;

    if (p_blobPvl.hasKeyword("Association")) {
      QString temp = (QString) p_blobPvl["Association"];
      temp = temp.toUpper();
      if (temp == "SAMPLES") p_assoc = Table::Samples;
      if (temp == "LINES") p_assoc = Table::Lines;
      if (temp == "BANDS") p_assoc = Table::Bands;
    }

    // Determine if we need to swap stuff when we read the data
    Isis::ByteOrder bo = Isis::ByteOrderEnumeration(p_blobPvl["ByteOrder"]);
    p_swap = false;
    if (Isis::IsLsb() && (bo == Isis::Msb)) p_swap = true;
    if (Isis::IsMsb() && (bo == Isis::Lsb)) p_swap = true;

    // Cleanup in case of a re-read
    Clear();
  }

  void Table::ReadData(std::istream &stream) {
    for (int rec = 0; rec < p_records; rec++) {
      streampos sbyte = (streampos)(p_startByte - 1) +
                        (streampos)(rec * RecordSize());
      stream.seekg(sbyte, std::ios::beg);
      if (!stream.good()) {
        QString msg = "Error preparing to read record [" + Isis::toString(rec + 1) + 
                     "] from Table [" + p_blobName + "]";
        throw IException(IException::Io, msg, _FILEINFO_);
      }

      char *buf = new char[RecordSize()];
      stream.read(buf, RecordSize());
      if (!stream.good()) {
        QString msg = "Error reading record [" + Isis::toString(rec + 1) + 
                      "] from Table [" + p_blobName + "]";
        throw IException(IException::Io, msg, _FILEINFO_);
      }

      if (p_swap) p_record.Swap(buf);
      p_recbufs.push_back(buf);
    }
  }

  void Table::WriteInit() {
    p_blobPvl["Records"] = Isis::toString(Records());
    p_nbytes = Records() * RecordSize();

    if (Isis::IsLsb()) {
      p_blobPvl["ByteOrder"] = Isis::ByteOrderName(Isis::Lsb);
    }
    else {
      p_blobPvl["ByteOrder"] = Isis::ByteOrderName(Isis::Msb);
    }

    if (p_blobPvl.hasKeyword("Association")) {
      p_blobPvl.deleteKeyword("Association");
    }
    if (p_assoc == Samples) {
      p_blobPvl += Isis::PvlKeyword("Association", "Samples");
    }
    else if (p_assoc == Lines) {
      p_blobPvl += Isis::PvlKeyword("Association", "Lines");
    }
    else if (p_assoc == Bands) {
      p_blobPvl += Isis::PvlKeyword("Association", "Bands");
    }
  }

  void Table::WriteData(std::fstream &os) {
    for (int rec = 0; rec < Records(); rec++) {
      os.write(p_recbufs[rec], RecordSize());
    }
  }


  QString Table::toString(Table table, QString fieldDelimiter) {
    QString tableValues;
    // add the first record with header, the given delimiter, and a new line after each record
    tableValues += TableRecord::toString(table[0], fieldDelimiter, true, true);
    // add remaining records without header, the same delimeter, and new line after each record
    for (int recordIndex = 1; recordIndex < table.Records(); recordIndex++) {
      tableValues += TableRecord::toString(table[recordIndex], fieldDelimiter);
    }
    return tableValues;
  }

}