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 
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:283
std::string ToString()
Definition: XrdClFileOperations.hh:713
CloseImpl< false > Close
Definition: XrdClFileOperations.hh:339
FileOperation(File &f, Arguments... args)
Definition: XrdClFileOperations.hh:66
Close operation (.
Definition: XrdClFileOperations.hh:308
XrdCl::File & file
The underlying XrdCl::File object.
Definition: XrdClFileOperations.hh:145
XRootDStatus VectorRead(const ChunkList &chunks, void *buffer, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus WriteV(uint64_t offset, const struct iovec *iov, int iovcnt, ResponseHandler *handler, uint16_t timeout=0)
std::vector< ChunkInfo > ChunkList
List of chunks.
Definition: XrdClXRootDResponses.hh:769
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:334
VectorReadImpl< false > VectorRead
Definition: XrdClFileOperations.hh:633
Definition: XrdClFileOperations.hh:708
VectorRead operation (.
Definition: XrdClFileOperations.hh:582
FcntlImpl< false > Fcntl
Definition: XrdClFileOperations.hh:800
Definition: XrdClOperationHandlers.hh:40
Object stat info.
Definition: XrdClXRootDResponses.hh:332
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:449
std::string ToString()
Definition: XrdClFileOperations.hh:320
Definition: XrdClFileOperations.hh:523
std::string ToString()
Definition: XrdClFileOperations.hh:211
XRootDStatus Sync(ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
Definition: XrdClFileOperations.hh:264
FileOperation(FileOperation< Derived, from, Response, Arguments... > &&op)
Definition: XrdClFileOperations.hh:78
Definition: XrdClFileOperations.hh:430
Definition: XrdClFileOperations.hh:708
VectorWrite operation (.
Definition: XrdClFileOperations.hh:639
XRootDStatus Write(uint64_t offset, uint32_t size, const void *buffer, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
Fcntl operation (.
Definition: XrdClFileOperations.hh:752
SyncImpl< false > Sync
Definition: XrdClFileOperations.hh:505
std::string ToString()
Definition: XrdClFileOperations.hh:435
Visa operation (.
Definition: XrdClFileOperations.hh:806
std::string ToString()
Definition: XrdClFileOperations.hh:528
Access mode.
Definition: XrdClFileSystem.hh:115
std::string ToString()
Definition: XrdClFileOperations.hh:486
Read operation (.
Definition: XrdClFileOperations.hh:250
std::string ToString()
Definition: XrdClFileOperations.hh:657
std::string ToString()
Definition: XrdClFileOperations.hh:769
Definition: XrdClFileOperations.hh:430
XRootDStatus Visa(ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
WriteImpl< false > Write
Definition: XrdClFileOperations.hh:468
Definition: XrdClFileOperations.hh:430
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:783
std::string ToString()
Definition: XrdClFileOperations.hh:269
Definition: XrdClFileOperations.hh:708
Definition: XrdClFileOperations.hh:188
OpenImpl< true > operator>>(Hdlr &&hdlr)
Definition: XrdClFileOperations.hh:197
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:225
Definition: XrdClFileOperations.hh:357
VectorWriteImpl< false > VectorWrite
Definition: XrdClFileOperations.hh:688
std::string ToString()
Definition: XrdClFileOperations.hh:818
Definition: XrdClOperationHandlers.hh:553
Truncate operation (.
Definition: XrdClFileOperations.hh:511
WriteV operation (.
Definition: XrdClFileOperations.hh:694
Open flags, may be or&#39;d when appropriate.
Definition: XrdClFileSystem.hh:71
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:500
Definition: XrdClFileOperations.hh:596
XRootDStatus Read(uint64_t offset, uint32_t size, void *buffer, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
Pipeline exception, wrapps an XRootDStatus.
Definition: XrdClOperationHandlers.hh:311
std::string ToString()
Definition: XrdClFileOperations.hh:362
A file.
Definition: XrdClFile.hh:44
File * file
The file object itself.
Definition: XrdClFileOperations.hh:97
OpenImpl(File *f, Arg< std::string > url, Arg< OpenFlags::Flags > flags, Arg< Access::Mode > mode=Access::None)
Constructor (.
Definition: XrdClFileOperations.hh:153
XRootDStatus Close(ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
virtual ~FileOperation()
Destructor.
Definition: XrdClFileOperations.hh:87
std::tuple< Args... > args
Operation arguments.
Definition: XrdClOperations.hh:686
Definition: XrdClArg.hh:223
Definition: XrdClFileOperations.hh:114
Definition: XrdClArg.hh:285
StatImpl< false > Stat(File *file, Arg< bool > force)
Definition: XrdClFileOperations.hh:398
ReadImpl< false > Read
Definition: XrdClFileOperations.hh:302
Stat operation (.
Definition: XrdClFileOperations.hh:345
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:376
const uint16_t stError
An error occurred that could potentially be retried.
Definition: XrdClStatus.hh:32
Request status.
Definition: XrdClXRootDResponses.hh:212
Definition: XrdClAnyObject.hh:25
Sync operation (.
Definition: XrdClFileOperations.hh:474
OpenImpl(File &f, Arg< std::string > url, Arg< OpenFlags::Flags > flags, Arg< Access::Mode > mode=Access::None)
Constructor (.
Definition: XrdClFileOperations.hh:163
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:727
const XRootDStatus & GetError() const
Definition: XrdClOperationHandlers.hh:351
Lambda wrapper.
Definition: XrdClOperationHandlers.hh:258
OpenImpl(OpenImpl< from > &&open)
Definition: XrdClFileOperations.hh:178
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:671
Definition: XrdClFileOperations.hh:44
XRootDStatus Truncate(uint64_t size, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus VectorWrite(const ChunkList &chunks, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
Definition: XrdClFileOperations.hh:652
Handle an async response.
Definition: XrdClXRootDResponses.hh:839
Definition: XrdClFileSystem.hh:122
std::string ToString()
Definition: XrdClFileOperations.hh:601
OpenImpl< false > Open
Definition: XrdClFileOperations.hh:244
friend class FileOperation
Definition: XrdClFileOperations.hh:47
ResponseHandler * Create(std::function< void(XRootDStatus &, StatInfo &)> func)
Definition: XrdClFileOperations.hh:131
Open operation (.
Definition: XrdClFileOperations.hh:104
XRootDStatus Stat(bool force, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:832
Definition: XrdClFileOperations.hh:596
WriteVImpl< false > WriteV
Definition: XrdClFileOperations.hh:746
Mode
Access mode.
Definition: XrdClFileSystem.hh:120
#define open
Definition: XrdPosix.hh:71
Definition: XrdClFileOperations.hh:764
VisaImpl< false > Visa
Definition: XrdClFileOperations.hh:837
ExResp(XrdCl::File &file)
Definition: XrdClFileOperations.hh:121
Flags
Open flags, may be or&#39;d when appropriate.
Definition: XrdClFileSystem.hh:76
Definition: XrdClFileOperations.hh:264
TruncateImpl< false > Truncate(File *file, Arg< uint64_t > size)
Definition: XrdClFileOperations.hh:564
Definition: XrdClFileOperations.hh:264
Write operation (.
Definition: XrdClFileOperations.hh:416
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:615
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:542
std::unique_ptr< PipelineHandler > handler
Operation handler.
Definition: XrdClOperations.hh:280
FileOperation(File *f, Arguments... args)
Definition: XrdClFileOperations.hh:56
XRootDStatus Fcntl(const Buffer &arg, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
Binary blob representation.
Definition: XrdClBuffer.hh:33
Definition: XrdClOperations.hh:467