Table.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "Table.h"
 
#include <fstream>
#include <sstream>
#include <string>
 
#include "Blob.h"
#include "Endian.h"
#include "IException.h"
#include "TableField.h"
 
using namespace std;
namespace Isis {
 
  Table::Table(Blob &blob) {
    initFromBlob(blob);
  }
 

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

  Table::Table(const QString &tableName) {
    p_name = tableName;
    p_assoc = Table::None;
  }
  Table::Table(const QString &tableName) {…}
 

  Table::Table(const QString &tableName, const QString &file) {
    Blob blob(tableName, "Table", file);
    initFromBlob(blob);
  }
  Table::Table(const QString &tableName, const QString &file) {…}
 

  Table::Table(const QString &tableName, const QString &file, const Pvl &fileHeader) {
    Blob blob(tableName, "Table");
    blob.Read(file, fileHeader);
    initFromBlob(blob);
  }
  Table::Table(const QString &tableName, const QString &file, const Pvl &fileHeader) {…}
 

  Table::Table(const Table &other) {
    p_name = other.p_name;
    p_label = other.p_label;
    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(const Table &other) {…}

  Table::Table(const QString &tableName, const std::string &tableString, const char &fieldDelimiter) {
    p_name = tableName;
 
    std::stringstream tableStream;
    tableStream << tableString;
 
    std::vector<std::string> tableLinesStringList;
    std::string line;
    while(std::getline(tableStream, line, '\n')) {
      tableLinesStringList.push_back(line);
    }
 
    int numOfFieldValues = tableLinesStringList.size() - 1; // minus the header line 
 
    std::string fieldNamesLineString = tableLinesStringList.front();
    std::stringstream fieldNamesStringStream;
    fieldNamesStringStream << fieldNamesLineString;
 
    std::vector<QString> fieldNames;
    std::string fieldNameString;
    while(std::getline(fieldNamesStringStream, fieldNameString, fieldDelimiter)) {
      fieldNames.push_back(QString::fromStdString(fieldNameString));
    }
 
    // Clear error flags and set pointer back to beginning
    tableStream.clear();
    tableStream.seekg(0, ios::beg);
 
    // Add records to table
    std::string recordString;
    int index = 0;
    while(std::getline(tableStream, recordString, '\n')) {
      // skip first line bc that's the header line
      if (index == 0) {
        index++;
        continue;
      }
      
      TableRecord tableRecord(recordString, fieldDelimiter, fieldNames, numOfFieldValues);
      p_record = tableRecord;
      this->operator+=(tableRecord);
      index++;
    }
 
    // Add fields
    for (int f = 0; f < p_record.Fields(); f++) {
      p_label.addGroup(p_record[f].pvlGroup());
    }
  }
  Table::Table(const QString &tableName, const std::string &tableString, const char &fieldDelimiter) {…}
 

  void Table::initFromBlob(Blob &blob) {
    Clear();
 
    p_label = blob.Label();
 
    p_name = p_label["Name"][0];
    p_records = p_label["Records"];
 
    Isis::TableRecord rec;
    for (int g = 0; g < p_label.groups(); g++) {
      if (p_label.group(g).isNamed("Field")) {
        Isis::TableField f(p_label.group(g));
        rec += f;
      }
    }
 
    p_record = rec;
 
    p_assoc = Table::None;
    if (p_label.hasKeyword("Association")) {
      QString temp = (QString) p_label["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_label["ByteOrder"]);
    p_swap = false;
    if (Isis::IsLsb() && (bo == Isis::Msb)) p_swap = true;
    if (Isis::IsMsb() && (bo == Isis::Lsb)) p_swap = true;
 
    for (int rec = 0; rec < p_records; rec++) {
      size_t bufferPos = rec * RecordSize();
 
      char *buf = new char[RecordSize()];
      memcpy(buf, &blob.getBuffer()[bufferPos], RecordSize());
 
      if (p_swap) p_record.Swap(buf);
      p_recbufs.push_back(buf);
    }
  }
  void Table::initFromBlob(Blob &blob) {…}
 

  Table &Table::operator=(const Isis::Table &other) {
    Clear();
    p_name = other.p_name;
    p_label = other.p_label;
    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::operator=(const Isis::Table &other) {…}
 

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

  void Table::Write(const QString &file) {
    Blob blob = toBlob();
    blob.Write(file);
  }
  void Table::Write(const QString &file) {…}
 

  QString Table::Name() const {
    return p_name;
  }
  QString Table::Name() const  {…}
 

  PvlObject &Table::Label() {
    return p_label;
  }
  PvlObject &Table::Label() {…}
 

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

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

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

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

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

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

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

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

  void Table::operator+=(Isis::TableRecord &rec) {
    if (RecordSize() == 0) {
      IString msg = "Unable to add records to Isis Table ["
                    + p_name + "]. 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_name + "] 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::operator+=(Isis::TableRecord &rec) {…}
 

  void Table::Update(const Isis::TableRecord &rec, const int index) {
    rec.Pack(p_recbufs[index]);
  }
  void Table::Update(const Isis::TableRecord &rec, const int 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::Delete(const int index) {…}
 

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

  Blob Table::toBlob() const {
    Blob tableBlob(Name(), "Table");
    PvlObject &blobLabel = tableBlob.Label();
 
    // Label setup
    blobLabel += PvlKeyword("Records", Isis::toString(Records()));
    int nbytes = Records() * RecordSize();
 
    if (Isis::IsLsb()) {
      blobLabel+= PvlKeyword("ByteOrder", Isis::ByteOrderName(Isis::Lsb));
    }
    else {
      blobLabel+= PvlKeyword("ByteOrder", Isis::ByteOrderName(Isis::Msb));
    }
 
    if (p_assoc == Samples) {
      blobLabel += Isis::PvlKeyword("Association", "Samples");
    }
    else if (p_assoc == Lines) {
      blobLabel += Isis::PvlKeyword("Association", "Lines");
    }
    else if (p_assoc == Bands) {
      blobLabel += Isis::PvlKeyword("Association", "Bands");
    }
 
    for (int i = 0; i < p_label.keywords(); i++) {
      if (!blobLabel.hasKeyword(p_label[i].name())) {
        blobLabel += p_label[i];
      }
    }
 
    for (int i = 0; i < p_label.comments(); i++){
      blobLabel.addComment(p_label.comment(i));
    }
 
    for (int g = 0; g < p_label.groups(); g++) {
      blobLabel += p_label.group(g);
    }
 
    // Binary data setup
    char *buf = new char[nbytes];
 
    for (int rec = 0; rec < Records(); rec++) {
      size_t bufferPos = rec * RecordSize();
 
      memcpy(&buf[bufferPos], p_recbufs[rec], RecordSize());
    }
 
    tableBlob.takeData(buf, nbytes);
 
    return tableBlob;
  }
  Blob Table::toBlob() const  {…}
 

  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;
  }
  QString Table::toString(Table table, QString fieldDelimiter) {…}
 
}