/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_7/src/Utilities/StorageFactory/src/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);
  }
}