Blob.cpp

Go to the documentation of this file.

#include "Blob.h"

#include <cstring>
#include <fstream>
#include <sstream>

#include <QDebug>

#include "FileName.h"
#include "IException.h"
#include "Message.h"
#include "Pvl.h"

using namespace std;
namespace Isis {
  Blob::Blob(const QString &name, const QString &type) {
    p_blobName = name;
    p_buffer = NULL;
    p_labelFile = "";
    p_nbytes = 0;
    p_type = type;

    p_blobPvl.setName(p_type);
    p_blobPvl += PvlKeyword("Name", p_blobName);
    p_blobPvl += PvlKeyword("StartByte", "0");
    p_blobPvl += PvlKeyword("Bytes", "0");
  }

  Blob::Blob(const QString &name, const QString &type, 
             const QString &file) {
    p_blobName = name;
    p_buffer = NULL;
    p_nbytes = 0;
    p_type = type;
    p_labelFile = FileName(file).expanded();

    Read(file);
  }

  Blob::Blob(const Blob &other) {
    p_blobPvl = other.p_blobPvl;
    p_blobName = other.p_blobName;
    p_startByte = other.p_startByte;
    p_nbytes = other.p_nbytes;
    p_type = other.p_type;
    p_detached = other.p_detached;
    p_labelFile = other.p_labelFile;

    p_buffer = NULL;

    if (other.p_buffer) {
      p_buffer = new char[p_nbytes];

      for (int i = 0; i < p_nbytes; i++) {
        p_buffer[i] = other.p_buffer[i];
      }
    }
  }

  Blob &Blob::operator=(const Blob &other) {
    p_blobPvl = other.p_blobPvl;
    p_blobName = other.p_blobName;
    p_startByte = other.p_startByte;
    p_nbytes = other.p_nbytes;
    p_type = other.p_type;
    p_detached = other.p_detached;
    p_labelFile = other.p_labelFile;

    p_buffer = NULL;

    if (other.p_buffer) {
      p_buffer = new char[p_nbytes];

      for (int i = 0; i < p_nbytes; i++) {
        p_buffer[i] = other.p_buffer[i];
      }
    }

    return *this;
  }

  Blob::~Blob() {
    if (p_buffer != NULL) delete [] p_buffer;
  }

  QString Blob::Type() const {
    return p_type;
  }

  QString Blob::Name() const {
    return p_blobName;
  }

  int Blob::Size() const {
    return p_nbytes;
  }

  PvlObject &Blob::Label() {
    return p_blobPvl;
  }

  void Blob::Find(const Pvl &pvl) {
    bool found = false;
    try {
      // Search for the blob name
      QString blobName = p_blobName.toUpper();
      for (int o = 0; o < pvl.objects(); o++) {
        const PvlObject &obj = pvl.object(o);
        if (obj.isNamed(p_type)) {
          QString curName = obj["Name"];
          curName = curName.toUpper();
          if (blobName == curName) {
            p_blobPvl = obj;
            found = true;
            break;
          }
          else {
            if (p_type == "OriginalLabel" && curName == "ORIGINALLABEL") {
              p_blobPvl = obj;
              found = true;
              break;
            }
          }
        }
      }
    }
    catch (IException &e) {
      QString msg = "Invalid " + p_type + " label format";
      throw IException(e, IException::Unknown, msg, _FILEINFO_);
    }

    // Did we find it?
    if (!found) {
      QString msg = "Unable to find " + p_type + " [" + p_blobName + "]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    // Ok the blob exists so we need to prep for reading the binary data
    try {
      p_startByte = p_blobPvl["StartByte"];
      p_nbytes = p_blobPvl["Bytes"];
      p_detached = "";
      if (p_blobPvl.hasKeyword("^" + p_type)) {
        QString path = "";
        if (p_labelFile != "") {
          path = FileName(p_labelFile).path() + "/";
        }
        p_detached = path + (QString) p_blobPvl["^"+p_type];
        p_blobPvl.deleteKeyword("^" + p_type);
      }
    }
    catch (IException &e) {
      QString msg = "Invalid " + p_type + " label format";
      throw IException(e, IException::Unknown, msg, _FILEINFO_);
    }
  }

  void Blob::Read(const QString &file) {
    // Expand the filename
    QString temp(FileName(file).expanded());

    // Get the pvl
    Pvl pvl;
    try {
      pvl.read(temp);
    }
    catch (IException &e) {
      QString msg = "Invalid " + p_type + " label format";
      throw IException(e, IException::Unknown, msg, _FILEINFO_);
    }

    Read(file, pvl);
  }

  void Blob::Read(const QString &file, const Pvl &pvlLabels) {

    // Expand the filename
    QString temp(FileName(file).expanded());

    // Open the file
    fstream istm;
    istm.open(temp.toAscii().data(), std::ios::in);
    if (!istm) {
      QString message = Message::FileOpen(temp);
      throw IException(IException::Io, message, _FILEINFO_);
    }

    try {
      // Check pvl and read from the stream
      Read(pvlLabels, istm);
    }
    catch (IException &e) {
      istm.close();
      QString msg = "Unable to open " + p_type + " [" + p_blobName +
                   "] in file [" + temp + "]";
      throw IException(e, IException::Io, msg, _FILEINFO_);
    }

    istm.close();
  }

  void Blob::Read(const Pvl &pvl, std::istream &istm) {
    try {
      Find(pvl);
      ReadInit();
      if (p_detached != "") {
        fstream dstm;
        dstm.open(p_detached.toAscii().data(), std::ios::in);
        if (!dstm) {
          QString message = Message::FileOpen(p_detached);
          throw IException(IException::Io, message, _FILEINFO_);
        }
        ReadData(dstm);
      }
      else {
        ReadData(istm);
      }
    }
    catch (IException &e) {
      QString msg = "Unable to read " + p_type + " [" + p_blobName + "]";
      throw IException(e, IException::Io, msg, _FILEINFO_);
    }
  }

  void Blob::ReadInit(){
  }

  void Blob::ReadData(std::istream &stream) {
    // Read the binary data
    if (p_buffer != NULL) delete [] p_buffer;
    p_buffer = new char[p_nbytes];

    streampos sbyte = p_startByte - 1;
    stream.seekg(sbyte, std::ios::beg);
    if (!stream.good()) {
      QString msg = "Error preparing to read data from " + p_type +
                   " [" + p_blobName + "]";
      throw IException(IException::Io, msg, _FILEINFO_);
    }

    stream.read(p_buffer, p_nbytes);
    if (!stream.good()) {
      QString msg = "Error reading data from " + p_type + " [" + p_blobName + "]";
      throw IException(IException::Io, msg, _FILEINFO_);
    }
  }

  void Blob::Write(const QString &file) {
    // Determine the size of the label and write it out
    try {
      WriteInit();
      Pvl pvl;
      pvl.addObject(p_blobPvl);
      ostringstream os;
      os << pvl << endl;
      os.seekp(0, std::ios::end);
      BigInt nbytes = (BigInt) os.tellp() + (BigInt) 64;
      p_startByte = nbytes + 1 + 1; // 1-based;
      pvl.findObject(p_type)["StartByte"] = toString(p_startByte);
      pvl.findObject(p_type)["Bytes"] = toString(p_nbytes);
      pvl.write(file);

      // Prepare and write the binary data
      fstream stream;
      ios::openmode flags = std::ios::in | std::ios::binary | std::ios::out;
      stream.open(file.toAscii().data(), flags);
      if (!stream) {
        QString message = "Unable to open [" + file + "]";
        throw IException(IException::Io, message, _FILEINFO_);
      }

      streampos sbyte = p_startByte - 1;
      stream.seekp(sbyte, std::ios::beg);
      if (!stream.good()) {
        stream.close();
        QString msg = "Error preparing to write data to " +
                     p_type + " [" + p_blobName + "]";
        throw IException(IException::Io, msg, _FILEINFO_);
      }

      WriteData(stream);
      stream.close();
    }
    catch (IException &e) {
      QString msg = "Unable to create " + p_type + " file [" + file + "]";
      throw IException(e, IException::Io, msg, _FILEINFO_);
    }
  }

  void Blob::Write(Pvl &pvl, std::fstream &stm,
                   const QString &detachedFileName) {
    // Handle 64-bit I/O
    WriteInit();

    // Find out where they wanted to write the blob
    streampos sbyte = stm.tellp();
    sbyte += 1;

    // Find out where the end-of-file is
    stm.seekp(0, std::ios::end);
    streampos eofbyte = stm.tellp();
    eofbyte += 1;

    // Handle detached blobs
    if (detachedFileName != "") {
      p_blobPvl += PvlKeyword("^" + p_type, detachedFileName);
    }

    // See if the blob is already in the file
    p_blobPvl["StartByte"] = toString((BigInt)sbyte);
    p_blobPvl["Bytes"] = toString(p_nbytes);

    bool found = false;
    for (int i = 0; i < pvl.objects(); i++) {
      if (pvl.object(i).name() == p_blobPvl.name()) {
        PvlObject &obj = pvl.object(i);
        if ((QString)obj["Name"] == (QString)p_blobPvl["Name"]) {
          found = true;

          BigInt oldSbyte = obj["StartByte"];
          int oldNbytes = (int) obj["Bytes"];

          // Does it fit in the old space
          if (p_nbytes <= oldNbytes) {
            p_blobPvl["StartByte"] = obj["StartByte"];
            sbyte = oldSbyte;
          }

          // Was the old space at the end of the file
          else if (((oldSbyte + oldNbytes) == eofbyte) &&
                  (eofbyte >= sbyte)) {
            p_blobPvl["StartByte"] = obj["StartByte"];
            sbyte = oldSbyte;
          }

          // Put it at the requested position/end of the file
          else {
            // Leave this here for clarity
          }

          obj = p_blobPvl;
        }
      }
    }

    // Didn't find the same blob so add it to the labels
    if (!found) {
      pvl.addObject(p_blobPvl);
    }

    stm.seekp((BigInt) sbyte - (BigInt)1);
    WriteData(stm);

    // Handle detached blobs
    if (detachedFileName != "") {
      p_blobPvl.deleteKeyword("^" + p_type);
    }
  }

  void Blob::WriteInit(){
  }

  void Blob::WriteData(std::fstream &stream) {
    stream.write(p_buffer, p_nbytes);
    if (!stream.good()) {
      QString msg = "Error writing data to " + p_type + " [" + p_blobName + "]";
      throw IException(IException::Io, msg, _FILEINFO_);
    }
  }


  bool IsBlob(PvlObject &obj) {
    if (obj.isNamed("TABLE")) return true;
    return false;
  }
} // end namespace isis