Storage.cc

Go to the documentation of this file.

#include "Utilities/StorageFactory/interface/Storage.h"
#include "FWCore/Utilities/interface/Exception.h"
#include <cassert>

using namespace edm::storage;

Storage::Storage() {}

Storage::~Storage() {}

IOSize Storage::read(IOBuffer into, IOOffset pos) { return read(into.data(), into.size(), pos); }

IOSize Storage::read(void *into, IOSize n, IOOffset pos) {
  // FIXME: this is not thread safe!  split into separate interface
  // that a particular storage can choose to support or not?  make
  // sure that throw semantics are correct here!
  // FIXME: use saveposition object in case exceptions are thrown?
  IOOffset here = position();
  position(pos);
  n = read(into, n);
  position(here);
  return n;
}

IOSize Storage::readv(IOPosBuffer *into, IOSize n) {
  IOOffset here = position();
  IOSize total = 0;
  for (IOSize i = 0; i < n; ++i) {
    try {
      position(into[i].offset());
      total += read(into[i].data(), into[i].size());
    } catch (cms::Exception &) {
      if (!total)
        throw;
      break;
    }
  }
  position(here);
  return total;
}


int Storage::read() {
  unsigned char byte;
  IOSize n = read(&byte, 1);
  return n == 0 ? -1 : byte;
}

IOSize Storage::read(IOBuffer into) { return read(into.data(), into.size()); }

IOSize Storage::readv(IOBuffer *into, IOSize buffers) {
  assert(!buffers || into);

  // Keep reading as long as possible; ignore errors if we have read
  // something, otherwise pass it on.
  IOSize status;
  IOSize done = 0;
  try {
    for (IOSize i = 0; i < buffers; done += status, ++i)
      if ((status = read(into[i])) == 0)
        break;
  } catch (cms::Exception &) {
    if (!done)
      throw;
  }

  return done;
}


IOSize Storage::xread(IOBuffer into) { return xread(into.data(), into.size()); }

IOSize Storage::xread(void *into, IOSize n) {
  assert(into);

  // Keep reading as long as possible.  Let system errors fly over
  // us, they are a hard error.
  IOSize x;
  IOSize done = 0;
  while (done < n && (x = read((char *)into + done, n - done)))
    done += x;

  return done;
}

IOSize Storage::xreadv(IOBuffer *into, IOSize buffers) {
  // FIXME: Use read(into, buffers) and then sort out in case of
  // failure, the readv probably succeed directly with much less
  // overhead.

  assert(!buffers || into);

  // Keep reading as long as possible.  Let system errors fly
  // over us, they are a hard error.
  IOSize x;
  IOSize done = 0;
  for (IOSize i = 0; i < buffers; ++i) {
    done += (x = xread(into[i]));
    if (x < into[i].size())
      break;
  }
  return done;
}

IOSize Storage::write(IOBuffer from, IOOffset pos) { return write(from.data(), from.size(), pos); }

IOSize Storage::write(const void *from, IOSize n, IOOffset pos) {
  // FIXME: this is not thread safe!  split into separate interface
  // that a particular storage can choose to support or not?  make
  // sure that throw semantics are correct here!

  // FIXME: use saveposition object in case exceptions are thrown?
  IOOffset here = position();
  position(pos);
  n = write(from, n);
  position(here);
  return n;
}

IOSize Storage::writev(const IOPosBuffer *from, IOSize n) {
  IOSize total = 0;
  for (IOSize i = 0; i < n; ++i) {
    try {
      total += write(from[i].data(), from[i].size(), from[i].offset());
    } catch (cms::Exception &) {
      if (!total)
        throw;
      break;
    }
  }
  return total;
}


IOSize Storage::write(unsigned char byte) { return write(&byte, 1); }

IOSize Storage::write(IOBuffer from) { return write(from.data(), from.size()); }

IOSize Storage::writev(const IOBuffer *from, IOSize buffers) {
  assert(!buffers || from);

  // Keep writing as long as possible; ignore errors if we have
  // written something, otherwise pass it on.
  IOSize x;
  IOSize done = 0;
  try {
    for (IOSize i = 0; i < buffers; ++i) {
      done += (x = write(from[i].data(), from[i].size()));
      if (x < from[i].size())
        break;
    }
  } catch (cms::Exception &) {
    if (!done)
      throw;
  }

  return done;
}


IOSize Storage::xwrite(IOBuffer from) { return xwrite(from.data(), from.size()); }

IOSize Storage::xwrite(const void *from, IOSize n) {
  // Keep writing until we've written it all.  Let errors fly over.
  IOSize done = 0;
  while (done < n)
    done += write((const char *)from + done, n - done);

  return done;
}

IOSize Storage::xwritev(const IOBuffer *from, IOSize buffers) {
  // Keep writing until we've written it all.  Let errors fly over.
  // FIXME: Use writev(from, buffers) and then sort out in case of
  // failure, the writev probably succeed directly with much less
  // overhead.
  assert(!buffers || from);

  IOSize done = 0;
  for (IOSize i = 0; i < buffers; ++i)
    done += xwrite(from[i].data(), from[i].size());

  return done;
}

IOOffset Storage::position() const {
  Storage *self = const_cast<Storage *>(this);
  return self->position(0, CURRENT);
}

IOOffset Storage::size() const {
  // FIXME: use saveposition object in case exceptions are thrown?
  Storage *self = const_cast<Storage *>(this);
  IOOffset here = position();
  self->position(0, END);
  IOOffset size = position();
  self->position(here);  // FIXME: VERIFY()?
  return size;
}

void Storage::rewind() { position(0); }

bool Storage::prefetch(const IOPosBuffer * /* what */, IOSize /* n */) { return false; }

void Storage::flush() {}

void Storage::close() {}

bool Storage::eof() const { return position() == size(); }