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 make_finalized( 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  ExResp factory( *this->file );
200  return this->StreamImpl( factory.Create( hdlr ) );
201  }
202 
203  //------------------------------------------------------------------------
205  //------------------------------------------------------------------------
206  std::string ToString()
207  {
208  return "Open";
209  }
210 
211  protected:
212 
213  //------------------------------------------------------------------------
219  //------------------------------------------------------------------------
221  {
222  try
223  {
224  std::string url = std::get<UrlArg>( this->args ).Get();
225  OpenFlags::Flags flags = std::get<FlagsArg>( this->args ).Get();
226  Access::Mode mode = std::get<ModeArg>( this->args ).Get();
227  return this->file->Open( url, flags, mode, this->handler.get() );
228  }
229  catch( const PipelineException& ex )
230  {
231  return ex.GetError();
232  }
233  catch( const std::exception& ex )
234  {
235  return XRootDStatus( stError, ex.what() );
236  }
237  }
238  };
240 
241  //----------------------------------------------------------------------------
243  //----------------------------------------------------------------------------
244  template<bool HasHndl>
245  class ReadImpl: public FileOperation<ReadImpl, HasHndl, Resp<ChunkInfo>,
246  Arg<uint64_t>, Arg<uint32_t>, Arg<void*>>
247  {
248  public:
249 
250  //------------------------------------------------------------------------
252  //------------------------------------------------------------------------
255 
256  //------------------------------------------------------------------------
258  //------------------------------------------------------------------------
260 
261  //------------------------------------------------------------------------
263  //------------------------------------------------------------------------
264  std::string ToString()
265  {
266  return "Read";
267  }
268 
269  protected:
270 
271  //------------------------------------------------------------------------
277  //------------------------------------------------------------------------
279  {
280  try
281  {
282  uint64_t offset = std::get<OffsetArg>( this->args ).Get();
283  uint32_t size = std::get<SizeArg>( this->args ).Get();
284  void *buffer = std::get<BufferArg>( this->args ).Get();
285  return this->file->Read( offset, size, buffer, this->handler.get() );
286  }
287  catch( const PipelineException& ex )
288  {
289  return ex.GetError();
290  }
291  catch( const std::exception& ex )
292  {
293  return XRootDStatus( stError, ex.what() );
294  }
295  }
296  };
298 
299  //----------------------------------------------------------------------------
301  //----------------------------------------------------------------------------
302  template<bool HasHndl>
303  class CloseImpl: public FileOperation<CloseImpl, HasHndl, Resp<void>>
304  {
305  public:
306 
307  //------------------------------------------------------------------------
309  //------------------------------------------------------------------------
311 
312  //------------------------------------------------------------------------
314  //------------------------------------------------------------------------
315  std::string ToString()
316  {
317  return "Close";
318  }
319 
320  protected:
321 
322  //------------------------------------------------------------------------
328  //------------------------------------------------------------------------
330  {
331  return this->file->Close( this->handler.get() );
332  }
333  };
335 
336  //----------------------------------------------------------------------------
338  //----------------------------------------------------------------------------
339  template<bool HasHndl>
340  class StatImpl: public FileOperation<StatImpl, HasHndl, Resp<StatInfo>, Arg<bool>>
341  {
342  public:
343 
344  //------------------------------------------------------------------------
346  //------------------------------------------------------------------------
348 
349  //------------------------------------------------------------------------
351  //------------------------------------------------------------------------
352  enum { ForceArg };
353 
354  //------------------------------------------------------------------------
356  //------------------------------------------------------------------------
357  std::string ToString()
358  {
359  return "Stat";
360  }
361 
362  protected:
363 
364  //------------------------------------------------------------------------
370  //------------------------------------------------------------------------
372  {
373  try
374  {
375  bool force = std::get<ForceArg>( this->args ).Get();
376  return this->file->Stat( force, this->handler.get() );
377  }
378  catch( const PipelineException& ex )
379  {
380  return ex.GetError();
381  }
382  catch( const std::exception& ex )
383  {
384  return XRootDStatus( stError, ex.what() );
385  }
386  }
387  };
388 
389  //----------------------------------------------------------------------------
392  //----------------------------------------------------------------------------
393  inline StatImpl<false> Stat( File *file, Arg<bool> force )
394  {
395  return StatImpl<false>( file, std::move( force ) );
396  }
397 
398  //----------------------------------------------------------------------------
401  //----------------------------------------------------------------------------
402  inline StatImpl<false> Stat( File &file, Arg<bool> force )
403  {
404  return StatImpl<false>( file, std::move( force ) );
405  }
406 
407  //----------------------------------------------------------------------------
409  //----------------------------------------------------------------------------
410  template<bool HasHndl>
411  class WriteImpl: public FileOperation<WriteImpl, HasHndl, Resp<void>, Arg<uint64_t>,
412  Arg<uint32_t>, Arg<void*>>
413  {
414  public:
415 
416  //------------------------------------------------------------------------
418  //------------------------------------------------------------------------
421 
422  //------------------------------------------------------------------------
424  //------------------------------------------------------------------------
426 
427  //------------------------------------------------------------------------
429  //------------------------------------------------------------------------
430  std::string ToString()
431  {
432  return "Write";
433  }
434 
435  protected:
436 
437  //------------------------------------------------------------------------
443  //------------------------------------------------------------------------
445  {
446  try
447  {
448  uint64_t offset = std::get<OffsetArg>( this->args ).Get();
449  uint32_t size = std::get<SizeArg>( this->args ).Get();
450  void *buffer = std::get<BufferArg>( this->args ).Get();
451  return this->file->Write( offset, size, buffer, this->handler.get() );
452  }
453  catch( const PipelineException& ex )
454  {
455  return ex.GetError();
456  }
457  catch( const std::exception& ex )
458  {
459  return XRootDStatus( stError, ex.what() );
460  }
461  }
462  };
464 
465  //----------------------------------------------------------------------------
467  //----------------------------------------------------------------------------
468  template<bool HasHndl>
469  class SyncImpl: public FileOperation<SyncImpl, HasHndl, Resp<void>>
470  {
471  public:
472 
473  //------------------------------------------------------------------------
475  //------------------------------------------------------------------------
477 
478  //------------------------------------------------------------------------
480  //------------------------------------------------------------------------
481  std::string ToString()
482  {
483  return "Sync";
484  }
485 
486  protected:
487 
488  //------------------------------------------------------------------------
494  //------------------------------------------------------------------------
496  {
497  return this->file->Sync( this->handler.get() );
498  }
499  };
501 
502  //----------------------------------------------------------------------------
504  //----------------------------------------------------------------------------
505  template<bool HasHndl>
506  class TruncateImpl: public FileOperation<TruncateImpl, HasHndl, Resp<void>, Arg<uint64_t>>
507  {
508  public:
509 
510  //------------------------------------------------------------------------
512  //------------------------------------------------------------------------
514 
515  //------------------------------------------------------------------------
517  //------------------------------------------------------------------------
518  enum { SizeArg };
519 
520  //------------------------------------------------------------------------
522  //------------------------------------------------------------------------
523  std::string ToString()
524  {
525  return "Truncate";
526  }
527 
528  protected:
529 
530  //------------------------------------------------------------------------
536  //------------------------------------------------------------------------
538  {
539  try
540  {
541  uint64_t size = std::get<SizeArg>( this->args ).Get();
542  return this->file->Truncate( size, this->handler.get() );
543  }
544  catch( const PipelineException& ex )
545  {
546  return ex.GetError();
547  }
548  catch( const std::exception& ex )
549  {
550  return XRootDStatus( stError, ex.what() );
551  }
552  }
553  };
554 
555  //----------------------------------------------------------------------------
558  //----------------------------------------------------------------------------
560  {
561  return TruncateImpl<false>( file, std::move( size ) );
562  }
563 
564  //----------------------------------------------------------------------------
567  //----------------------------------------------------------------------------
569  {
570  return TruncateImpl<false>( file, std::move( size ) );
571  }
572 
573  //----------------------------------------------------------------------------
575  //----------------------------------------------------------------------------
576  template<bool HasHndl>
577  class VectorReadImpl: public FileOperation<VectorReadImpl, HasHndl,
578  Resp<VectorReadInfo>, Arg<ChunkList>, Arg<void*>>
579  {
580  public:
581 
582  //------------------------------------------------------------------------
584  //------------------------------------------------------------------------
587 
588  //------------------------------------------------------------------------
590  //------------------------------------------------------------------------
591  enum { ChunksArg, BufferArg };
592 
593  //------------------------------------------------------------------------
595  //------------------------------------------------------------------------
596  std::string ToString()
597  {
598  return "VectorRead";
599  }
600 
601  protected:
602 
603  //------------------------------------------------------------------------
609  //------------------------------------------------------------------------
611  {
612  try
613  {
614  ChunkList chunks( std::get<ChunksArg>( this->args ).Get() );
615  void *buffer = std::get<BufferArg>( this->args ).Get();
616  return this->file->VectorRead( chunks, buffer, this->handler.get() );
617  }
618  catch( const PipelineException& ex )
619  {
620  return ex.GetError();
621  }
622  catch( const std::exception& ex )
623  {
624  return XRootDStatus( stError, ex.what() );
625  }
626  }
627  };
629 
630  //----------------------------------------------------------------------------
632  //----------------------------------------------------------------------------
633  template<bool HasHndl>
634  class VectorWriteImpl: public FileOperation<VectorWriteImpl, HasHndl, Resp<void>,
635  Arg<ChunkList>>
636  {
637  public:
638 
639  //------------------------------------------------------------------------
641  //------------------------------------------------------------------------
643 
644  //------------------------------------------------------------------------
646  //------------------------------------------------------------------------
647  enum { ChunksArg };
648 
649  //------------------------------------------------------------------------
651  //------------------------------------------------------------------------
652  std::string ToString()
653  {
654  return "VectorWrite";
655  }
656 
657  protected:
658 
659  //------------------------------------------------------------------------
665  //------------------------------------------------------------------------
667  {
668  try
669  {
670  const ChunkList chunks( std::get<ChunksArg>( this->args ).Get() );
671  return this->file->VectorWrite( chunks, this->handler.get() );
672  }
673  catch( const PipelineException& ex )
674  {
675  return ex.GetError();
676  }
677  catch( const std::exception& ex )
678  {
679  return XRootDStatus( stError, ex.what() );
680  }
681  }
682  };
684 
685  //----------------------------------------------------------------------------
687  //----------------------------------------------------------------------------
688  template<bool HasHndl>
689  class WriteVImpl: public FileOperation<WriteVImpl, HasHndl, Resp<void>, Arg<uint64_t>,
690  Arg<struct iovec*>, Arg<int>>
691  {
692  public:
693 
694  //------------------------------------------------------------------------
696  //------------------------------------------------------------------------
699 
700  //------------------------------------------------------------------------
702  //------------------------------------------------------------------------
704 
705  //------------------------------------------------------------------------
707  //------------------------------------------------------------------------
708  std::string ToString()
709  {
710  return "WriteV";
711  }
712 
713  protected:
714 
715  //------------------------------------------------------------------------
721  //------------------------------------------------------------------------
723  {
724  try
725  {
726  uint64_t offset = std::get<OffsetArg>( this->args ).Get();
727  const struct iovec *iov = std::get<IovArg>( this->args ).Get();
728  int iovcnt = std::get<IovcntArg>( this->args ).Get();
729  return this->file->WriteV( offset, iov, iovcnt, this->handler.get() );
730  }
731  catch( const PipelineException& ex )
732  {
733  return ex.GetError();
734  }
735  catch( const std::exception& ex )
736  {
737  return XRootDStatus( stError, ex.what() );
738  }
739  }
740  };
742 
743  //----------------------------------------------------------------------------
745  //----------------------------------------------------------------------------
746  template<bool HasHndl>
747  class FcntlImpl: public FileOperation<FcntlImpl, HasHndl, Resp<Buffer>, Arg<Buffer>>
748  {
749  public:
750 
751  //------------------------------------------------------------------------
753  //------------------------------------------------------------------------
755 
756  //------------------------------------------------------------------------
758  //------------------------------------------------------------------------
759  enum { BufferArg };
760 
761  //------------------------------------------------------------------------
763  //------------------------------------------------------------------------
764  std::string ToString()
765  {
766  return "Fcntl";
767  }
768 
769  protected:
770 
771  //------------------------------------------------------------------------
777  //------------------------------------------------------------------------
779  {
780  try
781  {
782  Buffer arg( std::get<BufferArg>( this->args ).Get() );
783  return this->file->Fcntl( arg, this->handler.get() );
784  }
785  catch( const PipelineException& ex )
786  {
787  return ex.GetError();
788  }
789  catch( const std::exception& ex )
790  {
791  return XRootDStatus( stError, ex.what() );
792  }
793  }
794  };
796 
797  //----------------------------------------------------------------------------
799  //----------------------------------------------------------------------------
800  template<bool HasHndl>
801  class VisaImpl: public FileOperation<VisaImpl, HasHndl, Resp<Buffer>>
802  {
803  public:
804 
805  //------------------------------------------------------------------------
807  //------------------------------------------------------------------------
809 
810  //------------------------------------------------------------------------
812  //------------------------------------------------------------------------
813  std::string ToString()
814  {
815  return "Visa";
816  }
817 
818  protected:
819 
820  //------------------------------------------------------------------------
826  //------------------------------------------------------------------------
828  {
829  return this->file->Visa( this->handler.get() );
830  }
831  };
833 
834  //----------------------------------------------------------------------------
836  //----------------------------------------------------------------------------
837  template<bool HasHndl>
838  class SetXAttrImpl: public FileOperation<SetXAttrImpl, HasHndl, Resp<void>,
839  Arg<std::string>, Arg<std::string>>
840  {
841  public:
842 
843  //------------------------------------------------------------------------
845  //------------------------------------------------------------------------
848 
849  //------------------------------------------------------------------------
851  //------------------------------------------------------------------------
852  enum { NameArg, ValueArg };
853 
854  //------------------------------------------------------------------------
856  //------------------------------------------------------------------------
857  std::string ToString()
858  {
859  return "SetXAttrImpl";
860  }
861 
862  protected:
863 
864  //------------------------------------------------------------------------
870  //------------------------------------------------------------------------
872  {
873  try
874  {
875  std::string name = std::get<NameArg>( this->args ).Get();
876  std::string value = std::get<ValueArg>( this->args ).Get();
877  // wrap the arguments with a vector
878  std::vector<xattr_t> attrs;
879  attrs.push_back( xattr_t( std::move( name ), std::move( value ) ) );
880  // wrap the PipelineHandler so the response gets unpacked properly
881  UnpackXAttrStatus *handler = new UnpackXAttrStatus( this->handler.get() );
882  XRootDStatus st = this->file->SetXAttr( attrs, handler );
883  if( !st.IsOK() ) delete handler;
884  return st;
885  }
886  catch( const PipelineException& ex )
887  {
888  return ex.GetError();
889  }
890  catch( const std::exception& ex )
891  {
892  return XRootDStatus( stError, ex.what() );
893  }
894  }
895  };
896 
897  //----------------------------------------------------------------------------
900  //----------------------------------------------------------------------------
902  {
903  return SetXAttrImpl<false>( file, std::move( name ), std::move( value ) );
904  }
905 
906  //----------------------------------------------------------------------------
909  //----------------------------------------------------------------------------
911  {
912  return SetXAttrImpl<false>( file, std::move( name ), std::move( value ) );
913  }
914 
915  //----------------------------------------------------------------------------
917  //----------------------------------------------------------------------------
918  template<bool HasHndl>
919  class SetXAttrBulkImpl: public FileOperation<SetXAttrBulkImpl, HasHndl,
920  Resp<std::vector<XAttrStatus>>, Arg<std::vector<xattr_t>>>
921  {
922  public:
923 
924  //------------------------------------------------------------------------
926  //------------------------------------------------------------------------
929 
930  //------------------------------------------------------------------------
932  //------------------------------------------------------------------------
933  enum { AttrsArg };
934 
935  //------------------------------------------------------------------------
937  //------------------------------------------------------------------------
938  std::string ToString()
939  {
940  return "SetXAttrBulkImpl";
941  }
942 
943 
944  protected:
945 
946  //------------------------------------------------------------------------
952  //------------------------------------------------------------------------
954  {
955  try
956  {
957  std::vector<xattr_t> attrs = std::get<AttrsArg>( this->args ).Get();
958  return this->file->SetXAttr( attrs, this->handler.get() );
959  }
960  catch( const PipelineException& ex )
961  {
962  return ex.GetError();
963  }
964  catch( const std::exception& ex )
965  {
966  return XRootDStatus( stError, ex.what() );
967  }
968  }
969  };
970 
971  //----------------------------------------------------------------------------
974  //----------------------------------------------------------------------------
975  inline SetXAttrBulkImpl<false> SetXAttr( File *file, Arg<std::vector<xattr_t>> attrs )
976  {
977  return SetXAttrBulkImpl<false>( file, std::move( attrs ) );
978  }
979 
980  //----------------------------------------------------------------------------
983  //----------------------------------------------------------------------------
984  inline SetXAttrBulkImpl<false> SetXAttr( File &file, Arg<std::vector<xattr_t>> attrs )
985  {
986  return SetXAttrBulkImpl<false>( file, std::move( attrs ) );
987  }
988 
989  //----------------------------------------------------------------------------
991  //----------------------------------------------------------------------------
992  template<bool HasHndl>
993  class GetXAttrImpl: public FileOperation<GetXAttrImpl, HasHndl, Resp<std::string>,
994  Arg<std::string>>
995  {
996  public:
997 
998  //------------------------------------------------------------------------
1000  //------------------------------------------------------------------------
1003 
1004  //------------------------------------------------------------------------
1006  //------------------------------------------------------------------------
1007  enum { NameArg };
1008 
1009  //------------------------------------------------------------------------
1011  //------------------------------------------------------------------------
1012  std::string ToString()
1013  {
1014  return "GetXAttrImpl";
1015  }
1016 
1017  protected:
1018 
1019  //------------------------------------------------------------------------
1025  //------------------------------------------------------------------------
1027  {
1028  try
1029  {
1030  std::string name = std::get<NameArg>( this->args ).Get();
1031  // wrap the argument with a vector
1032  std::vector<std::string> attrs;
1033  attrs.push_back( std::move( name ) );
1034  // wrap the PipelineHandler so the response gets unpacked properly
1035  UnpackXAttr *handler = new UnpackXAttr( this->handler.get() );
1036  XRootDStatus st = this->file->GetXAttr( attrs, handler );
1037  if( !st.IsOK() ) delete handler;
1038  return st;
1039  }
1040  catch( const PipelineException& ex )
1041  {
1042  return ex.GetError();
1043  }
1044  catch( const std::exception& ex )
1045  {
1046  return XRootDStatus( stError, ex.what() );
1047  }
1048  }
1049  };
1050 
1051  //----------------------------------------------------------------------------
1054  //----------------------------------------------------------------------------
1056  {
1057  return GetXAttrImpl<false>( file, std::move( name ) );
1058  }
1059 
1060  //----------------------------------------------------------------------------
1063  //----------------------------------------------------------------------------
1065  {
1066  return GetXAttrImpl<false>( file, std::move( name ) );
1067  }
1068 
1069  //----------------------------------------------------------------------------
1071  //----------------------------------------------------------------------------
1072  template<bool HasHndl>
1073  class GetXAttrBulkImpl: public FileOperation<GetXAttrBulkImpl, HasHndl, Resp<std::vector<XAttr>>,
1074  Arg<std::vector<std::string>>>
1075  {
1076  public:
1077 
1078  //------------------------------------------------------------------------
1080  //------------------------------------------------------------------------
1083 
1084  //------------------------------------------------------------------------
1086  //------------------------------------------------------------------------
1087  enum { NamesArg };
1088 
1089  //------------------------------------------------------------------------
1091  //------------------------------------------------------------------------
1092  std::string ToString()
1093  {
1094  return "GetXAttrBulkImpl";
1095  }
1096 
1097 
1098  protected:
1099 
1100  //------------------------------------------------------------------------
1106  //------------------------------------------------------------------------
1108  {
1109  try
1110  {
1111  std::vector<std::string> attrs = std::get<NamesArg>( this->args ).Get();
1112  return this->file->GetXAttr( attrs, this->handler.get() );
1113  }
1114  catch( const PipelineException& ex )
1115  {
1116  return ex.GetError();
1117  }
1118  catch( const std::exception& ex )
1119  {
1120  return XRootDStatus( stError, ex.what() );
1121  }
1122  }
1123  };
1124 
1125  //----------------------------------------------------------------------------
1128  //----------------------------------------------------------------------------
1129  inline GetXAttrBulkImpl<false> GetXAttr( File *file, Arg<std::vector<std::string>> attrs )
1130  {
1131  return GetXAttrBulkImpl<false>( file, std::move( attrs ) );
1132  }
1133 
1134  //----------------------------------------------------------------------------
1137  //----------------------------------------------------------------------------
1138  inline GetXAttrBulkImpl<false> GetXAttr( File &file, Arg<std::vector<std::string>> attrs )
1139  {
1140  return GetXAttrBulkImpl<false>( file, std::move( attrs ) );
1141  }
1142 
1143  //----------------------------------------------------------------------------
1145  //----------------------------------------------------------------------------
1146  template<bool HasHndl>
1147  class DelXAttrImpl: public FileOperation<DelXAttrImpl, HasHndl, Resp<void>,
1148  Arg<std::string>>
1149  {
1150  public:
1151 
1152  //------------------------------------------------------------------------
1154  //------------------------------------------------------------------------
1156 
1157  //------------------------------------------------------------------------
1159  //------------------------------------------------------------------------
1160  enum { NameArg };
1161 
1162  //------------------------------------------------------------------------
1164  //------------------------------------------------------------------------
1165  std::string ToString()
1166  {
1167  return "DelXAttrImpl";
1168  }
1169 
1170  protected:
1171 
1172  //------------------------------------------------------------------------
1178  //------------------------------------------------------------------------
1180  {
1181  try
1182  {
1183  std::string name = std::get<NameArg>( this->args ).Get();
1184  // wrap the argument with a vector
1185  std::vector<std::string> attrs;
1186  attrs.push_back( std::move( name ) );
1187  // wrap the PipelineHandler so the response gets unpacked properly
1188  UnpackXAttrStatus *handler = new UnpackXAttrStatus( this->handler.get() );
1189  XRootDStatus st = this->file->DelXAttr( attrs, handler );
1190  if( !st.IsOK() ) delete handler;
1191  return st;
1192  }
1193  catch( const PipelineException& ex )
1194  {
1195  return ex.GetError();
1196  }
1197  catch( const std::exception& ex )
1198  {
1199  return XRootDStatus( stError, ex.what() );
1200  }
1201  }
1202  };
1203 
1204  //----------------------------------------------------------------------------
1207  //----------------------------------------------------------------------------
1209  {
1210  return DelXAttrImpl<false>( file, std::move( name ) );
1211  }
1212 
1213  //----------------------------------------------------------------------------
1216  //----------------------------------------------------------------------------
1218  {
1219  return DelXAttrImpl<false>( file, std::move( name ) );
1220  }
1221 
1222  //----------------------------------------------------------------------------
1224  //----------------------------------------------------------------------------
1225  template<bool HasHndl>
1226  class DelXAttrBulkImpl: public FileOperation<DelXAttrBulkImpl, HasHndl,
1227  Resp<std::vector<XAttrStatus>>, Arg<std::vector<std::string>>>
1228  {
1229  public:
1230 
1231  //------------------------------------------------------------------------
1233  //------------------------------------------------------------------------
1236 
1237  //------------------------------------------------------------------------
1239  //------------------------------------------------------------------------
1240  enum { NamesArg };
1241 
1242  //------------------------------------------------------------------------
1244  //------------------------------------------------------------------------
1245  std::string ToString()
1246  {
1247  return "DelXAttrBulkImpl";
1248  }
1249 
1250 
1251  protected:
1252 
1253  //------------------------------------------------------------------------
1259  //------------------------------------------------------------------------
1261  {
1262  try
1263  {
1264  std::vector<std::string> attrs = std::get<NamesArg>( this->args ).Get();
1265  return this->file->DelXAttr( attrs, this->handler.get() );
1266  }
1267  catch( const PipelineException& ex )
1268  {
1269  return ex.GetError();
1270  }
1271  catch( const std::exception& ex )
1272  {
1273  return XRootDStatus( stError, ex.what() );
1274  }
1275  }
1276  };
1277 
1278  //----------------------------------------------------------------------------
1281  //----------------------------------------------------------------------------
1282  inline DelXAttrBulkImpl<false> DelXAttr( File *file, Arg<std::vector<std::string>> attrs )
1283  {
1284  return DelXAttrBulkImpl<false>( file, std::move( attrs ) );
1285  }
1286 
1287  //----------------------------------------------------------------------------
1290  //----------------------------------------------------------------------------
1291  inline DelXAttrBulkImpl<false> DelXAttr( File &file, Arg<std::vector<std::string>> attrs )
1292  {
1293  return DelXAttrBulkImpl<false>( file, std::move( attrs ) );
1294  }
1295 
1296  //----------------------------------------------------------------------------
1298  //----------------------------------------------------------------------------
1299  template<bool HasHndl>
1300  class ListXAttrImpl: public FileOperation<ListXAttrImpl, HasHndl,
1301  Resp<std::vector<XAttr>>>
1302  {
1303  public:
1304 
1305  //------------------------------------------------------------------------
1307  //------------------------------------------------------------------------
1309 
1310  //------------------------------------------------------------------------
1312  //------------------------------------------------------------------------
1313  std::string ToString()
1314  {
1315  return "ListXAttrImpl";
1316  }
1317 
1318 
1319  protected:
1320 
1321  //------------------------------------------------------------------------
1327  //------------------------------------------------------------------------
1329  {
1330  return this->file->ListXAttr( this->handler.get() );
1331  }
1332  };
1333 
1334  //----------------------------------------------------------------------------
1337  //----------------------------------------------------------------------------
1339  {
1340  return ListXAttrImpl<false>( file );
1341  }
1342 
1343  //----------------------------------------------------------------------------
1346  //----------------------------------------------------------------------------
1348  {
1349  return ListXAttrImpl<false>( file );
1350  }
1351 }
1352 
1353 #endif // __XRD_CL_FILE_OPERATIONS_HH__
1354 
XrdClOperationHandlers.hh
XrdCl::Resp
Definition: XrdClOperationHandlers.hh:648
XrdCl::WriteImpl
Write operation (.
Definition: XrdClFileOperations.hh:413
XrdCl::ResponseHandler
Handle an async response.
Definition: XrdClXRootDResponses.hh:975
XrdCl::TruncateImpl::SizeArg
@ SizeArg
Definition: XrdClFileOperations.hh:518
XrdCl::PipelineException::GetError
const XRootDStatus & GetError() const
Definition: XrdClOperationHandlers.hh:399
XrdCl::SetXAttrBulkImpl
SetXAttr bulk operation (.
Definition: XrdClFileOperations.hh:921
XrdCl::WriteV
WriteVImpl< false > WriteV
Definition: XrdClFileOperations.hh:741
XrdCl::WriteImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:444
XrdCl::FcntlImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:764
XrdCl::Open
OpenImpl< false > Open
Definition: XrdClFileOperations.hh:239
XrdCl::Close
CloseImpl< false > Close
Definition: XrdClFileOperations.hh:334
XrdCl::Access
Access mode.
Definition: XrdClFileSystem.hh:117
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:430
XrdCl::FileOperation::file
File * file
The file object itself.
Definition: XrdClFileOperations.hh:97
XrdCl::WriteVImpl::IovcntArg
@ IovcntArg
Definition: XrdClFileOperations.hh:703
XrdCl::DelXAttrImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:1165
XrdCl::FileOperation::~FileOperation
virtual ~FileOperation()
Destructor.
Definition: XrdClFileOperations.hh:87
XrdCl::GetXAttr
GetXAttrImpl< false > GetXAttr(File *file, Arg< std::string > name)
Definition: XrdClFileOperations.hh:1055
XrdCl::GetXAttrBulkImpl
GetXAttr bulk operation (.
Definition: XrdClFileOperations.hh:1075
XrdCl::ReadImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:278
XrdCl::TruncateImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:523
XrdCl::OpenImpl::operator>>
OpenImpl< true > operator>>(Hdlr &&hdlr)
Definition: XrdClFileOperations.hh:197
XrdCl::OpenImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:220
XrdCl::OpenImpl
Open operation (.
Definition: XrdClFileOperations.hh:106
XrdCl::VectorReadImpl
VectorRead operation (.
Definition: XrdClFileOperations.hh:579
XrdCl::SetXAttrImpl
SetXAttr operation (.
Definition: XrdClFileOperations.hh:840
XrdCl::StatImpl
Stat operation (.
Definition: XrdClFileOperations.hh:341
XrdCl::GetXAttrImpl
GetXAttr operation (.
Definition: XrdClFileOperations.hh:995
XrdCl::WriteVImpl::IovArg
@ IovArg
Definition: XrdClFileOperations.hh:703
XrdCl::File::SetXAttr
XRootDStatus SetXAttr(const std::vector< xattr_t > &attrs, ResponseHandler *handler, uint16_t timeout=0)
XrdCl::File::DelXAttr
XRootDStatus DelXAttr(const std::vector< std::string > &attrs, ResponseHandler *handler, uint16_t timeout=0)
XrdCl::Truncate
TruncateImpl< false > Truncate(File *file, Arg< uint64_t > size)
Definition: XrdClFileOperations.hh:559
XrdCl::GetXAttrBulkImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:1092
XrdCl::Arg< std::string >
Definition: XrdClArg.hh:286
XrdCl::Operation::handler
std::unique_ptr< PipelineHandler > handler
Operation handler.
Definition: XrdClOperations.hh:288
XrdCl::WriteVImpl
WriteV operation (.
Definition: XrdClFileOperations.hh:691
XrdCl::File
A file.
Definition: XrdClFile.hh:45
XrdCl::PipelineException
Pipeline exception, wrapps an XRootDStatus.
Definition: XrdClOperationHandlers.hh:360
XrdCl::GetXAttrImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:1012
XrdCl::OpenFlags
Open flags, may be or'd when appropriate.
Definition: XrdClFileSystem.hh:71
XrdCl::FileOperation::FileOperation
friend class FileOperation
Definition: XrdClFileOperations.hh:47
XrdCl::WriteImpl::OffsetArg
@ OffsetArg
Definition: XrdClFileOperations.hh:425
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:264
XrdCl::VisaImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:813
XrdCl::CloseImpl
Close operation (.
Definition: XrdClFileOperations.hh:304
XrdCl::FileOperation::FileOperation
FileOperation(File *f, Arguments... args)
Definition: XrdClFileOperations.hh:56
XrdCl::Access::Mode
Mode
Access mode.
Definition: XrdClFileSystem.hh:122
XrdCl::ConcreteOperation< Derived, HasHndl, Response, Arguments... >::args
std::tuple< Args... > args
Operation arguments.
Definition: XrdClOperations.hh:698
XrdCl::TruncateImpl
Truncate operation (.
Definition: XrdClFileOperations.hh:507
XrdCl::ConcreteOperation
Definition: XrdClOperations.hh:476
XrdCl::WriteImpl::BufferArg
@ BufferArg
Definition: XrdClFileOperations.hh:425
XrdCl::OpenImpl::UrlArg
@ UrlArg
Definition: XrdClFileOperations.hh:188
XrdCl::OpenImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:206
XrdCl::SetXAttrImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:857
XrdCl::CloseImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:315
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:802
open
#define open
Definition: XrdPosix.hh:71
XrdCl::File::GetXAttr
XRootDStatus GetXAttr(const std::vector< std::string > &attrs, ResponseHandler *handler, uint16_t timeout=0)
XrdCl::XRootDStatus
Request status.
Definition: XrdClXRootDResponses.hh:215
XrdCl::Fcntl
FcntlImpl< false > Fcntl
Definition: XrdClFileOperations.hh:795
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:904
XrdCl::OpenImpl::OpenImpl
OpenImpl(OpenImpl< from > &&open)
Definition: XrdClFileOperations.hh:178
XrdCl::SyncImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:481
XrdCl::CloseImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:329
XrdCl::Read
ReadImpl< false > Read
Definition: XrdClFileOperations.hh:297
XrdCl::ReadImpl
Read operation (.
Definition: XrdClFileOperations.hh:247
XrdCl::StatImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:371
XrdCl::FileOperation::FileOperation
FileOperation(File &f, Arguments... args)
Definition: XrdClFileOperations.hh:66
XrdCl::ReadImpl::BufferArg
@ BufferArg
Definition: XrdClFileOperations.hh:259
XrdCl::VectorWriteImpl
VectorWrite operation (.
Definition: XrdClFileOperations.hh:636
XrdCl::StatImpl::ForceArg
@ ForceArg
Definition: XrdClFileOperations.hh:352
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:495
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:596
XrdCl::Visa
VisaImpl< false > Visa
Definition: XrdClFileOperations.hh:832
XrdCl::File::ListXAttr
XRootDStatus ListXAttr(ResponseHandler *handler, uint16_t timeout=0)
XrdCl::SetXAttr
SetXAttrImpl< false > SetXAttr(File *file, Arg< std::string > name, Arg< std::string > value)
Definition: XrdClFileOperations.hh:901
XrdCl::WriteVImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:722
XrdCl::FileOperation
Definition: XrdClFileOperations.hh:45
XrdCl::ReadImpl::OffsetArg
@ OffsetArg
Definition: XrdClFileOperations.hh:259
XrdCl::GetXAttrImpl::NameArg
@ NameArg
Definition: XrdClFileOperations.hh:1007
XrdCl::UnpackXAttr
Helper class for unpacking single XAttr from bulk response.
Definition: XrdClOperationHandlers.hh:77
XrdCl::DelXAttrImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:1179
XrdCl::SetXAttrBulkImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:938
XrdCl::StatImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:357
XrdCl::Stat
StatImpl< false > Stat(File *file, Arg< bool > force)
Definition: XrdClFileOperations.hh:393
XrdCl::Status::IsOK
bool IsOK() const
We're fine.
Definition: XrdClStatus.hh:120
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:778
XrdCl::VectorRead
VectorReadImpl< false > VectorRead
Definition: XrdClFileOperations.hh:628
XrdCl::DelXAttrImpl::NameArg
@ NameArg
Definition: XrdClFileOperations.hh:1160
XrdCl::GetXAttrBulkImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:1107
XrdCl::ExOpenFuncWrapper
Lambda wrapper.
Definition: XrdClOperationHandlers.hh:317
XrdCl::DelXAttrBulkImpl::NamesArg
@ NamesArg
Definition: XrdClFileOperations.hh:1240
XrdCl::WriteVImpl::OffsetArg
@ OffsetArg
Definition: XrdClFileOperations.hh:703
XrdCl::Write
WriteImpl< false > Write
Definition: XrdClFileOperations.hh:463
XrdCl::SetXAttrImpl::ValueArg
@ ValueArg
Definition: XrdClFileOperations.hh:852
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::SetXAttrBulkImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:953
XrdCl
Definition: XrdClAnyObject.hh:26
XrdCl::VectorWriteImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:666
XrdCl::GetXAttrImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:1026
XrdCl::DelXAttr
DelXAttrImpl< false > DelXAttr(File *file, Arg< std::string > name)
Definition: XrdClFileOperations.hh:1208
XrdCl::FcntlImpl
Fcntl operation (.
Definition: XrdClFileOperations.hh:748
XrdCl::ListXAttrImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:1313
XrdCl::FileOperation::FileOperation
FileOperation(FileOperation< Derived, from, Response, Arguments... > &&op)
Definition: XrdClFileOperations.hh:78
XrdCl::WriteImpl::SizeArg
@ SizeArg
Definition: XrdClFileOperations.hh:425
XrdCl::VectorWriteImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:652
XrdCl::SetXAttrImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:871
XrdCl::VectorWrite
VectorWriteImpl< false > VectorWrite
Definition: XrdClFileOperations.hh:683
XrdCl::FcntlImpl::BufferArg
@ BufferArg
Definition: XrdClFileOperations.hh:759
XrdCl::File::WriteV
XRootDStatus WriteV(uint64_t offset, const struct iovec *iov, int iovcnt, ResponseHandler *handler, uint16_t timeout=0)
XrdCl::File::Stat
XRootDStatus Stat(bool force, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XrdCl::make_finalized
FinalizeHandler * make_finalized(ResponseHandler *handler)
Definition: XrdClOperationHandlers.hh:591
XrdCl::Access::None
@ None
Definition: XrdClFileSystem.hh:123
XrdCl::VectorWriteImpl::ChunksArg
@ ChunksArg
Definition: XrdClFileOperations.hh:647
XrdCl::Arg
Definition: XrdClArg.hh:224
XrdCl::ReadImpl::SizeArg
@ SizeArg
Definition: XrdClFileOperations.hh:259
XrdCl::DelXAttrBulkImpl
DelXAttr bulk operation (.
Definition: XrdClFileOperations.hh:1228
XrdCl::ListXAttrImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:1328
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:396
XrdCl::SyncImpl
Sync operation (.
Definition: XrdClFileOperations.hh:470
XrdCl::VectorReadImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:610
XrdCl::ListXAttr
ListXAttrImpl< false > ListXAttr(File *file)
Definition: XrdClFileOperations.hh:1338
XrdCl::SetXAttrImpl::NameArg
@ NameArg
Definition: XrdClFileOperations.hh:852
XrdCl::SetXAttrBulkImpl::AttrsArg
@ AttrsArg
Definition: XrdClFileOperations.hh:933
XrdCl::Buffer
Binary blob representation.
Definition: XrdClBuffer.hh:34
XrdCl::DelXAttrImpl
DelXAttr operation (.
Definition: XrdClFileOperations.hh:1149
XrdCl::Sync
SyncImpl< false > Sync
Definition: XrdClFileOperations.hh:500
XrdCl::ListXAttrImpl
ListXAttr bulk operation (.
Definition: XrdClFileOperations.hh:1302
XrdCl::DelXAttrBulkImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:1245
XrdCl::UnpackXAttrStatus
Helper class for unpacking single XAttrStatus from bulk response.
Definition: XrdClOperationHandlers.hh:41
XrdCl::TruncateImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:537
XrdCl::File::Fcntl
XRootDStatus Fcntl(const Buffer &arg, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XrdCl::VectorReadImpl::ChunksArg
@ ChunksArg
Definition: XrdClFileOperations.hh:591
XrdCl::GetXAttrBulkImpl::NamesArg
@ NamesArg
Definition: XrdClFileOperations.hh:1087
XrdCl::VisaImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:827
XrdCl::OpenFlags::Flags
Flags
Open flags, may be or'd when appropriate.
Definition: XrdClFileSystem.hh:76
XrdCl::xattr_t
std::tuple< std::string, std::string > xattr_t
Extended attribute key - value pair.
Definition: XrdClXRootDResponses.hh:285
XrdCl::DelXAttrBulkImpl::RunImpl
XRootDStatus RunImpl()
Definition: XrdClFileOperations.hh:1260
XrdCl::WriteVImpl::ToString
std::string ToString()
Definition: XrdClFileOperations.hh:708
XrdCl::VectorReadImpl::BufferArg
@ BufferArg
Definition: XrdClFileOperations.hh:591