File.cc

Go to the documentation of this file.

#include "Utilities/StorageFactory/interface/File.h"
#include "Utilities/StorageFactory/src/SysFile.h"
#include "Utilities/StorageFactory/src/Throw.h"
#include <cassert>

using namespace IOFlags;

//<<<<<< PRIVATE DEFINES                                                >>>>>>
//<<<<<< PRIVATE CONSTANTS                                              >>>>>>
//<<<<<< PRIVATE TYPES                                                  >>>>>>
//<<<<<< PUBLIC VARIABLE DEFINITIONS                                    >>>>>>
//<<<<<< PRIVATE VARIABLE DEFINITIONS                                   >>>>>>
//<<<<<< CLASS STRUCTURE INITIALIZATION                                 >>>>>>
//<<<<<< PUBLIC FUNCTION DEFINITIONS                                    >>>>>>
//<<<<<< PRIVATE FUNCTION DEFINITIONS                                   >>>>>>
//<<<<<< MEMBER FUNCTION DEFINITIONS                                    >>>>>>


File::File(void) {
  fd(EDM_IOFD_INVALID);
  m_flags = 0;
}

File::File(IOFD fd, bool autoclose /* = true */) {
  this->fd(fd);
  m_flags = autoclose ? InternalAutoClose : 0;
}

File::File(IOFD fd, unsigned flags) {
  this->fd(fd);
  m_flags = flags;
}

File::File(const char *name, int flags /*= OpenRead*/, int perms /*= 0666*/) { open(name, flags, perms); }

File::File(const std::string &name, int flags /*= OpenRead*/, int perms /*= 0666*/) {
  open(name.c_str(), flags, perms);
}

File::~File(void) {
  if (m_flags & InternalAutoClose)
    abort();
}


void File::setAutoClose(bool autoclose) {
  m_flags &= ~InternalAutoClose;
  if (autoclose)
    m_flags |= InternalAutoClose;
}


File *File::duplicate(bool copy) const {
  File *dup = new File(fd(), copy ? m_flags : 0);
  return copy ? this->duplicate(dup) : dup;
}

File *File::duplicate(File *child) const {
  IOFD fd = this->fd();
  assert(fd != EDM_IOFD_INVALID);
  assert(child);
  child->fd(sysduplicate(fd));
  child->m_flags = m_flags;
  return child;
}


void File::create(const char *name, bool exclusive /*=false*/, int perms /*=0666*/) {
  open(name, (OpenCreate | OpenWrite | OpenTruncate | (exclusive ? OpenExclusive : 0)), perms);
}

void File::create(const std::string &name, bool exclusive /*=false*/, int perms /*=0666*/) {
  open(name.c_str(), (OpenCreate | OpenWrite | OpenTruncate | (exclusive ? OpenExclusive : 0)), perms);
}

void File::open(const std::string &name, int flags /*= OpenRead*/, int perms /*= 0666*/) {
  open(name.c_str(), flags, perms);
}

void File::open(const char *name, int flags /*= OpenRead*/, int perms /*= 0666*/) {
  // is zero and always implied.  OTOH, existence check should be
  // done with Filename::exists() -- see comments there about what
  // can happen on a WIN32 remote share even if the file doesn't
  // exist.  For now make sure that read or write was asked for.

  assert(name && *name);
  assert(flags & (OpenRead | OpenWrite));

  // If I am already open, close the old file first.
  if (fd() != EDM_IOFD_INVALID && (m_flags & InternalAutoClose))
    close();

  IOFD newfd = EDM_IOFD_INVALID;
  unsigned newflags = InternalAutoClose;

  sysopen(name, flags, perms, newfd, newflags);

  fd(newfd);
  m_flags = newflags;
}

void File::attach(IOFD fd) {
  this->fd(fd);
  m_flags = 0;
}


bool File::prefetch(const IOPosBuffer *what, IOSize n) {
  IOFD fd = this->fd();
  for (IOSize i = 0; i < n; ++i) {
#if F_RDADVISE
    radvisory info;
    info.ra_offset = what[i].offset();
    info.ra_count = what[i].size();
    fcntl(fd, F_RDADVISE, &info);
#elif _POSIX_ADVISORY_INFO > 0
    posix_fadvise(fd, what[i].offset(), what[i].size(), POSIX_FADV_WILLNEED);
#else
#error advisory read ahead not available on this platform
#endif
  }
  return true;
}

IOSize File::read(void *into, IOSize n) { return IOChannel::read(into, n); }

IOSize File::readv(IOBuffer *into, IOSize length) { return IOChannel::readv(into, length); }

IOSize File::write(const void *from, IOSize n) {
  // FIXME: This may create a race condition or cause trouble on
  // remote files.  Should be currently needed only on WIN32.
  if (m_flags & OpenAppend)
    position(0, END);

  IOSize s = IOChannel::write(from, n);

  if (m_flags & OpenUnbuffered)
    // FIXME: Exception handling?
    flush();

  return s;
}

IOSize File::writev(const IOBuffer *from, IOSize length) {
  // FIXME: This may create a race condition or cause trouble on
  // remote files.  Should be currently needed only on WIN32.
  if (m_flags & OpenAppend)
    position(0, END);

  IOSize s = IOChannel::writev(from, length);

  if (m_flags & OpenUnbuffered)
    // FIXME: Exception handling?
    flush();

  return s;
}

void File::close(void) {
  IOFD fd = this->fd();
  assert(fd != EDM_IOFD_INVALID);

  int error;
  if (!sysclose(fd, &error))
    throwStorageError("FileCloseError", "Calling File::close()", "sysclose", error);

  m_flags &= ~InternalAutoClose;
  this->fd(EDM_IOFD_INVALID);
}

void File::abort(void) {
  IOFD fd = this->fd();
  if (fd != EDM_IOFD_INVALID) {
    sysclose(fd);
    m_flags &= ~InternalAutoClose;
    this->fd(EDM_IOFD_INVALID);
  }
}