XrdCl::File Class Reference

A file. More...

#include <XrdClFile.hh>

Collaboration diagram for XrdCl::File:

Public Types
enum	VirtRedirect {   EnableVirtRedirect ,   DisableVirtRedirect }

Public Member Functions
	File (bool enablePlugIns=true)
	File (const std::string &url, bool enablePlugIns=true)
	File (VirtRedirect virtRedirect, bool enablePlugIns=true)
virtual	~File ()
	Destructor. More...
XRootDStatus	Clone (const CloneLocations &locs, ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Clone (const CloneLocations &locs, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Close (ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Close (time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	DelXAttr (const std::vector< std::string > &attrs, ResponseHandler *handler, time_t timeout=0)
XRootDStatus	DelXAttr (const std::vector< std::string > &attrs, std::vector< XAttrStatus > &result, time_t timeout=0)
XRootDStatus	Fcntl (const Buffer &arg, Buffer *&response, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Fcntl (const Buffer &arg, ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Fcntl (QueryCode::Code queryCode, const Buffer &arg, Buffer *&response, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Fcntl (QueryCode::Code queryCode, const Buffer &arg, ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
bool	GetProperty (const std::string &name, std::string &value) const
XRootDStatus	GetXAttr (const std::vector< std::string > &attrs, ResponseHandler *handler, time_t timeout=0)
XRootDStatus	GetXAttr (const std::vector< std::string > &attrs, std::vector< XAttr > &result, time_t timeout=0)
bool	IsOpen () const
	Check if the file is open. More...
bool	IsSecure () const
	Check if the file is using an encrypted connection. More...
XRootDStatus	ListXAttr (ResponseHandler *handler, time_t timeout=0)
XRootDStatus	ListXAttr (std::vector< XAttr > &result, time_t timeout=0)
XRootDStatus	Open (const std::string &url, OpenFlags::Flags flags, Access::Mode mode, ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Open (const std::string &url, OpenFlags::Flags flags, Access::Mode mode=Access::None, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	OpenUsingTemplate (const File &rfile, const std::string &url, OpenFlags::Flags flags, Access::Mode mode, ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	OpenUsingTemplate (const File &rfile, const std::string &url, OpenFlags::Flags flags, Access::Mode mode=Access::None, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	PgRead (uint64_t offset, uint32_t size, void *buffer, ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	PgRead (uint64_t offset, uint32_t size, void *buffer, std::vector< uint32_t > &cksums, uint32_t &bytesRead, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	PgWrite (uint64_t offset, uint32_t size, const void *buffer, std::vector< uint32_t > &cksums, ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	PgWrite (uint64_t offset, uint32_t size, const void *buffer, std::vector< uint32_t > &cksums, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	PreRead (const TractList &tracts, ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	PreRead (const TractList &tracts, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Read (uint64_t offset, uint32_t size, void *buffer, ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Read (uint64_t offset, uint32_t size, void *buffer, uint32_t &bytesRead, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	ReadV (uint64_t offset, struct iovec *iov, int iovcnt, ResponseHandler *handler, time_t timeout=0)
XRootDStatus	ReadV (uint64_t offset, struct iovec *iov, int iovcnt, uint32_t &bytesRead, time_t timeout=0)
bool	SetProperty (const std::string &name, const std::string &value)
XRootDStatus	SetXAttr (const std::vector< xattr_t > &attrs, ResponseHandler *handler, time_t timeout=0)
XRootDStatus	SetXAttr (const std::vector< xattr_t > &attrs, std::vector< XAttrStatus > &result, time_t timeout=0)
XRootDStatus	Stat (bool force, ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Stat (bool force, StatInfo *&response, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Sync (ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Sync (time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Truncate (uint64_t size, ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Truncate (uint64_t size, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	TryOtherServer (time_t timeout=0)
XRootDStatus	VectorRead (const ChunkList &chunks, void *buffer, ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	VectorRead (const ChunkList &chunks, void *buffer, VectorReadInfo *&vReadInfo, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	VectorWrite (const ChunkList &chunks, ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	VectorWrite (const ChunkList &chunks, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Visa (Buffer *&visa, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Visa (ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
	Get access token to a file - async. More...
XRootDStatus	Write (uint64_t offset, Buffer &&buffer, ResponseHandler *handler, time_t timeout=0)
XRootDStatus	Write (uint64_t offset, Buffer &&buffer, time_t timeout=0)
XRootDStatus	Write (uint64_t offset, uint32_t size, const void *buffer, ResponseHandler *handler, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Write (uint64_t offset, uint32_t size, const void *buffer, time_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus	Write (uint64_t offset, uint32_t size, Optional< uint64_t > fdoff, int fd, ResponseHandler *handler, time_t timeout=0)
XRootDStatus	Write (uint64_t offset, uint32_t size, Optional< uint64_t > fdoff, int fd, time_t timeout=0)
XRootDStatus	WriteV (uint64_t offset, const struct iovec *iov, int iovcnt, ResponseHandler *handler, time_t timeout=0)
XRootDStatus	WriteV (uint64_t offset, const struct iovec *iov, int iovcnt, time_t timeout=0)

Friends
template<bool HasHndl>
class	CheckpointImpl
template<bool HasHndl>
class	ChkptWrtImpl
template<bool HasHndl>
class	ChkptWrtVImpl
struct	CloneLocations

Detailed Description

A file.

Definition at line 51 of file XrdClFile.hh.

Member Enumeration Documentation

VirtRedirect

enum XrdCl::File::VirtRedirect

Enumerator
EnableVirtRedirect
DisableVirtRedirect

Definition at line 56 of file XrdClFile.hh.

      {
        EnableVirtRedirect,
        DisableVirtRedirect
      };

Constructor & Destructor Documentation

File() [1/3]

XrdCl::File::File

(

bool

enablePlugIns = true

)

Constructor

Parameters

enablePlugIns

enable the plug-in mechanism for the object

Definition at line 59 of file XrdClFile.cc.

                                :
    pPlugIn(0),
    pEnablePlugIns( enablePlugIns )
  {
    pImpl = new FileImpl( pPlugIn );
  }

File() [2/3]

XrdCl::File::File	(	VirtRedirect	virtRedirect,
		bool	enablePlugIns = true
	)

Constructor

Parameters

virtRedirect
enablePlugIns

Definition at line 69 of file XrdClFile.cc.

                                                           :
    pPlugIn(0),
    pEnablePlugIns( enablePlugIns )
  {
    pImpl = new FileImpl( virtRedirect == EnableVirtRedirect, pPlugIn );
  }

References EnableVirtRedirect.

File() [3/3]

XrdCl::File::File	(	const std::string &	url,
		bool	enablePlugIns = true
	)

Constructor

Parameters

url	URL for the file to initialise the plugin for
enablePlugIns	enable the plug-in mechanism for the object

Definition at line 79 of file XrdClFile.cc.

                                                    : pPlugIn(0), pEnablePlugIns(enablePlugIns)
  {
    InitPlugin(url);
    pImpl = new FileImpl(pPlugIn);
  }

~File()

XrdCl::File::~File ( )

virtual

Destructor.

Definition at line 88 of file XrdClFile.cc.

  {
    //--------------------------------------------------------------------------
    // This, in principle, should never ever happen. Except for the case
    // when we're interfaced with ROOT that may call this desctructor from
    // its garbage collector, from its __cxa_finalize, ie. after the XrdCl lib
    // has been finalized by the linker. So, if we don't have the log object
    // at this point we just give up the hope.
    // Also, make sure the PostMaster threads are running - if not the Close
    // will hang forever (this could happen when Python interpreter exits).
    //--------------------------------------------------------------------------
    if ( DefaultEnv::GetLog() && DefaultEnv::GetPostMaster()->IsRunning() && IsOpen() )
      XRootDStatus status = Close( nullptr, 0 );
    delete pImpl;
    delete pPlugIn;
  }

References Close(), XrdCl::DefaultEnv::GetLog(), XrdCl::DefaultEnv::GetPostMaster(), and IsOpen().

Here is the call graph for this function:

Member Function Documentation

Clone() [1/2]

XRootDStatus XrdCl::File::Clone	(	const CloneLocations &	locs,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Clone files and ranges specified into the current file - async

Parameters

locs	files, source ranges and dest offsets to be cloned
handler	handler to be notified about the status of the operation
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 1016 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->Clone( locs, handler, timeout );
 
    return pImpl->pStateHandler->Clone( pImpl->pStateHandler, locs, handler, timeout );
  }

References XrdCl::FilePlugIn::Clone(), and XrdCl::FileImpl::pStateHandler.

Referenced by Clone().

Here is the call graph for this function:

Here is the caller graph for this function:

Clone() [2/2]

XRootDStatus XrdCl::File::Clone	(	const CloneLocations &	locs,
		time_t	timeout = 0
	)

Clone files and ranges specified into the current file - sync

Parameters

locs	files, source ranges and dest offsets to be cloned
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 1027 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = Clone( locs, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    return MessageUtils::WaitForStatus( &handler );
  }

References Clone(), XrdCl::Status::IsOK(), and XrdCl::MessageUtils::WaitForStatus().

Here is the call graph for this function:

Close() [1/2]

XRootDStatus XrdCl::File::Close	(	ResponseHandler *	handler,
		time_t	timeout = 0
	)

Close the file - async

Parameters

handler	handler to be notified about the status of the operation
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 210 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->Close( handler, timeout );
 
    return FileStateHandler::Close( pImpl->pStateHandler, handler, timeout );
  }

References XrdCl::FilePlugIn::Close(), XrdCl::FileStateHandler::Close(), and XrdCl::FileImpl::pStateHandler.

Referenced by ~File(), XrdPosixFile::~XrdPosixFile(), XrdCl::Recorder::Close(), Close(), XrdPosixFile::Close(), and DoTail().

Here is the call graph for this function:

Here is the caller graph for this function:

Close() [2/2]

XRootDStatus XrdCl::File::Close

(

time_t

timeout = 0

)

Close the file - sync

Parameters

timeout

timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 223 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = Close( &handler, timeout );
    if( !st.IsOK() || st.code == suAlreadyDone )
      return st;
 
    return MessageUtils::WaitForStatus( &handler );
  }

References Close(), XrdCl::Status::code, XrdCl::Status::IsOK(), XrdCl::suAlreadyDone, and XrdCl::MessageUtils::WaitForStatus().

Here is the call graph for this function:

DelXAttr() [1/2]

XRootDStatus XrdCl::File::DelXAttr	(	const std::vector< std::string > &	attrs,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Delete extended attributes - async

Parameters

attrs	: list of extended attributes to set
handler	: handler to be notified when the response arrives, the response parameter will hold a std::vector of XAttrStatus objects
timeout	: timeout value, if 0 the environment default will be used

Returns

: status of the operation

Definition at line 847 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return XRootDStatus( stError, errNotSupported );
 
    return FileStateHandler::DelXAttr( pImpl->pStateHandler, attrs, handler, timeout );
  }

References XrdCl::FileStateHandler::DelXAttr(), XrdCl::errNotSupported, XrdCl::FileImpl::pStateHandler, and XrdCl::stError.

Referenced by DelXAttr().

Here is the call graph for this function:

Here is the caller graph for this function:

DelXAttr() [2/2]

XRootDStatus XrdCl::File::DelXAttr	(	const std::vector< std::string > &	attrs,
		std::vector< XAttrStatus > &	result,
		time_t	timeout = 0
	)

Delete extended attributes - sync

Parameters

attrs	: list of extended attributes to set
result	: result of the operation
timeout	: timeout value, if 0 the environment default will be used

Returns

: status of the operation

Definition at line 860 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = DelXAttr( attrs, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    std::vector<XAttrStatus> *resp = 0;
    st = MessageUtils::WaitForResponse( &handler, resp );
    if( resp ) result.swap( *resp );
    delete resp;
 
    return st;
  }

References DelXAttr(), XrdCl::Status::IsOK(), and XrdCl::MessageUtils::WaitForResponse().

Here is the call graph for this function:

Fcntl() [1/4]

XRootDStatus XrdCl::File::Fcntl	(	const Buffer &	arg,
		Buffer *&	response,
		time_t	timeout = 0
	)

Performs a custom operation on an open file, server implementation dependent - sync

Parameters

arg	query argument
response	the response (to be deleted by the user)
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 740 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = Fcntl( arg, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    return MessageUtils::WaitForResponse( &handler, response );
  }

References Fcntl(), XrdCl::Status::IsOK(), and XrdCl::MessageUtils::WaitForResponse().

Here is the call graph for this function:

Fcntl() [2/4]

XRootDStatus XrdCl::File::Fcntl	(	const Buffer &	arg,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Performs a custom operation on an open file, server implementation dependent - async

Parameters

arg	query argument
handler	handler to be notified when the response arrives, the response parameter will hold a Buffer object if the procedure is successful
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 694 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->Fcntl( arg, handler, timeout );
 
    return FileStateHandler::Fcntl( pImpl->pStateHandler, QueryCode::Code::OpaqueQ, arg, handler, timeout );
  }

References XrdCl::FilePlugIn::Fcntl(), XrdCl::FileStateHandler::Fcntl(), and XrdCl::FileImpl::pStateHandler.

Referenced by XrdCl::Recorder::Fcntl(), Fcntl(), and XrdPosixFile::Fcntl().

Here is the call graph for this function:

Here is the caller graph for this function:

Fcntl() [3/4]

XRootDStatus XrdCl::File::Fcntl	(	QueryCode::Code	queryCode,
		const Buffer &	arg,
		Buffer *&	response,
		time_t	timeout = 0
	)

Performs a custom operation on an open file, server implementation dependent - sync

Parameters

queryCode	query code
arg	query argument
response	the response (to be deleted by the user)
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 708 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = Fcntl(queryCode, arg, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    return MessageUtils::WaitForResponse( &handler, response );
  }

References Fcntl(), XrdCl::Status::IsOK(), and XrdCl::MessageUtils::WaitForResponse().

Here is the call graph for this function:

Fcntl() [4/4]

XRootDStatus XrdCl::File::Fcntl	(	QueryCode::Code	queryCode,
		const Buffer &	arg,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Performs a custom operation on an open file, server implementation dependent - async

Parameters

queryCode	query code
arg	query argument
handler	handler to be notified when the response arrives, the response parameter will hold a Buffer object if the procedure is successful
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 725 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->Fcntl( queryCode, arg, handler, timeout );
 
    return FileStateHandler::Fcntl(pImpl->pStateHandler, queryCode, arg, handler, timeout );
  }

References XrdCl::FilePlugIn::Fcntl(), XrdCl::FileStateHandler::Fcntl(), and XrdCl::FileImpl::pStateHandler.

Here is the call graph for this function:

GetProperty()

bool XrdCl::File::GetProperty	(	const std::string &	name,
		std::string &	value
	)		const

Get file property

See also

File::SetProperty for property list

Read-only properties: DataServer [string] - the data server the file is accessed at LastURL [string] - final file URL with all the cgi information

Definition at line 994 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->GetProperty( name, value );
 
    return pImpl->pStateHandler->GetProperty( name, value );
  }

References XrdCl::FilePlugIn::GetProperty(), and XrdCl::FileImpl::pStateHandler.

Referenced by XrdPosixXrootd::endPoint(), XrdCl::Recorder::GetProperty(), XrdCl::ZipArchive::List(), and XrdPosixFile::Location().

Here is the call graph for this function:

Here is the caller graph for this function:

GetXAttr() [1/2]

XRootDStatus XrdCl::File::GetXAttr	(	const std::vector< std::string > &	attrs,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Get extended attributes - async

Parameters

attrs	: list of extended attributes to get
handler	: handler to be notified when the response arrives, the response parameter will hold a std::vector of XAttr objects
timeout	: timeout value, if 0 the environment default will be used

Returns

: status of the operation

Definition at line 814 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return XRootDStatus( stError, errNotSupported );
 
    return FileStateHandler::GetXAttr( pImpl->pStateHandler, attrs, handler, timeout );
  }

References XrdCl::errNotSupported, XrdCl::FileStateHandler::GetXAttr(), XrdCl::FileImpl::pStateHandler, and XrdCl::stError.

Referenced by GetXAttr().

Here is the call graph for this function:

Here is the caller graph for this function:

GetXAttr() [2/2]

XRootDStatus XrdCl::File::GetXAttr	(	const std::vector< std::string > &	attrs,
		std::vector< XAttr > &	result,
		time_t	timeout = 0
	)

Get extended attributes - sync

Parameters

attrs	: list of extended attributes to get
result	: result of the operation
timeout	: timeout value, if 0 the environment default will be used

Returns

: status of the operation

Definition at line 827 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = GetXAttr( attrs, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    std::vector<XAttr> *resp = 0;
    st = MessageUtils::WaitForResponse( &handler, resp );
    if( resp ) result.swap( *resp );
    delete resp;
 
    return st;
  }

References GetXAttr(), XrdCl::Status::IsOK(), and XrdCl::MessageUtils::WaitForResponse().

Here is the call graph for this function:

IsOpen()

bool XrdCl::File::IsOpen

(

)

const

Check if the file is open.

Definition at line 962 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->IsOpen();
 
    return pImpl->pStateHandler->IsOpen();
  }

References XrdCl::FilePlugIn::IsOpen(), and XrdCl::FileImpl::pStateHandler.

Referenced by ~File(), XrdPosixFile::~XrdPosixFile(), XrdPosixFile::Close(), XrdPosixFile::DelayedDestroy(), XrdPosixXrootd::endPoint(), XrdCl::Recorder::IsOpen(), XrdPosixFile::Location(), and XrdCl::ZipArchive::OpenFile().

Here is the call graph for this function:

Here is the caller graph for this function:

IsSecure()

bool XrdCl::File::IsSecure

(

)

const

Check if the file is using an encrypted connection.

Definition at line 973 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return false;
    return pImpl->pStateHandler->IsSecure();
  }

References XrdCl::FileImpl::pStateHandler.

ListXAttr() [1/2]

XRootDStatus XrdCl::File::ListXAttr	(	ResponseHandler *	handler,
		time_t	timeout = 0
	)

List extended attributes - async

Parameters

handler	: handler to be notified when the response arrives, the response parameter will hold a std::vector of XAttr objects
timeout	: timeout value, if 0 the environment default will be used

Returns

: status of the operation

Definition at line 880 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return XRootDStatus( stError, errNotSupported );
 
    return FileStateHandler::ListXAttr( pImpl->pStateHandler, handler, timeout );
  }

References XrdCl::errNotSupported, XrdCl::FileStateHandler::ListXAttr(), XrdCl::FileImpl::pStateHandler, and XrdCl::stError.

Referenced by ListXAttr().

Here is the call graph for this function:

Here is the caller graph for this function:

ListXAttr() [2/2]

XRootDStatus XrdCl::File::ListXAttr	(	std::vector< XAttr > &	result,
		time_t	timeout = 0
	)

List extended attributes - sync

Parameters

result	: result of the operation
timeout	: timeout value, if 0 the environment default will be used

Returns

: status of the operation

Definition at line 892 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = ListXAttr( &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    std::vector<XAttr> *resp = 0;
    st = MessageUtils::WaitForResponse( &handler, resp );
    if( resp ) result.swap( *resp );
    delete resp;
 
    return st;
  }

References XrdCl::Status::IsOK(), ListXAttr(), and XrdCl::MessageUtils::WaitForResponse().

Here is the call graph for this function:

Open() [1/2]

XRootDStatus XrdCl::File::Open	(	const std::string &	url,
		OpenFlags::Flags	flags,
		Access::Mode	mode,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Open the file pointed to by the given URL - async

Parameters

url	url of the file to be opened
flags	OpenFlags::Flags
mode	Access::Mode for new files, 0 otherwise
handler	handler to be notified about the status of the operation
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 125 of file XrdClFile.cc.

  {
    // Check if we need to install and run a plug-in for this URL
    InitPlugin(url);
 
    if( (flags & OpenFlags::Dup) || (flags & OpenFlags::Samefs) )
      return XRootDStatus( stError, errInvalidArgs, 0,
             "Dup or Samefs options require a file template to be specified" );
 
    //--------------------------------------------------------------------------
    // Open the file
    //--------------------------------------------------------------------------
    if( pPlugIn )
      return pPlugIn->Open( url, flags, mode, handler, timeout );
 
    return FileStateHandler::Open( pImpl->pStateHandler, url, flags, mode, handler, timeout );
  }

References XrdCl::OpenFlags::Dup, XrdCl::errInvalidArgs, XrdCl::FilePlugIn::Open(), XrdCl::FileStateHandler::Open(), XrdCl::FileImpl::pStateHandler, XrdCl::OpenFlags::Samefs, and XrdCl::stError.

Referenced by DoTail(), XrdCl::MetalinkRedirector::Load(), XrdClS3::Filesystem::MkDir(), XrdCl::Recorder::Open(), xrdcl_proxy::ProxyPrefixFile::Open(), and Open().

Here is the call graph for this function:

Here is the caller graph for this function:

Open() [2/2]

XRootDStatus XrdCl::File::Open	(	const std::string &	url,
		OpenFlags::Flags	flags,
		Access::Mode	mode = Access::None,
		time_t	timeout = 0
	)

Open the file pointed to by the given URL - sync

Parameters

url	url of the file to be opened
flags	OpenFlags::Flags
mode	Access::Mode for new files, 0 otherwise
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 176 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = Open( url, flags, mode, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    return MessageUtils::WaitForStatus( &handler );
  }

References XrdCl::Status::IsOK(), Open(), and XrdCl::MessageUtils::WaitForStatus().

Here is the call graph for this function:

OpenUsingTemplate() [1/2]

XRootDStatus XrdCl::File::OpenUsingTemplate	(	const File &	rfile,
		const std::string &	url,
		OpenFlags::Flags	flags,
		Access::Mode	mode,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Open the file pointed to by the given URL - async Alows one to specify template file. Required if using Dup or Samefs flags.

Parameters

rfile	File object of the reference file
url	url of the file to be opened
flags	OpenFlags::Flags
mode	Access::Mode for new files, 0 otherwise
handler	handler to be notified about the status of the operation
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 151 of file XrdClFile.cc.

  {
    // Check if we need to install and run a plug-in for this URL
    InitPlugin(url);
 
    //--------------------------------------------------------------------------
    // Open the file
    //--------------------------------------------------------------------------
    if( pPlugIn )
      return pPlugIn->OpenUsingTemplate( rfile.GetFileTemplate().get(), url,
                            flags, mode, handler, timeout );
 
    return FileStateHandler::OpenUsingTemplate( pImpl->pStateHandler,
                                   rfile.GetFileTemplate().get(), url, flags,
                                   mode, handler, timeout );
  }

References XrdCl::FilePlugIn::OpenUsingTemplate(), XrdCl::FileStateHandler::OpenUsingTemplate(), and XrdCl::FileImpl::pStateHandler.

Referenced by OpenUsingTemplate().

Here is the call graph for this function:

Here is the caller graph for this function:

OpenUsingTemplate() [2/2]

XRootDStatus XrdCl::File::OpenUsingTemplate	(	const File &	rfile,
		const std::string &	url,
		OpenFlags::Flags	flags,
		Access::Mode	mode = Access::None,
		time_t	timeout = 0
	)

Open the file pointed to by the given URL - sync Alows one to specify template file. Required if using Dup or Samefs flags.

Parameters

rfile	File object of the reference file
url	url of the file to be opened
flags	OpenFlags::Flags
mode	Access::Mode for new files, 0 otherwise
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 193 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = OpenUsingTemplate( rfile, url, flags, mode, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    return MessageUtils::WaitForStatus( &handler );
  }

References XrdCl::Status::IsOK(), OpenUsingTemplate(), and XrdCl::MessageUtils::WaitForStatus().

Here is the call graph for this function:

PgRead() [1/2]

XRootDStatus XrdCl::File::PgRead	(	uint64_t	offset,
		uint32_t	size,
		void *	buffer,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Read number of pages at a given offset - async

Parameters

offset	offset from the beginning of the file
size	buffer size, at least 1 page big (4KB)
buffer	a pointer to a buffer big enough to hold the data
handler	handler to be notified when the response arrives, the response parameter will hold a PageInfo object if the procedure was successful
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 304 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->PgRead( offset, size, buffer, handler, timeout );
 
    return FileStateHandler::PgRead( pImpl->pStateHandler, offset, size, buffer, handler, timeout );
  }

References XrdCl::FileStateHandler::PgRead(), XrdCl::FilePlugIn::PgRead(), and XrdCl::FileImpl::pStateHandler.

Referenced by XrdCl::Recorder::PgRead(), PgRead(), XrdPosixFile::pgRead(), and XrdPosixFile::Read().

Here is the call graph for this function:

Here is the caller graph for this function:

PgRead() [2/2]

XRootDStatus XrdCl::File::PgRead	(	uint64_t	offset,
		uint32_t	size,
		void *	buffer,
		std::vector< uint32_t > &	cksums,
		uint32_t &	bytesRead,
		time_t	timeout = 0
	)

Read a data chunk at a given offset - sync

Parameters

offset	offset from the beginning of the file
size	buffer size, at least 1 page big (4KB)
buffer	a pointer to a buffer big enough to hold the data
cksums	crc32c checksum for each read 4KB page
bytesRead	number of bytes actually read
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 319 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = PgRead( offset, size, buffer, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    PageInfo *pageInfo = 0;
    XRootDStatus status = MessageUtils::WaitForResponse( &handler, pageInfo );
    if( status.IsOK() )
    {
      bytesRead = pageInfo->GetLength();
      cksums = pageInfo->GetCksums();
      delete pageInfo;
    }
    return status;
  }

References XrdCl::PageInfo::GetCksums(), XrdCl::PageInfo::GetLength(), XrdCl::Status::IsOK(), PgRead(), and XrdCl::MessageUtils::WaitForResponse().

Here is the call graph for this function:

PgWrite() [1/2]

XRootDStatus XrdCl::File::PgWrite	(	uint64_t	offset,
		uint32_t	size,
		const void *	buffer,
		std::vector< uint32_t > &	cksums,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Write number of pages at a given offset - async

Parameters

offset	offset from the beginning of the file
size	buffer size
buffer	a pointer to a buffer holding data pages
cksums	the crc32c checksums for each 4KB page
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 439 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->PgWrite( offset, size, buffer, cksums, handler, timeout );
 
    return FileStateHandler::PgWrite( pImpl->pStateHandler, offset, size, buffer, cksums, handler, timeout );
  }

References XrdCl::FileStateHandler::PgWrite(), XrdCl::FilePlugIn::PgWrite(), and XrdCl::FileImpl::pStateHandler.

Referenced by XrdPosixFile::pgWrite(), XrdCl::Recorder::PgWrite(), and PgWrite().

Here is the call graph for this function:

Here is the caller graph for this function:

PgWrite() [2/2]

XRootDStatus XrdCl::File::PgWrite	(	uint64_t	offset,
		uint32_t	size,
		const void *	buffer,
		std::vector< uint32_t > &	cksums,
		time_t	timeout = 0
	)

Write number of pages at a given offset - sync

Parameters

offset	offset from the beginning of the file
size	buffer size
buffer	a pointer to a buffer holding data pages
cksums	the crc32c checksums for each 4KB page
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 455 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = PgWrite( offset, size, buffer, cksums, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    XRootDStatus status = MessageUtils::WaitForStatus( &handler );
    return status;
  }

References XrdCl::Status::IsOK(), PgWrite(), and XrdCl::MessageUtils::WaitForStatus().

Here is the call graph for this function:

PreRead() [1/2]

XRootDStatus XrdCl::File::PreRead	(	const TractList &	tracts,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Preread scattered data tracts in one operation - async

Parameters

tracts	list of the tracts to preread, no data is returned. The file object must describe an open file. The default maximum tract size is 2097136 bytes and the default maximum number of tracts per request is \024. The server may be queried using FileSystem::Query for the actual settings.
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Definition at line 527 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->PreRead( tracts, handler, timeout );
 
//** return FileStateHandler::PreRead( pImpl->pStateHandler, tracts, handler, timeout );
    return XRootDStatus();
  }

References XrdCl::FilePlugIn::PreRead().

Referenced by PreRead().

Here is the call graph for this function:

Here is the caller graph for this function:

PreRead() [2/2]

XRootDStatus XrdCl::File::PreRead	(	const TractList &	tracts,
		time_t	timeout = 0
	)

Preread scattered data tracts in one operation - sync

Parameters

tracts	list of the tracts to preread, no data is returned. The file object must describe an open file. The default maximum tract size is 2097136 bytes and the default maximum number of tracts per request is 1024. The server may be queried using FileSystem::Query for the actual settings.
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Definition at line 541 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    return PreRead( tracts, &handler, timeout );
  }

References PreRead().

Here is the call graph for this function:

Read() [1/2]

XRootDStatus XrdCl::File::Read	(	uint64_t	offset,
		uint32_t	size,
		void *	buffer,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Read a data chunk at a given offset - async

Parameters

offset	offset from the beginning of the file
size	number of bytes to be read
buffer	a pointer to a buffer big enough to hold the data or 0 if the buffer should be allocated by the system
handler	handler to be notified when the response arrives, the response parameter will hold a ChunkInfo object if the procedure was successful
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 265 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->Read( offset, size, buffer, handler, timeout );
 
    return FileStateHandler::Read( pImpl->pStateHandler, offset, size, buffer, handler, timeout );
  }

References XrdCl::FileImpl::pStateHandler, XrdCl::FileStateHandler::Read(), and XrdCl::FilePlugIn::Read().

Referenced by DoTail(), XrdCl::MetalinkReadHandler::HandleResponse(), XrdCl::MetalinkOpenHandler::HandleResponseWithHosts(), XrdPosixFile::Read(), XrdCl::Recorder::Read(), and Read().

Here is the call graph for this function:

Here is the caller graph for this function:

Read() [2/2]

XRootDStatus XrdCl::File::Read	(	uint64_t	offset,
		uint32_t	size,
		void *	buffer,
		uint32_t &	bytesRead,
		time_t	timeout = 0
	)

Read a data chunk at a given offset - sync

Parameters

offset	offset from the beginning of the file
size	number of bytes to be read
buffer	a pointer to a buffer big enough to hold the data
bytesRead	number of bytes actually read
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 280 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = Read( offset, size, buffer, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    ChunkInfo *chunkInfo = 0;
    XRootDStatus status = MessageUtils::WaitForResponse( &handler, chunkInfo );
    if( status.IsOK() )
    {
      bytesRead = chunkInfo->length;
      delete chunkInfo;
    }
    return status;
  }

References XrdCl::Status::IsOK(), XrdCl::ChunkInfo::length, Read(), and XrdCl::MessageUtils::WaitForResponse().

Here is the call graph for this function:

ReadV() [1/2]

XRootDStatus XrdCl::File::ReadV	(	uint64_t	offset,
		struct iovec *	iov,
		int	iovcnt,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Read data into scattered buffers in one operation - async

Parameters

offset	offset from the beginning of the file
iov	list of the buffers to be written
iovcnt	number of buffers
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Definition at line 649 of file XrdClFile.cc.

  {
    return FileStateHandler::ReadV( pImpl->pStateHandler, offset, iov, iovcnt, handler, timeout );
  }

References XrdCl::FileImpl::pStateHandler, and XrdCl::FileStateHandler::ReadV().

Referenced by ReadV().

Here is the call graph for this function:

Here is the caller graph for this function:

ReadV() [2/2]

XRootDStatus XrdCl::File::ReadV	(	uint64_t	offset,
		struct iovec *	iov,
		int	iovcnt,
		uint32_t &	bytesRead,
		time_t	timeout = 0
	)

Read data into scattered buffers in one operation - sync

Parameters

offset	offset from the beginning of the file
iov	list of the buffers to be written
iovcnt	number of buffers
bytesRead	number of bytes actually read
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Read data into scattered buffers in one operation - sync

Parameters

offset	offset from the beginning of the file
iov	list of the buffers to be written
iovcnt	number of buffers
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Definition at line 669 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = ReadV( offset, iov, iovcnt, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    VectorReadInfo *vrInfo = 0;
    XRootDStatus status = MessageUtils::WaitForResponse( &handler, vrInfo );
    if( status.IsOK() )
    {
      bytesRead = vrInfo->GetSize();
      delete vrInfo;
    }
    return status;
  }

References XrdCl::VectorReadInfo::GetSize(), XrdCl::Status::IsOK(), ReadV(), and XrdCl::MessageUtils::WaitForResponse().

Here is the call graph for this function:

SetProperty()

bool XrdCl::File::SetProperty	(	const std::string &	name,
		const std::string &	value
	)

Set file property

File properties: ReadRecovery [true/false] - enable/disable read recovery WriteRecovery [true/false] - enable/disable write recovery FollowRedirects [true/false] - enable/disable following redirections BundledClose [true/false] - enable/disable bundled close

Definition at line 983 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->SetProperty( name, value );
 
    return pImpl->pStateHandler->SetProperty( name, value );
  }

References XrdCl::FileImpl::pStateHandler, and XrdCl::FilePlugIn::SetProperty().

Referenced by XrdClS3::Filesystem::MkDir(), and XrdCl::Recorder::SetProperty().

Here is the call graph for this function:

Here is the caller graph for this function:

SetXAttr() [1/2]

XRootDStatus XrdCl::File::SetXAttr	(	const std::vector< xattr_t > &	attrs,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Set extended attributes - async

Parameters

attrs	: list of extended attributes to set
handler	: handler to be notified when the response arrives, the response parameter will hold a std::vector of XAttrStatus objects
timeout	: timeout value, if 0 the environment default will be used

Returns

: status of the operation

Definition at line 781 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return XRootDStatus( stError, errNotSupported );
 
    return FileStateHandler::SetXAttr( pImpl->pStateHandler, attrs, handler, timeout );
  }

References XrdCl::errNotSupported, XrdCl::FileImpl::pStateHandler, XrdCl::FileStateHandler::SetXAttr(), and XrdCl::stError.

Referenced by SetXAttr().

Here is the call graph for this function:

Here is the caller graph for this function:

SetXAttr() [2/2]

XRootDStatus XrdCl::File::SetXAttr	(	const std::vector< xattr_t > &	attrs,
		std::vector< XAttrStatus > &	result,
		time_t	timeout = 0
	)

Set extended attributes - sync

Parameters

attrs	: list of extended attributes to set
result	: result of the operation
timeout	: timeout value, if 0 the environment default will be used

Returns

: status of the operation

Definition at line 794 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = SetXAttr( attrs, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    std::vector<XAttrStatus> *resp = 0;
    st = MessageUtils::WaitForResponse( &handler, resp );
    if( resp ) result.swap( *resp );
    delete resp;
 
    return st;
  }

References XrdCl::Status::IsOK(), SetXAttr(), and XrdCl::MessageUtils::WaitForResponse().

Here is the call graph for this function:

Stat() [1/2]

XRootDStatus XrdCl::File::Stat	(	bool	force,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Obtain status information for this file - async

Parameters

force	do not use the cached information, force re-stating
handler	handler to be notified when the response arrives, the response parameter will hold a StatInfo object if the procedure is successful
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 236 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->Stat( force, handler, timeout );
 
    return FileStateHandler::Stat( pImpl->pStateHandler, force, handler, timeout );
  }

References XrdCl::FileImpl::pStateHandler, XrdCl::FilePlugIn::Stat(), and XrdCl::FileStateHandler::Stat().

Referenced by DoTail(), XrdCl::ZipArchive::List(), XrdCl::Recorder::Stat(), Stat(), and XrdPosixFile::Stat().

Here is the call graph for this function:

Here is the caller graph for this function:

Stat() [2/2]

XRootDStatus XrdCl::File::Stat	(	bool	force,
		StatInfo *&	response,
		time_t	timeout = 0
	)

Obtain status information for this file - sync

Parameters

force	do not use the cached information, force re-stating
response	the response (to be deleted by the user)
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 249 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = Stat( force, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    return MessageUtils::WaitForResponse( &handler, response );
  }

References XrdCl::Status::IsOK(), Stat(), and XrdCl::MessageUtils::WaitForResponse().

Here is the call graph for this function:

Sync() [1/2]

XRootDStatus XrdCl::File::Sync	(	ResponseHandler *	handler,
		time_t	timeout = 0
	)

Commit all pending disk writes - async

Parameters

handler	handler to be notified when the response arrives
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 473 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->Sync( handler, timeout );
 
    return FileStateHandler::Sync( pImpl->pStateHandler, handler, timeout );
  }

References XrdCl::FileImpl::pStateHandler, XrdCl::FilePlugIn::Sync(), and XrdCl::FileStateHandler::Sync().

Referenced by XrdPosixFile::Sync(), XrdCl::Recorder::Sync(), and Sync().

Here is the call graph for this function:

Here is the caller graph for this function:

Sync() [2/2]

XRootDStatus XrdCl::File::Sync

(

time_t

timeout = 0

)

Commit all pending disk writes - sync

Parameters

timeout

timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 485 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = Sync( &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    XRootDStatus status = MessageUtils::WaitForStatus( &handler );
    return status;
  }

References XrdCl::Status::IsOK(), Sync(), and XrdCl::MessageUtils::WaitForStatus().

Here is the call graph for this function:

Truncate() [1/2]

XRootDStatus XrdCl::File::Truncate	(	uint64_t	size,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Truncate the file to a particular size - async

Parameters

size	desired size of the file
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 499 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->Truncate( size, handler, timeout );
 
    return FileStateHandler::Truncate( pImpl->pStateHandler, size, handler, timeout );
  }

References XrdCl::FileImpl::pStateHandler, XrdCl::FileStateHandler::Truncate(), and XrdCl::FilePlugIn::Truncate().

Referenced by XrdPosixFile::Trunc(), XrdCl::Recorder::Truncate(), and Truncate().

Here is the call graph for this function:

Here is the caller graph for this function:

Truncate() [2/2]

XRootDStatus XrdCl::File::Truncate	(	uint64_t	size,
		time_t	timeout = 0
	)

Truncate the file to a particular size - sync

Parameters

size	desired size of the file
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 513 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = Truncate( size, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    XRootDStatus status = MessageUtils::WaitForStatus( &handler );
    return status;
  }

References XrdCl::Status::IsOK(), Truncate(), and XrdCl::MessageUtils::WaitForStatus().

Here is the call graph for this function:

TryOtherServer()

XRootDStatus XrdCl::File::TryOtherServer

(

time_t

timeout = 0

)

Try different data server

Parameters

timeout

: timeout value, if 0 the environment default will be used

Returns

: status of the operation

Definition at line 954 of file XrdClFile.cc.

  {
    return FileStateHandler::TryOtherServer( pImpl->pStateHandler, timeout );
  }

References XrdCl::FileImpl::pStateHandler, and XrdCl::FileStateHandler::TryOtherServer().

Here is the call graph for this function:

VectorRead() [1/2]

XRootDStatus XrdCl::File::VectorRead	(	const ChunkList &	chunks,
		void *	buffer,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Read scattered data chunks in one operation - async

Parameters

chunks	list of the chunks to be read and buffers to put the data in. The default maximum chunk size is 2097136 bytes and the default maximum number of chunks per request is 1024. The server may be queried using FileSystem::Query for the actual settings.
buffer	if zero the buffer pointers in the chunk list will be used, otherwise it needs to point to a buffer big enough to hold the requested data
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Definition at line 552 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->VectorRead( chunks, buffer, handler, timeout );
 
    return FileStateHandler::VectorRead( pImpl->pStateHandler, chunks, buffer, handler, timeout );
  }

References XrdCl::FileImpl::pStateHandler, XrdCl::FilePlugIn::VectorRead(), and XrdCl::FileStateHandler::VectorRead().

Referenced by XrdPosixFile::ReadV(), XrdCl::Recorder::VectorRead(), and VectorRead().

Here is the call graph for this function:

Here is the caller graph for this function:

VectorRead() [2/2]

XRootDStatus XrdCl::File::VectorRead	(	const ChunkList &	chunks,
		void *	buffer,
		VectorReadInfo *&	vReadInfo,
		time_t	timeout = 0
	)

Read scattered data chunks in one operation - sync

Parameters

chunks	list of the chunks to be read and buffers to put the data in. The default maximum chunk size is 2097136 bytes and the default maximum number of chunks per request is 1024. The server may be queried using FileSystem::Query for the actual settings.
buffer	if zero the buffer pointers in the chunk list will be used, otherwise it needs to point to a buffer big enough to hold the requested data
vReadInfo	buffer size and chunk information
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Definition at line 566 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = VectorRead( chunks, buffer, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    return MessageUtils::WaitForResponse( &handler, vReadInfo );
  }

References XrdCl::Status::IsOK(), VectorRead(), and XrdCl::MessageUtils::WaitForResponse().

Here is the call graph for this function:

VectorWrite() [1/2]

XRootDStatus XrdCl::File::VectorWrite	(	const ChunkList &	chunks,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Write scattered data chunks in one operation - async

Parameters

chunks	list of the chunks to be written.
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Definition at line 582 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->VectorWrite( chunks, handler, timeout );
 
    return FileStateHandler::VectorWrite( pImpl->pStateHandler, chunks, handler, timeout );
  }

References XrdCl::FileImpl::pStateHandler, XrdCl::FilePlugIn::VectorWrite(), and XrdCl::FileStateHandler::VectorWrite().

Referenced by XrdCl::Recorder::VectorWrite(), and VectorWrite().

Here is the call graph for this function:

Here is the caller graph for this function:

VectorWrite() [2/2]

XRootDStatus XrdCl::File::VectorWrite	(	const ChunkList &	chunks,
		time_t	timeout = 0
	)

Write scattered data chunks in one operation - sync

Parameters

chunks	list of the chunks to be written.
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Definition at line 595 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = VectorWrite( chunks, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    return MessageUtils::WaitForStatus( &handler );
  }

References XrdCl::Status::IsOK(), VectorWrite(), and XrdCl::MessageUtils::WaitForStatus().

Here is the call graph for this function:

Visa() [1/2]

XRootDStatus XrdCl::File::Visa	(	Buffer *&	visa,
		time_t	timeout = 0
	)

Get access token to a file - sync

Parameters

visa	the access token (to be deleted by the user)
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 767 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = Visa( &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    return MessageUtils::WaitForResponse( &handler, visa );
  }

References XrdCl::Status::IsOK(), Visa(), and XrdCl::MessageUtils::WaitForResponse().

Here is the call graph for this function:

Visa() [2/2]

XRootDStatus XrdCl::File::Visa	(	ResponseHandler *	handler,
		time_t	timeout = 0
	)

Get access token to a file - async.

Get access token to a file - async

Parameters

handler	handler to be notified when the response arrives, the response parameter will hold a Buffer object if the procedure is successful
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 755 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->Visa( handler, timeout );
 
    return FileStateHandler::Visa( pImpl->pStateHandler, handler, timeout );
  }

References XrdCl::FileImpl::pStateHandler, XrdCl::FilePlugIn::Visa(), and XrdCl::FileStateHandler::Visa().

Referenced by Visa(), and XrdCl::Recorder::Visa().

Here is the call graph for this function:

Here is the caller graph for this function:

Write() [1/6]

XRootDStatus XrdCl::File::Write	(	uint64_t	offset,
		Buffer &&	buffer,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Write a data chunk at a given offset - async

Parameters

offset	offset from the beginning of the file
buffer	r-value reference to Buffer object, in this case XrdCl runtime takes ownership of the buffer
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 375 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->Write( offset, std::move( buffer ), handler, timeout );
 
    return FileStateHandler::Write( pImpl->pStateHandler, offset, std::move( buffer ), handler, timeout );
  }

References XrdCl::FileImpl::pStateHandler, XrdCl::FileStateHandler::Write(), and XrdCl::FilePlugIn::Write().

Here is the call graph for this function:

Write() [2/6]

XRootDStatus XrdCl::File::Write	(	uint64_t	offset,
		Buffer &&	buffer,
		time_t	timeout = 0
	)

Write a data chunk at a given offset - sync

Parameters

offset	offset from the beginning of the file
buffer	r-value reference to Buffer object, in this case XrdCl runtime takes ownership of the buffer
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 389 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = Write( offset, std::move( buffer ), &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    XRootDStatus status = MessageUtils::WaitForStatus( &handler );
    return status;
  }

References XrdCl::Status::IsOK(), XrdCl::MessageUtils::WaitForStatus(), and Write().

Here is the call graph for this function:

Write() [3/6]

XRootDStatus XrdCl::File::Write	(	uint64_t	offset,
		uint32_t	size,
		const void *	buffer,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Write a data chunk at a given offset - async The call interprets and returns the server response, which may be either a success or a failure, it does not contain the number of bytes that were actually written.

Parameters

offset	offset from the beginning of the file
size	number of bytes to be written
buffer	a pointer to the buffer holding the data to be written
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 345 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->Write( offset, size, buffer, handler, timeout );
 
    return FileStateHandler::Write( pImpl->pStateHandler, offset, size, buffer, handler, timeout );
  }

References XrdCl::FileImpl::pStateHandler, XrdCl::FileStateHandler::Write(), and XrdCl::FilePlugIn::Write().

Referenced by XrdPosixFile::Write(), XrdCl::Recorder::Write(), and Write().

Here is the call graph for this function:

Here is the caller graph for this function:

Write() [4/6]

XRootDStatus XrdCl::File::Write	(	uint64_t	offset,
		uint32_t	size,
		const void *	buffer,
		time_t	timeout = 0
	)

Write a data chunk at a given offset - sync The call interprets and returns the server response, which may be either a success or a failure, it does not contain the number of bytes that were actually written.

Parameters

offset	offset from the beginning of the file
size	number of bytes to be written
buffer	a pointer to the buffer holding the data to be written
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 360 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = Write( offset, size, buffer, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    XRootDStatus status = MessageUtils::WaitForStatus( &handler );
    return status;
  }

References XrdCl::Status::IsOK(), XrdCl::MessageUtils::WaitForStatus(), and Write().

Here is the call graph for this function:

Write() [5/6]

XRootDStatus XrdCl::File::Write	(	uint64_t	offset,
		uint32_t	size,
		Optional< uint64_t >	fdoff,
		int	fd,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Write a data from a given file descriptor at a given offset - async

Parameters

offset	offset from the beginning of the file
size	number of bytes to be written
fdoff	offset of the data to be written from the file descriptor (optional, if not provided will copy data from the file descriptor at the current cursor position)
fd	file descriptor open for reading
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 405 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->Write( offset, size, fdoff, fd, handler, timeout );
 
    return FileStateHandler::Write( pImpl->pStateHandler, offset, size, fdoff, fd, handler, timeout );
  }

References XrdCl::FileImpl::pStateHandler, XrdCl::FileStateHandler::Write(), and XrdCl::FilePlugIn::Write().

Here is the call graph for this function:

Write() [6/6]

XRootDStatus XrdCl::File::Write	(	uint64_t	offset,
		uint32_t	size,
		Optional< uint64_t >	fdoff,
		int	fd,
		time_t	timeout = 0
	)

Write a data from a given file descriptor at a given offset - sync

Parameters

offset	offset from the beginning of the file
size	number of bytes to be written
fdoff	offset of the data to be written from the file descriptor (optional, if not provided will copy data from the file descriptor at the current cursor position)
fd	file descriptor open for reading
timeout	timeout value, if 0 the environment default will be used

Returns

status of the operation

Definition at line 421 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = Write( offset, size, fdoff, fd, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    XRootDStatus status = MessageUtils::WaitForStatus( &handler );
    return status;
  }

References XrdCl::Status::IsOK(), XrdCl::MessageUtils::WaitForStatus(), and Write().

Here is the call graph for this function:

WriteV() [1/2]

XRootDStatus XrdCl::File::WriteV	(	uint64_t	offset,
		const struct iovec *	iov,
		int	iovcnt,
		ResponseHandler *	handler,
		time_t	timeout = 0
	)

Write scattered buffers in one operation - async

Parameters

offset	offset from the beginning of the file
iov	list of the buffers to be written
iovcnt	number of buffers
handler	handler to be notified when the response arrives
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Definition at line 609 of file XrdClFile.cc.

  {
    if( pPlugIn )
      return pPlugIn->WriteV( offset, iov, iovcnt, handler, timeout );
 
    return FileStateHandler::WriteV( pImpl->pStateHandler, offset, iov, iovcnt, handler, timeout );
  }

References XrdCl::FileImpl::pStateHandler, XrdCl::FileStateHandler::WriteV(), and XrdCl::FilePlugIn::WriteV().

Referenced by WriteV().

Here is the call graph for this function:

Here is the caller graph for this function:

WriteV() [2/2]

XRootDStatus XrdCl::File::WriteV	(	uint64_t	offset,
		const struct iovec *	iov,
		int	iovcnt,
		time_t	timeout = 0
	)

Write scattered buffers in one operation - sync

Parameters

offset	offset from the beginning of the file
iov	list of the buffers to
iovcnt	number of buffers
timeout	timeout value, if 0 then the environment default will be used

Returns

status of the operation

Definition at line 624 of file XrdClFile.cc.

  {
    SyncResponseHandler handler;
    XRootDStatus st = WriteV( offset, iov, iovcnt, &handler, timeout );
    if( !st.IsOK() )
      return st;
 
    XRootDStatus status = MessageUtils::WaitForStatus( &handler );
    return status;
  }

References XrdCl::Status::IsOK(), XrdCl::MessageUtils::WaitForStatus(), and WriteV().

Here is the call graph for this function:

Friends And Related Function Documentation

CheckpointImpl

template<bool HasHndl>

friend class CheckpointImpl

friend

Definition at line 950 of file XrdClFile.hh.

ChkptWrtImpl

template<bool HasHndl>

friend class ChkptWrtImpl

friend

Definition at line 953 of file XrdClFile.hh.

ChkptWrtVImpl

template<bool HasHndl>

friend class ChkptWrtVImpl

friend

Definition at line 956 of file XrdClFile.hh.

CloneLocations

friend struct CloneLocations

friend

Definition at line 54 of file XrdClFile.hh.

---

The documentation for this class was generated from the following files:

• XrdClFile.hh
• XrdClFile.cc