xrootd
XrdClFileOperations.hh
Go to the documentation of this file.
1 //------------------------------------------------------------------------------
2 // Copyright (c) 2011-2017 by European Organization for Nuclear Research (CERN)
3 // Author: Krzysztof Jamrog <krzysztof.piotr.jamrog@cern.ch>,
4 // Michal Simon <michal.simon@cern.ch>
5 //------------------------------------------------------------------------------
6 // This file is part of the XRootD software suite.
7 //
8 // XRootD is free software: you can redistribute it and/or modify
9 // it under the terms of the GNU Lesser General Public License as published by
10 // the Free Software Foundation, either version 3 of the License, or
11 // (at your option) any later version.
12 //
13 // XRootD is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
17 //
18 // You should have received a copy of the GNU Lesser General Public License
19 // along with XRootD. If not, see <http://www.gnu.org/licenses/>.
20 //
21 // In applying this licence, CERN does not waive the privileges and immunities
22 // granted to it by virtue of its status as an Intergovernmental Organization
23 // or submit itself to any jurisdiction.
24 //------------------------------------------------------------------------------
25 
26 #ifndef __XRD_CL_FILE_OPERATIONS_HH__
27 #define __XRD_CL_FILE_OPERATIONS_HH__
28 
29 #include "XrdCl/XrdClFile.hh"
30 #include "XrdCl/XrdClOperations.hh"
32 
33 namespace XrdCl
34 {
35 
36  //----------------------------------------------------------------------------
42  //----------------------------------------------------------------------------
43  template<template<bool> class Derived, bool HasHndl, typename Response, typename ... Arguments>
44  class FileOperation: public ConcreteOperation<Derived, HasHndl, Response, Arguments...>
45  {
46 
47  template<template<bool> class, bool, typename, typename ...> friend class FileOperation;
48 
49  public:
50  //------------------------------------------------------------------------
55  //------------------------------------------------------------------------
56  FileOperation( File *f, Arguments... args): ConcreteOperation<Derived, false, Response, Arguments...>( std::move( args )... ), file(f)
57  {
58  }
59 
60  //------------------------------------------------------------------------
65  //------------------------------------------------------------------------
66  FileOperation( File &f, Arguments... args): FileOperation( &f, std::move( args )... )
67  {
68  }
69 
70  //------------------------------------------------------------------------
76  //------------------------------------------------------------------------
77  template<bool from>
79  ConcreteOperation<Derived, HasHndl, Response, Arguments...>( std::move( op ) ), file( op.file )
80  {
81 
82  }
83 
84  //------------------------------------------------------------------------
86  //------------------------------------------------------------------------
87  virtual ~FileOperation()
88  {
89 
90  }
91 
92  protected:
93 
94  //------------------------------------------------------------------------
96  //------------------------------------------------------------------------
98  };
99 
100  //----------------------------------------------------------------------------
102  //----------------------------------------------------------------------------
103  template<bool HasHndl>
106  {
107  //------------------------------------------------------------------------
113  //------------------------------------------------------------------------
114  struct ExResp : public Resp<void>
115  {
116  //--------------------------------------------------------------------
120  //--------------------------------------------------------------------
121  ExResp( XrdCl::File &file ): file( file )
122  {
123  }
124 
125  //--------------------------------------------------------------------
130  //--------------------------------------------------------------------
131  inline ResponseHandler* Create( std::function<void( XRootDStatus&,
132  StatInfo& )> func )
133  {
134  return new ExOpenFuncWrapper( this->file, func );
135  }
136 
137  //--------------------------------------------------------------------
139  //--------------------------------------------------------------------
140  using Resp<void>::Create;
141 
142  //--------------------------------------------------------------------
144  //--------------------------------------------------------------------
146  };
147 
148  public:
149 
150  //------------------------------------------------------------------------
152  //------------------------------------------------------------------------
155  FileOperation<OpenImpl, HasHndl, Resp<void>, Arg<std::string>, Arg<OpenFlags::Flags>,
156  Arg<Access::Mode>>( f, std::move( url ), std::move( flags ), std::move( mode ) )
157  {
158  }
159 
160  //------------------------------------------------------------------------
162  //------------------------------------------------------------------------
165  FileOperation<OpenImpl, HasHndl, Resp<void>, Arg<std::string>, Arg<OpenFlags::Flags>,
166  Arg<Access::Mode>>( &f, std::move( url ), std::move( flags ), std::move( mode ) )
167  {
168  }
169 
170  //------------------------------------------------------------------------
176  //------------------------------------------------------------------------
177  template<bool from>
179  FileOperation<OpenImpl, HasHndl, Resp<void>, Arg<std::string>,
180  Arg<OpenFlags::Flags>, Arg<Access::Mode>>( std::move( open ) )
181  {
182  }
183 
184 
185  //------------------------------------------------------------------------
187  //------------------------------------------------------------------------
188  enum { UrlArg, FlagsArg, ModeArg };
189 
190  //------------------------------------------------------------------------
195  //------------------------------------------------------------------------
196  template<typename Hdlr>
197  OpenImpl<true> operator>>( Hdlr &&hdlr )
198  {
199  // check if the resulting handler should be owned by us or by the user,
200  // if the user passed us directly a ResponseHandler it's owned by the
201  // user, otherwise we need to wrap the argument in a handler and in this
202  // case the resulting handler will be owned by us
203  constexpr bool own = !IsResponseHandler<Hdlr>::value;
204  ExResp factory( *this->file );
205  return this->StreamImpl( factory.Create( hdlr ), own );
206  }
207 
208  //------------------------------------------------------------------------
210  //------------------------------------------------------------------------
211  std::string ToString()
212  {
213  return "Open";
214  }
215 
216  protected:
217 
218  //------------------------------------------------------------------------
224  //------------------------------------------------------------------------
226  {
227  try
228  {
229  std::string url = std::get<UrlArg>( this->args ).Get();
230  OpenFlags::Flags flags = std::get<FlagsArg>( this->args ).Get();
231  Access::Mode mode = std::get<ModeArg>( this->args ).Get();
232  return this->file->Open( url, flags, mode, this->handler.get() );
233  }
234  catch( const PipelineException& ex )
235  {
236  return ex.GetError();
237  }
238  catch( const std::exception& ex )
239  {
240  return XRootDStatus( stError, ex.what() );
241  }
242  }
243  };
245 
246  //----------------------------------------------------------------------------
248  //----------------------------------------------------------------------------
249  template<bool HasHndl>
250  class ReadImpl: public FileOperation<ReadImpl, HasHndl, Resp<ChunkInfo>,
251  Arg<uint64_t>, Arg<uint32_t>, Arg<void*>>
252  {
253  public:
254 
255  //------------------------------------------------------------------------
257  //------------------------------------------------------------------------
260 
261  //------------------------------------------------------------------------
263  //------------------------------------------------------------------------
265 
266  //------------------------------------------------------------------------
268  //------------------------------------------------------------------------
269  std::string ToString()
270  {
271  return "Read";
272  }
273 
274  protected:
275 
276  //------------------------------------------------------------------------
282  //------------------------------------------------------------------------
284  {
285  try
286  {
287  uint64_t offset = std::get<OffsetArg>( this->args ).Get();
288  uint32_t size = std::get<SizeArg>( this->args ).Get();
289  void *buffer = std::get<BufferArg>( this->args ).Get();
290  return this->file->Read( offset, size, buffer, this->handler.get() );
291  }
292  catch( const PipelineException& ex )
293  {
294  return ex.GetError();
295  }
296  catch( const std::exception& ex )
297  {
298  return XRootDStatus( stError, ex.what() );
299  }
300  }
301  };
303 
304  //----------------------------------------------------------------------------
306  //----------------------------------------------------------------------------
307  template<bool HasHndl>
308  class CloseImpl: public FileOperation<CloseImpl, HasHndl, Resp<void>>
309  {
310  public:
311 
312  //------------------------------------------------------------------------
314  //------------------------------------------------------------------------
316 
317  //------------------------------------------------------------------------
319  //------------------------------------------------------------------------
320  std::string ToString()
321  {
322  return "Close";
323  }
324 
325  protected:
326 
327  //------------------------------------------------------------------------
333  //------------------------------------------------------------------------
335  {
336  return this->file->Close( this->handler.get() );
337  }
338  };
340 
341  //----------------------------------------------------------------------------
343  //----------------------------------------------------------------------------
344  template<bool HasHndl>
345  class StatImpl: public FileOperation<StatImpl, HasHndl, Resp<StatInfo>, Arg<bool>>
346  {
347  public:
348 
349  //------------------------------------------------------------------------
351  //------------------------------------------------------------------------
353 
354  //------------------------------------------------------------------------
356  //------------------------------------------------------------------------
357  enum { ForceArg };
358 
359  //------------------------------------------------------------------------
361  //------------------------------------------------------------------------
362  std::string ToString()
363  {
364  return "Stat";
365  }
366 
367  protected:
368 
369  //------------------------------------------------------------------------
375  //------------------------------------------------------------------------
377  {
378  try
379  {
380  bool force = std::get<ForceArg>( this->args ).Get();
381  return this->file->Stat( force, this->handler.get() );
382  }
383  catch( const PipelineException& ex )
384  {
385  return ex.GetError();
386  }
387  catch( const std::exception& ex )
388  {
389  return XRootDStatus( stError, ex.what() );
390  }
391  }
392  };
393 
394  //----------------------------------------------------------------------------
397  //----------------------------------------------------------------------------
399  {
400  return StatImpl<false>( file, std::move( force ) );
401  }
402 
403  //----------------------------------------------------------------------------
406  //----------------------------------------------------------------------------
408  {
409  return StatImpl<false>( file, std::move( force ) );
410  }
411 
412  //----------------------------------------------------------------------------
414  //----------------------------------------------------------------------------
415  template<bool HasHndl>
416  class WriteImpl: public FileOperation<WriteImpl, HasHndl, Resp<void>, Arg<uint64_t>,
417  Arg<uint32_t>, Arg<void*>>
418  {
419  public:
420 
421  //------------------------------------------------------------------------
423  //------------------------------------------------------------------------
426 
427  //------------------------------------------------------------------------
429  //------------------------------------------------------------------------
431 
432  //------------------------------------------------------------------------
434  //------------------------------------------------------------------------
435  std::string ToString()
436  {
437  return "Write";
438  }
439 
440  protected:
441 
442  //------------------------------------------------------------------------
448  //------------------------------------------------------------------------
450  {
451  try
452  {
453  uint64_t offset = std::get<OffsetArg>( this->args ).Get();
454  uint32_t size = std::get<SizeArg>( this->args ).Get();
455  void *buffer = std::get<BufferArg>( this->args ).Get();
456  return this->file->Write( offset, size, buffer, this->handler.get() );
457  }
458  catch( const PipelineException& ex )
459  {
460  return ex.GetError();
461  }
462  catch( const std::exception& ex )
463  {
464  return XRootDStatus( stError, ex.what() );
465  }
466  }
467  };
469 
470  //----------------------------------------------------------------------------
472  //----------------------------------------------------------------------------
473  template<bool HasHndl>
474  class SyncImpl: public FileOperation<SyncImpl, HasHndl, Resp<void>>
475  {
476  public:
477 
478  //------------------------------------------------------------------------
480  //------------------------------------------------------------------------
482 
483  //------------------------------------------------------------------------
485  //------------------------------------------------------------------------
486  std::string ToString()
487  {
488  return "Sync";
489  }
490 
491  protected:
492 
493  //------------------------------------------------------------------------
499  //------------------------------------------------------------------------
501  {
502  return this->file->Sync( this->handler.get() );
503  }
504  };
506 
507  //----------------------------------------------------------------------------
509  //----------------------------------------------------------------------------
510  template<bool HasHndl>
511  class TruncateImpl: public FileOperation<TruncateImpl, HasHndl, Resp<void>, Arg<uint64_t>>
512  {
513  public:
514 
515  //------------------------------------------------------------------------
517  //------------------------------------------------------------------------
519 
520  //------------------------------------------------------------------------
522  //------------------------------------------------------------------------
523  enum { SizeArg };
524 
525  //------------------------------------------------------------------------
527  //------------------------------------------------------------------------
528  std::string ToString()
529  {
530  return "Truncate";
531  }
532 
533  protected:
534 
535  //------------------------------------------------------------------------
541  //------------------------------------------------------------------------
543  {
544  try
545  {
546  uint64_t size = std::get<SizeArg>( this->args ).Get();
547  return this->file->Truncate( size, this->handler.get() );
548  }
549  catch( const PipelineException& ex )
550  {
551  return ex.GetError();
552  }
553  catch( const std::exception& ex )
554  {
555  return XRootDStatus( stError, ex.what() );
556  }
557  }
558  };
559 
560  //----------------------------------------------------------------------------
563  //----------------------------------------------------------------------------
565  {
566  return TruncateImpl<false>( file, std::move( size ) );
567  }
568 
569  //----------------------------------------------------------------------------
572  //----------------------------------------------------------------------------
574  {
575  return TruncateImpl<false>( file, std::move( size ) );
576  }
577 
578  //----------------------------------------------------------------------------
580  //----------------------------------------------------------------------------
581  template<bool HasHndl>
582  class VectorReadImpl: public FileOperation<VectorReadImpl, HasHndl,
583  Resp<VectorReadInfo>, Arg<ChunkList>, Arg<void*>>
584  {
585  public:
586 
587  //------------------------------------------------------------------------
589  //------------------------------------------------------------------------
592 
593  //------------------------------------------------------------------------
595  //------------------------------------------------------------------------
596  enum { ChunksArg, BufferArg };
597 
598  //------------------------------------------------------------------------
600  //------------------------------------------------------------------------
601  std::string ToString()
602  {
603  return "VectorRead";
604  }
605 
606  protected:
607 
608  //------------------------------------------------------------------------
614  //------------------------------------------------------------------------
616  {
617  try
618  {
619  ChunkList chunks( std::get<ChunksArg>( this->args ).Get() );
620  void *buffer = std::get<BufferArg>( this->args ).Get();
621  return this->file->VectorRead( chunks, buffer, this->handler.get() );
622  }
623  catch( const PipelineException& ex )
624  {
625  return ex.GetError();
626  }
627  catch( const std::exception& ex )
628  {
629  return XRootDStatus( stError, ex.what() );
630  }
631  }
632  };
634 
635  //----------------------------------------------------------------------------
637  //----------------------------------------------------------------------------
638  template<bool HasHndl>
639  class VectorWriteImpl: public FileOperation<VectorWriteImpl, HasHndl, Resp<void>,
640  Arg<ChunkList>>
641  {
642  public:
643 
644  //------------------------------------------------------------------------
646  //------------------------------------------------------------------------
648 
649  //------------------------------------------------------------------------
651  //------------------------------------------------------------------------
652  enum { ChunksArg };
653 
654  //------------------------------------------------------------------------
656  //------------------------------------------------------------------------
657  std::string ToString()
658  {
659  return "VectorWrite";
660  }
661 
662  protected:
663 
664  //------------------------------------------------------------------------
670  //------------------------------------------------------------------------
672  {
673  try
674  {
675  const ChunkList chunks( std::get<ChunksArg>( this->args ).Get() );
676  return this->file->VectorWrite( chunks, this->handler.get() );
677  }
678  catch( const PipelineException& ex )
679  {
680  return ex.GetError();
681  }
682  catch( const std::exception& ex )
683  {
684  return XRootDStatus( stError, ex.what() );
685  }
686  }
687  };
689 
690  //----------------------------------------------------------------------------
692  //----------------------------------------------------------------------------
693  template<bool HasHndl>
694  class WriteVImpl: public FileOperation<WriteVImpl, HasHndl, Resp<void>, Arg<uint64_t>,
695  Arg<struct iovec*>, Arg<int>>
696  {
697  public:
698 
699  //------------------------------------------------------------------------
701  //------------------------------------------------------------------------
704 
705  //------------------------------------------------------------------------
707  //------------------------------------------------------------------------
709 
710  //------------------------------------------------------------------------
712  //------------------------------------------------------------------------
713  std::string ToString()
714  {
715  return "WriteV";
716  }
717 
718  protected:
719 
720  //------------------------------------------------------------------------
726  //------------------------------------------------------------------------
728  {
729  try
730  {
731  uint64_t offset = std::get<OffsetArg>( this->args ).Get();
732  const struct iovec *iov = std::get<IovArg>( this->args ).Get();
733  int iovcnt = std::get<IovcntArg>( this->args ).Get();
734  return this->file->WriteV( offset, iov, iovcnt, this->handler.get() );
735  }
736  catch( const PipelineException& ex )
737  {
738  return ex.GetError();
739  }
740  catch( const std::exception& ex )
741  {
742  return XRootDStatus( stError, ex.what() );
743  }
744  }
745  };
747 
748  //----------------------------------------------------------------------------
750  //----------------------------------------------------------------------------
751  template<bool HasHndl>
752  class FcntlImpl: public FileOperation<FcntlImpl, HasHndl, Resp<Buffer>, Arg<Buffer>>
753  {
754  public:
755 
756  //------------------------------------------------------------------------
758  //------------------------------------------------------------------------
760 
761  //------------------------------------------------------------------------
763  //------------------------------------------------------------------------
764  enum { BufferArg };
765 
766  //------------------------------------------------------------------------
768  //------------------------------------------------------------------------
769  std::string ToString()
770  {
771  return "Fcntl";
772  }
773 
774  protected:
775 
776  //------------------------------------------------------------------------
782  //------------------------------------------------------------------------
784  {
785  try
786  {
787  Buffer arg( std::get<BufferArg>( this->args ).Get() );
788  return this->file->Fcntl( arg, this->handler.get() );
789  }
790  catch( const PipelineException& ex )
791  {
792  return ex.GetError();
793  }
794  catch( const std::exception& ex )
795  {
796  return XRootDStatus( stError, ex.what() );
797  }
798  }
799  };
801 
802  //----------------------------------------------------------------------------
804  //----------------------------------------------------------------------------
805  template<bool HasHndl>
806  class VisaImpl: public FileOperation<VisaImpl, HasHndl, Resp<Buffer>>
807  {
808  public:
809 
810  //------------------------------------------------------------------------
812  //------------------------------------------------------------------------
814 
815  //------------------------------------------------------------------------
817  //------------------------------------------------------------------------
818  std::string ToString()
819  {
820  return "Visa";
821  }
822 
823  protected:
824 
825  //------------------------------------------------------------------------
831  //------------------------------------------------------------------------
833  {
834  return this->file->Visa( this->handler.get() );
835  }
836  };
838 }
839 
840 #endif // __XRD_CL_FILE_OPERATIONS_HH__
841 
XrdClOperationHandlers.hh
XrdCl::Resp
Definition: XrdClOperationHandlers.hh:554
XrdCl::WriteImpl
Write operation (.
Definition: XrdClFileOperations.hh:418
XrdCl::ResponseHandler
Handle an async response.
Definition: XrdClXRootDResponses.hh:855
XrdCl::PipelineException::GetError
const XRootDStatus & GetError() const
Definition: XrdClOperationHandlers.hh:351
XrdCl::WriteV
WriteVImpl< false > WriteV
Definition: XrdClFileOperations.hh:746
XrdCl::WriteImpl::SizeArg
@ SizeArg
Definition: XrdClFileOperations.hh:430
XrdCl::WriteImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:449
XrdCl::FcntlImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:769
XrdCl::Open
OpenImpl< false > Open
Definition: XrdClFileOperations.hh:244
XrdCl::Close
CloseImpl< false > Close
Definition: XrdClFileOperations.hh:339
XrdCl::Access
Access mode.
Definition: XrdClFileSystem.hh:118
XrdCl::OpenImpl::ExResp
Definition: XrdClFileOperations.hh:115
XrdCl::OpenImpl::ExResp::Create
ResponseHandler * Create(std::function< void(XRootDStatus &, StatInfo &)> func)
Definition: XrdClFileOperations.hh:131
XrdCl::WriteImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:435
XrdCl::FileOperation::file
File * file
The file object itself.
Definition: XrdClFileOperations.hh:97
XrdCl::TruncateImpl::SizeArg
@ SizeArg
Definition: XrdClFileOperations.hh:523
XrdCl::FileOperation::~FileOperation
virtual ~FileOperation()
Destructor.
Definition: XrdClFileOperations.hh:87
XrdCl::ReadImpl::OffsetArg
@ OffsetArg
Definition: XrdClFileOperations.hh:264
XrdCl::WriteVImpl::IovArg
@ IovArg
Definition: XrdClFileOperations.hh:708
XrdCl::ReadImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:283
XrdCl::TruncateImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:528
XrdCl::OpenImpl::operator>>
OpenImpl< true > operator>>(Hdlr &&hdlr)
Definition: XrdClFileOperations.hh:197
XrdCl::OpenImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:225
XrdCl::OpenImpl
Open operation (.
Definition: XrdClFileOperations.hh:106
XrdCl::VectorReadImpl
VectorRead operation (.
Definition: XrdClFileOperations.hh:584
XrdCl::StatImpl
Stat operation (.
Definition: XrdClFileOperations.hh:346
XrdCl::VectorWriteImpl::ChunksArg
@ ChunksArg
Definition: XrdClFileOperations.hh:652
XrdCl::Truncate
TruncateImpl< false > Truncate(File *file, Arg< uint64_t > size)
Definition: XrdClFileOperations.hh:564
XrdCl::Arg< std::string >
Definition: XrdClArg.hh:286
XrdCl::Operation::handler
std::unique_ptr< PipelineHandler > handler
Operation handler.
Definition: XrdClOperations.hh:280
XrdCl::WriteVImpl
WriteV operation (.
Definition: XrdClFileOperations.hh:696
XrdCl::File
A file.
Definition: XrdClFile.hh:45
XrdCl::PipelineException
Pipeline exception, wrapps an XRootDStatus.
Definition: XrdClOperationHandlers.hh:312
XrdCl::OpenFlags
Open flags, may be or'd when appropriate.
Definition: XrdClFileSystem.hh:72
XrdCl::FcntlImpl::BufferArg
@ BufferArg
Definition: XrdClFileOperations.hh:764
XrdCl::FileOperation::FileOperation
friend class FileOperation
Definition: XrdClFileOperations.hh:47
XrdCl::OpenImpl::OpenImpl
OpenImpl(File *f, Arg< std::string > url, Arg< OpenFlags::Flags > flags, Arg< Access::Mode > mode=Access::None)
Constructor (.
Definition: XrdClFileOperations.hh:153
XrdCl::ReadImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:269
XrdCl::VisaImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:818
XrdCl::StatImpl::ForceArg
@ ForceArg
Definition: XrdClFileOperations.hh:357
XrdCl::CloseImpl
Close operation (.
Definition: XrdClFileOperations.hh:309
XrdCl::FileOperation::FileOperation
FileOperation(File *f, Arguments... args)
Definition: XrdClFileOperations.hh:56
XrdCl::Access::Mode
Mode
Access mode.
Definition: XrdClFileSystem.hh:123
XrdCl::ConcreteOperation< Derived, HasHndl, Response, Arguments... >::args
std::tuple< Args... > args
Operation arguments.
Definition: XrdClOperations.hh:686
XrdCl::TruncateImpl
Truncate operation (.
Definition: XrdClFileOperations.hh:512
XrdCl::ConcreteOperation
Definition: XrdClOperations.hh:468
XrdCl::OpenImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:211
XrdCl::CloseImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:320
XrdCl::OpenImpl::ExResp::ExResp
ExResp(XrdCl::File &file)
Definition: XrdClFileOperations.hh:121
XrdCl::File::Sync
XRootDStatus Sync(ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XrdClOperations.hh
XrdCl::VisaImpl
Visa operation (.
Definition: XrdClFileOperations.hh:807
open
#define open
Definition: XrdPosix.hh:71
XrdCl::XRootDStatus
Request status.
Definition: XrdClXRootDResponses.hh:213
XrdCl::Fcntl
FcntlImpl< false > Fcntl
Definition: XrdClFileOperations.hh:800
XrdCl::OpenImpl::OpenImpl
OpenImpl(File &f, Arg< std::string > url, Arg< OpenFlags::Flags > flags, Arg< Access::Mode > mode=Access::None)
Constructor (.
Definition: XrdClFileOperations.hh:163
XrdCl::ChunkList
std::vector< ChunkInfo > ChunkList
List of chunks.
Definition: XrdClXRootDResponses.hh:784
XrdCl::OpenImpl::OpenImpl
OpenImpl(OpenImpl< from > &&open)
Definition: XrdClFileOperations.hh:178
XrdCl::SyncImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:486
XrdCl::WriteVImpl::IovcntArg
@ IovcntArg
Definition: XrdClFileOperations.hh:708
XrdCl::VectorReadImpl::BufferArg
@ BufferArg
Definition: XrdClFileOperations.hh:596
XrdCl::CloseImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:334
XrdCl::Read
ReadImpl< false > Read
Definition: XrdClFileOperations.hh:302
XrdCl::ReadImpl
Read operation (.
Definition: XrdClFileOperations.hh:252
XrdCl::StatImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:376
XrdCl::FileOperation::FileOperation
FileOperation(File &f, Arguments... args)
Definition: XrdClFileOperations.hh:66
XrdCl::VectorWriteImpl
VectorWrite operation (.
Definition: XrdClFileOperations.hh:641
XrdCl::File::VectorRead
XRootDStatus VectorRead(const ChunkList &chunks, void *buffer, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XrdCl::SyncImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:500
XrdCl::File::Read
XRootDStatus Read(uint64_t offset, uint32_t size, void *buffer, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XrdCl::File::Write
XRootDStatus Write(uint64_t offset, uint32_t size, const void *buffer, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XrdCl::File::Close
XRootDStatus Close(ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XrdCl::File::Truncate
XRootDStatus Truncate(uint64_t size, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XrdCl::VectorReadImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:601
XrdCl::Visa
VisaImpl< false > Visa
Definition: XrdClFileOperations.hh:837
XrdCl::WriteVImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:727
XrdCl::FileOperation
Definition: XrdClFileOperations.hh:45
XrdCl::VectorReadImpl::ChunksArg
@ ChunksArg
Definition: XrdClFileOperations.hh:596
XrdCl::StatImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:362
XrdCl::OpenImpl::UrlArg
@ UrlArg
Definition: XrdClFileOperations.hh:188
XrdCl::Stat
StatImpl< false > Stat(File *file, Arg< bool > force)
Definition: XrdClFileOperations.hh:398
XrdCl::File::Visa
XRootDStatus Visa(ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XrdClFile.hh
XrdCl::FcntlImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:783
XrdCl::VectorRead
VectorReadImpl< false > VectorRead
Definition: XrdClFileOperations.hh:633
XrdCl::ExOpenFuncWrapper
Lambda wrapper.
Definition: XrdClOperationHandlers.hh:259
XrdCl::Write
WriteImpl< false > Write
Definition: XrdClFileOperations.hh:468
XrdCl::File::VectorWrite
XRootDStatus VectorWrite(const ChunkList &chunks, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XrdCl::OpenImpl::ExResp::file
XrdCl::File & file
The underlying XrdCl::File object.
Definition: XrdClFileOperations.hh:145
XrdCl
Definition: XrdClAnyObject.hh:26
XrdCl::VectorWriteImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:671
XrdCl::FcntlImpl
Fcntl operation (.
Definition: XrdClFileOperations.hh:753
XrdCl::FileOperation::FileOperation
FileOperation(FileOperation< Derived, from, Response, Arguments... > &&op)
Definition: XrdClFileOperations.hh:78
XrdCl::VectorWriteImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:657
XrdCl::VectorWrite
VectorWriteImpl< false > VectorWrite
Definition: XrdClFileOperations.hh:688
XrdCl::File::WriteV
XRootDStatus WriteV(uint64_t offset, const struct iovec *iov, int iovcnt, ResponseHandler *handler, uint16_t timeout=0)
XrdCl::WriteImpl::BufferArg
@ BufferArg
Definition: XrdClFileOperations.hh:430
XrdCl::File::Stat
XRootDStatus Stat(bool force, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XrdCl::Access::None
@ None
Definition: XrdClFileSystem.hh:124
XrdCl::Arg
Definition: XrdClArg.hh:224
XrdCl::stError
const uint16_t stError
An error occurred that could potentially be retried.
Definition: XrdClStatus.hh:32
XrdCl::StatInfo
Object stat info.
Definition: XrdClXRootDResponses.hh:333
XrdCl::SyncImpl
Sync operation (.
Definition: XrdClFileOperations.hh:475
XrdCl::VectorReadImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:615
XrdCl::ReadImpl::SizeArg
@ SizeArg
Definition: XrdClFileOperations.hh:264
XrdCl::Buffer
Binary blob representation.
Definition: XrdClBuffer.hh:34
XrdCl::Sync
SyncImpl< false > Sync
Definition: XrdClFileOperations.hh:505
XrdCl::TruncateImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:542
XrdCl::File::Fcntl
XRootDStatus Fcntl(const Buffer &arg, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XrdCl::ReadImpl::BufferArg
@ BufferArg
Definition: XrdClFileOperations.hh:264
XrdCl::VisaImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:832
XrdCl::OpenFlags::Flags
Flags
Open flags, may be or'd when appropriate.
Definition: XrdClFileSystem.hh:77
XrdCl::IsResponseHandler
Definition: XrdClOperationHandlers.hh:41
XrdCl::WriteVImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:713
XrdCl::WriteVImpl::OffsetArg
@ OffsetArg
Definition: XrdClFileOperations.hh:708
XrdCl::WriteImpl::OffsetArg
@ OffsetArg
Definition: XrdClFileOperations.hh:430