#include <File.h>

Inheritance diagram for File:

Public Member Functions
virtual void	abort (void)

virtual void	attach (IOFD fd)

void	close (void) override

virtual void	create (const char *name, bool exclusive=false, int perms=0666)

virtual void	create (const std::string &name, bool exclusive=false, int perms=0666)

	File (void)

	File (IOFD fd, bool autoclose=true)

	File (const char *name, int flags=IOFlags::OpenRead, int perms=0666)

	File (const std::string &name, int flags=IOFlags::OpenRead, int perms=0666)

void	flush (void) override

virtual void	open (const char *name, int flags=IOFlags::OpenRead, int perms=0666)

virtual void	open (const std::string &name, int flags=IOFlags::OpenRead, int perms=0666)

IOOffset	position (IOOffset offset, Relative whence=SET) override

bool	prefetch (const IOPosBuffer *what, IOSize n) override

IOSize	read (void *into, IOSize n) override

IOSize	read (void *into, IOSize n, IOOffset pos) override

IOSize	readv (IOBuffer *into, IOSize length) override

void	resize (IOOffset size) override

virtual void	setAutoClose (bool closeit)

IOOffset	size (void) const override

IOSize	write (const void *from, IOSize n) override

IOSize	write (const void *from, IOSize n, IOOffset pos) override

IOSize	writev (const IOBuffer *from, IOSize length) override

	~File (void) override

Public Member Functions inherited from IOChannel
virtual IOFD	fd (void) const

virtual void	fd (IOFD value)

	IOChannel (IOFD fd=-1)

virtual bool	isBlocking (void) const

IOSize	read (void *into, IOSize n) override

IOSize	readv (IOBuffer *into, IOSize buffers) override

virtual void	setBlocking (bool value)

IOSize	write (const void *from, IOSize n) override

IOSize	writev (const IOBuffer *from, IOSize buffers) override

	~IOChannel (void) override

Public Member Functions inherited from IOInput
int	read (void)

IOSize	read (IOBuffer into)

IOSize	xread (IOBuffer into)

IOSize	xread (void *into, IOSize n)

IOSize	xreadv (IOBuffer *into, IOSize buffers)

virtual	~IOInput (void)
	Destruct the stream. A no-op. More...

Public Member Functions inherited from IOOutput
IOSize	write (unsigned char byte)

IOSize	write (IOBuffer from)

IOSize	xwrite (const void *from, IOSize n)

IOSize	xwrite (IOBuffer from)

IOSize	xwritev (const IOBuffer *from, IOSize buffers)

virtual	~IOOutput (void)
	Destruct the stream. A no-op. More...

Public Member Functions inherited from Storage
virtual bool	eof (void) const

virtual IOOffset	position (void) const

IOSize	read (IOBuffer into, IOOffset pos)

virtual IOSize	readv (IOPosBuffer *into, IOSize buffers)

virtual void	rewind (void)

	Storage (void)

IOSize	write (IOBuffer from, IOOffset pos)

virtual IOSize	writev (const IOPosBuffer *from, IOSize buffers)

	~Storage (void) override

Private Types
enum	{ InternalAutoClose = 4096 }

Private Member Functions
File *	duplicate (bool copy) const

File *	duplicate (File *child) const

	File (IOFD fd, unsigned flags)

Static Private Member Functions
static bool	sysclose (IOFD fd, int *error=nullptr)

static IOFD	sysduplicate (IOFD fd)

static void	sysopen (const char *name, int flags, int perms, IOFD &newfd, unsigned &newflags)

Private Attributes
unsigned	m_flags

Additional Inherited Members
Public Types inherited from Storage
enum	Relative { SET, CURRENT, END }

Protected Member Functions inherited from IOChannel
bool	sysclose (IOFD fd, int *error=nullptr)

Detailed Description

Basic file-related functions. Nicked from SEAL.

Definition at line 11 of file File.h.

Member Enumeration Documentation

anonymous enum

private

Enumerator
InternalAutoClose

Definition at line 54 of file File.h.

54 { InternalAutoClose = 4096 }; //< Close on delete

File::InternalAutoClose

Definition: File.h:54

Constructor & Destructor Documentation

File::File ( void )

Create a new file object without a file attached to it.

Definition at line 57 of file File.cc.

References EDM_IOFD_INVALID, and ztee::fd.

                {
   fd(EDM_IOFD_INVALID);
   m_flags = 0;
 }

File::File	(	IOFD	fd,
		bool	autoclose = `true`
	)

Create a new file object from a file descriptor. The descriptor will be closed automatically when the file object is destructed if autoclose is true (the default).

Definition at line 65 of file File.cc.

References ztee::fd.

                                     {
   this->fd(fd);
   m_flags = autoclose ? InternalAutoClose : 0;
 }

File::File	(	const char *	name,
		int	flags = `IOFlags::OpenRead`,
		int	perms = `0666`
	)

Create a new file object by calling open() with the given arguments.

Definition at line 77 of file File.cc.

77 { open(name, flags, perms); }

File::open

virtual void open(const char *name, int flags=IOFlags::OpenRead, int perms=0666)

Definition: File.cc:156

HLT_2018_cff.flags

flags

Definition: HLT_2018_cff.py:11743

Skims_PA_cff.name

name

Definition: Skims_PA_cff.py:17

File::File	(	const std::string &	name,
		int	flags = `IOFlags::OpenRead`,
		int	perms = `0666`
	)

Create a new file object by calling open() with the given arguments.

Definition at line 80 of file File.cc.

References HLT_2018_cff::flags.

                                                           {
   open(name.c_str(), flags, perms);
 }

File::~File ( void )

override

Release the resources held by the file object. If the object holds a valid file descriptor given to it through the constructor or obtained by calling open(), the descriptor will be closed.

Definition at line 87 of file File.cc.

                 {
   if (m_flags & InternalAutoClose)
     abort();
 }

File::File	(	IOFD	fd,
		unsigned	flags
	)

private

Internal function for copying file objects to retain the state flags.

Definition at line 71 of file File.cc.

References ztee::fd, and HLT_2018_cff::flags.

                                   {
   this->fd(fd);
   m_flags = flags;
 }

Member Function Documentation

void File::abort ( void )

virtual

Close the file and ignore all errors.

Reimplemented in RemoteFile.

Definition at line 254 of file File.cc.

References EDM_IOFD_INVALID, and ztee::fd.

Referenced by RemoteFile::abort().

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

void File::attach ( IOFD fd )

virtual

Definition at line 178 of file File.cc.

References ztee::fd.

                          {
   this->fd(fd);
   m_flags = 0;
 }

void File::close ( void )

overridevirtual

Close the file.

Reimplemented from IOChannel.

Reimplemented in RemoteFile.

Definition at line 241 of file File.cc.

References EDM_IOFD_INVALID, relativeConstraints::error, ztee::fd, and throwStorageError().

Referenced by RemoteFile::close(), esMonitoring.AsyncLineReaderMixin::handle_close(), esMonitoring.FDJsonServer::handle_close(), Vispa.Gui.BoxContentDialog.BoxContentDialog::keyPressEvent(), and Vispa.Gui.FindDialog.FindDialog::keyPressEvent().

                      {
   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::create	(	const char *	name,
		bool	exclusive = `false`,
		int	perms = `0666`
	)

virtual

Create and open the file name in write mode. If exclusive, the creation fails if the file already exists, otherwise if the file exists, it will be truncated. The new file will have the permissions perms.

Definition at line 131 of file File.cc.

References IOFlags::OpenCreate, IOFlags::OpenExclusive, IOFlags::OpenTruncate, and IOFlags::OpenWrite.

                                                                  {
   open(name, (OpenCreate | OpenWrite | OpenTruncate | (exclusive ? OpenExclusive : 0)), perms);
 }

void File::create	(	const std::string &	name,
		bool	exclusive = `false`,
		int	perms = `0666`
	)

virtual

Create and open the file name in write mode. If exclusive, the creation fails if the file already exists, otherwise if the file exists, it will be truncated. The new file will have the permissions perms.

Definition at line 139 of file File.cc.

References IOFlags::OpenCreate, IOFlags::OpenExclusive, IOFlags::OpenTruncate, and IOFlags::OpenWrite.

                                                                       {
   open(name.c_str(), (OpenCreate | OpenWrite | OpenTruncate | (exclusive ? OpenExclusive : 0)), perms);
 }

File * File::duplicate ( bool copy ) const

private

Duplicate the file object. If copy, also duplicates the underlying file descriptor, otherwise the two will point to the same descriptor. If the file descriptor is not copied, the copy will not close its file descriptor on destruction, the original object (this) will.

Definition at line 110 of file File.cc.

References trackingPlots::dup, ztee::fd, and VtxSmearedBeamProfile_cfi::File.

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

File * File::duplicate ( File * child ) const

private

Internal implementation of duplicate() to actually duplicate the file handle into child.

Definition at line 117 of file File.cc.

References class-composition::child, EDM_IOFD_INVALID, IOChannel::fd(), ztee::fd, and m_flags.

                                        {
   IOFD fd = this->fd();
   assert(fd != EDM_IOFD_INVALID);
   assert(child);
   child->fd(sysduplicate(fd));
   child->m_flags = m_flags;
   return child;
 }

void File::flush ( void )

overridevirtual

Flush the system's file system buffers for this file.

Reimplemented from Storage.

Definition at line 122 of file UnixFile.cc.

References EDM_IOFD_INVALID, ztee::fd, and throwStorageError().

                      {
   IOFD fd = this->fd();
   assert(fd != EDM_IOFD_INVALID);
 
 #if _POSIX_SYNCHRONIZED_IO > 0
   if (fdatasync(fd) == -1)
     throwStorageError("FileFlushError", "Calling File::flush()", "fdatasync()", errno);
 #elif _POSIX_FSYNC > 0
   if (fsync(fd) == -1)
     throwStorageError("FileFlushError", "Calling File::flush()", "fsync()", errno);
 #endif
 }

void File::open	(	const char *	name,
		int	flags = `IOFlags::OpenRead`,
		int	perms = `0666`
	)

virtual

Open or possibly create the file name with options specified in flags. If the file is to be created, it will be given the permissions perms. If this object already has a file open, it is closed first.

Definition at line 156 of file File.cc.

References EDM_IOFD_INVALID, ztee::fd, IOFlags::OpenRead, and IOFlags::OpenWrite.

                                                           {
   // 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::open	(	const std::string &	name,
		int	flags = `IOFlags::OpenRead`,
		int	perms = `0666`
	)

virtual

Open or possibly create the file name with options specified in flags. If the file is to be created, it will be given the permissions perms. If this object already has a file open, it is closed first. Redirected to the overloaded method taking a "const char *" argument.

Definition at line 148 of file File.cc.

References HLT_2018_cff::flags.

                                                                {
   open(name.c_str(), flags, perms);
 }

IOOffset File::position	(	IOOffset	offset,
		Relative	whence = `SET`
	)

overridevirtual

Return the current file pointer position.

Implements Storage.

Definition at line 101 of file UnixFile.cc.

References EDM_IOFD_INVALID, ztee::fd, mps_fire::result, L1DTConfigBti_cff::SET, and throwStorageError().

                                                           {
   IOFD fd = this->fd();
   assert(fd != EDM_IOFD_INVALID);
   assert(whence == CURRENT || whence == SET || whence == END);
 
   IOOffset result;
   int mywhence = (whence == SET ? SEEK_SET : whence == CURRENT ? SEEK_CUR : SEEK_END);
   if ((result = ::lseek(fd, offset, mywhence)) == -1)
     throwStorageError("FilePositionError", "Calling File::position()", "lseek()", errno);
 
   return result;
 }

bool File::prefetch	(	const IOPosBuffer *	what,
		IOSize	n
	)

overridevirtual

Prefetch data for the file.

Reimplemented from Storage.

Definition at line 185 of file File.cc.

References ztee::fd, mps_fire::i, info(), dqmiodumpmetadata::n, IOPosBuffer::offset(), hltrates_dqm_sourceclient-live_cfg::offset, IOPosBuffer::size(), and findQualityFiles::size.

                                                      {
   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
	)

overridevirtual

Read from the file.

Implements IOInput.

Definition at line 203 of file File.cc.

References IOInput::read().

203 { return IOChannel::read(into, n); }

dqmiodumpmetadata.n

n

Definition: dqmiodumpmetadata.py:28

IOInput::read

int read(void)

Definition: IOInput.cc:52

IOSize File::read	(	void *	into,
		IOSize	n,
		IOOffset	pos
	)

overridevirtual

Reimplemented from Storage.

Definition at line 58 of file UnixFile.cc.

References ztee::fd, edm::errors::FileReadError, alignCSCRings::s, and throwStorageError().

                                                     {
   assert(pos >= 0);
 
   ssize_t s;
   do
     s = ::pread(fd(), into, n, pos);
   while (s == -1 && errno == EINTR);
 
   if (s == -1)
     throwStorageError(edm::errors::FileReadError, "Calling File::read()", "pread()", errno);
 
   return s;
 }

IOSize File::readv	(	IOBuffer *	into,
		IOSize	length
	)

overridevirtual

Read from the file.

Reimplemented from IOInput.

Definition at line 206 of file File.cc.

References IOChannel::readv().

206 { return IOChannel::readv(into, length); }

IOChannel::readv

IOSize readv(IOBuffer *into, IOSize buffers) override

Definition: UnixIOChannel.cc:21

void File::resize ( IOOffset size )

overridevirtual

Resize to the file to size. If size is less than the file's current size, the file is truncated. If size is larger than the file's current size, the file is extended with zero bytes. Does not change the current file pointer.

Implements Storage.

Definition at line 114 of file UnixFile.cc.

References EDM_IOFD_INVALID, ztee::fd, and throwStorageError().

Referenced by Vispa.Gui.TextDialog.TextDialog::__init__(), Vispa.Plugins.ConfigEditor.ToolDialog.ToolDialog::__init__(), Vispa.Main.MainWindow.MainWindow::_loadIni(), and Vispa.Gui.PortConnection.PointToPointConnection::updateConnection().

                                {
   IOFD fd = this->fd();
   assert(fd != EDM_IOFD_INVALID);
 
   if (ftruncate(fd, size) == -1)
     throwStorageError("FileResizeError", "Calling File::resize()", "ftruncate()", errno);
 }

void File::setAutoClose ( bool autoclose )

virtual

Set the autoclose flag of the file. If autoclose is true, the destructor will automatically try to close the underlying file descriptor. Otherwise the file descriptor will be left open. Set the flag off if the file descriptor is originally owned by someone else.

Definition at line 98 of file File.cc.

                                       {
   m_flags &= ~InternalAutoClose;
   if (autoclose)
     m_flags |= InternalAutoClose;
 }

IOOffset File::size ( void ) const

overridevirtual

Get the size of the file.

Reimplemented from Storage.

Definition at line 90 of file UnixFile.cc.

References EDM_IOFD_INVALID, ztee::fd, and throwStorageError().

Referenced by ntupleDataFormat._Collection::__iter__(), and ntupleDataFormat._Collection::__len__().

                               {
   IOFD fd = this->fd();
   assert(fd != EDM_IOFD_INVALID);
 
   struct stat info;
   if (fstat(fd, &info) == -1)
     throwStorageError("FileSizeError", "Calling File::size()", "fstat()", errno);
 
   return info.st_size;
 }

bool File::sysclose	(	IOFD	fd,
		int *	error = `nullptr`
	)

staticprivate

Actually close a file handle and return error code.

Definition at line 135 of file UnixFile.cc.

References runTheMatrix::ret.

                                          {
   int ret = ::close(fd);
   if (error)
     *error = errno;
   return ret != -1;
 }

IOFD File::sysduplicate ( IOFD fd )

staticprivate

Definition at line 9 of file UnixFile.cc.

References trackingPlots::dup, EDM_IOFD_INVALID, and throwStorageError().

                                {
   IOFD copyfd;
   if ((copyfd = ::dup(fd)) == EDM_IOFD_INVALID)
     throwStorageError("FileDuplicateError", "Calling File::sysduplicate()", "dup()", errno);
 
   return copyfd;
 }

void File::sysopen	(	const char *	name,
		int	flags,
		int	perms,
		IOFD &	newfd,
		unsigned &	newflags
	)

staticprivate

Definition at line 17 of file UnixFile.cc.

References edm::errors::FileOpenError, O_NONBLOCK, IOFlags::OpenAppend, IOFlags::OpenCreate, IOFlags::OpenExclusive, IOFlags::OpenNonBlock, IOFlags::OpenNotCTTY, IOFlags::OpenRead, IOFlags::OpenTruncate, IOFlags::OpenUnbuffered, IOFlags::OpenWrite, and throwStorageError().

                                                                                         {
   // Translate our flags to system flags.
   int openflags = 0;
 
   if ((flags & OpenRead) && (flags & OpenWrite))
     openflags |= O_RDWR;
   else if (flags & OpenRead)
     openflags |= O_RDONLY;
   else if (flags & OpenWrite)
     openflags |= O_WRONLY;
 
   if (flags & OpenNonBlock)
     openflags |= O_NONBLOCK;
 
   if (flags & OpenAppend)
     openflags |= O_APPEND;
 
 #ifdef O_SYNC
   if (flags & OpenUnbuffered)
     openflags |= O_SYNC;
 #else
   if (flags & OpenUnbuffered)
     newflags |= OpenUnbuffered;
 #endif
 
   if (flags & OpenCreate)
     openflags |= O_CREAT;
 
   if (flags & OpenExclusive)
     openflags |= O_EXCL;
 
   if (flags & OpenTruncate)
     openflags |= O_TRUNC;
 
   if (flags & OpenNotCTTY)
     openflags |= O_NOCTTY;
 
   if ((newfd = ::open(name, openflags, perms)) == -1)
     throwStorageError(edm::errors::FileOpenError, "Calling File::sysopen()", "open()", errno);
 }

IOSize File::write	(	const void *	from,
		IOSize	n
	)

overridevirtual

Write to the file.

Implements IOOutput.

Definition at line 209 of file File.cc.

References IOFlags::OpenAppend, IOFlags::OpenUnbuffered, position, alignCSCRings::s, and IOChannel::write().

                                              {
   // 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::write	(	const void *	from,
		IOSize	n,
		IOOffset	pos
	)

overridevirtual

Reimplemented from Storage.

Definition at line 72 of file UnixFile.cc.

References ztee::fd, edm::errors::FileWriteError, IOFlags::OpenUnbuffered, alignCSCRings::s, and throwStorageError().

                                                            {
   assert(pos >= 0);
 
   ssize_t s;
   do
     s = ::pwrite(fd(), from, n, pos);
   while (s == -1 && errno == EINTR);
 
   if (s == -1)
     throwStorageError(edm::errors::FileWriteError, "Calling File::write()", "pwrite()", errno);
 
   if (m_flags & OpenUnbuffered)
     // FIXME: Exception handling?
     flush();
 
   return s;
 }

IOSize File::writev	(	const IOBuffer *	from,
		IOSize	length
	)

overridevirtual

Write to the file.

Reimplemented from IOOutput.

Definition at line 225 of file File.cc.

References IOFlags::OpenAppend, IOFlags::OpenUnbuffered, position, alignCSCRings::s, and IOChannel::writev().

                                                        {
   // 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;
 }

Member Data Documentation

unsigned File::m_flags

private

Definition at line 64 of file File.h.

Referenced by duplicate().

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation