EIC code displayed by LXR master/​include/​xrootd/​private/​XrdCl/​XrdClFileOperations.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-19 10:10:59

 //------------------------------------------------------------------------------
 // Copyright (c) 2011-2017 by European Organization for Nuclear Research (CERN)
 // Author: Krzysztof Jamrog <krzysztof.piotr.jamrog@cern.ch>,
 //         Michal Simon <michal.simon@cern.ch>
 //------------------------------------------------------------------------------
 // This file is part of the XRootD software suite.
 //
 // XRootD is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Lesser General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
 // XRootD is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with XRootD.  If not, see <http://www.gnu.org/licenses/>.
 //
 // In applying this licence, CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 //------------------------------------------------------------------------------
 
 #ifndef __XRD_CL_FILE_OPERATIONS_HH__
 #define __XRD_CL_FILE_OPERATIONS_HH__
 
 #include "XrdCl/XrdClFile.hh"
 #include "XrdCl/XrdClOperations.hh"
 #include "XrdCl/XrdClOperationHandlers.hh"
 #include "XrdCl/XrdClCtx.hh"
 
 namespace XrdCl
 {
 
   //----------------------------------------------------------------------------
   //! Base class for all file related operations
   //!
   //! @arg Derived : the class that derives from this template (CRTP)
   //! @arg HasHndl : true if operation has a handler, false otherwise
   //! @arg Args    : operation arguments
   //----------------------------------------------------------------------------
   template<template<bool> class Derived, bool HasHndl, typename Response, typename ... Arguments>
   class FileOperation: public ConcreteOperation<Derived, HasHndl, Response, Arguments...>
   {
 
       template<template<bool> class, bool, typename, typename ...> friend class FileOperation;
 
     public:
       //------------------------------------------------------------------------
       //! Constructor
       //!
       //! @param f    : file on which the operation will be performed
       //! @param args : file operation arguments
       //------------------------------------------------------------------------
       FileOperation( Ctx<File> f, Arguments... args): ConcreteOperation<Derived, false, Response, Arguments...>( std::move( args )... ), file( std::move( f ) )
       {
       }
 
       //------------------------------------------------------------------------
       //! Move constructor from other states
       //!
       //! @arg from : state from which the object is being converted
       //!
       //! @param op : the object that is being converted
       //------------------------------------------------------------------------
       template<bool from>
       FileOperation( FileOperation<Derived, from, Response, Arguments...> && op ) :
         ConcreteOperation<Derived, HasHndl, Response, Arguments...>( std::move( op ) ), file( op.file )
       {
 
       }
 
       //------------------------------------------------------------------------
       //! Destructor
       //------------------------------------------------------------------------
       virtual ~FileOperation()
       {
 
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! The file object itself
       //------------------------------------------------------------------------
       Ctx<File> file;
   };
 
   //----------------------------------------------------------------------------
   //! Open operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class OpenImpl: public FileOperation<OpenImpl, HasHndl, Resp<void>, Arg<std::string>,
       Arg<OpenFlags::Flags>, Arg<Access::Mode>>
   {
       //------------------------------------------------------------------------
       //! Helper for extending the operator>> capabilities.
       //!
       //! In addition to standard overloads for std::function adds:
       //! - void( XRootDStatus&, StatInfo& )
       //! - void( XRootDStatus&, StatInfo&, OperationContext& )
       //------------------------------------------------------------------------
       struct ExResp : public Resp<void>
       {
           //--------------------------------------------------------------------
           //! Constructor
           //!
           //! @param file : the underlying XrdCl::File object
           //--------------------------------------------------------------------
           ExResp( const Ctx<File> &file ): file( file )
           {
           }
 
           //--------------------------------------------------------------------
           //! A factory method
           //!
           //! @param func : the function/functor/lambda that should be wrapped
           //! @return     : ResponseHandler instance
           //--------------------------------------------------------------------
           inline ResponseHandler* Create( std::function<void( XRootDStatus&,
               StatInfo& )> func )
           {
             return new ExOpenFuncWrapper( this->file, func );
           }
 
           //--------------------------------------------------------------------
           //! Make other overloads of Create visible
           //--------------------------------------------------------------------
           using Resp<void>::Create;
 
           //--------------------------------------------------------------------
           //! The underlying XrdCl::File object
           //--------------------------------------------------------------------
           Ctx<File> file;
       };
 
     public:
 
       //------------------------------------------------------------------------
       //! Constructor (@see FileOperation)
       //------------------------------------------------------------------------
       OpenImpl( Ctx<File> f, Arg<std::string> url, Arg<OpenFlags::Flags> flags,
                 Arg<Access::Mode> mode = Access::None ) :
           FileOperation<OpenImpl, HasHndl, Resp<void>, Arg<std::string>, Arg<OpenFlags::Flags>,
             Arg<Access::Mode>>( std::move( f ), std::move( url ), std::move( flags ),
             std::move( mode ) )
       {
       }
 
       //------------------------------------------------------------------------
       //! Move constructor from other states
       //!
       //! @arg from : state from which the object is being converted
       //!
       //! @param open : the object that is being converted
       //------------------------------------------------------------------------
       template<bool from>
       OpenImpl( OpenImpl<from> && open ) :
           FileOperation<OpenImpl, HasHndl, Resp<void>, Arg<std::string>, Arg<OpenFlags::Flags>,
             Arg<Access::Mode>>( std::move( open ) )
       {
       }
 
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { UrlArg, FlagsArg, ModeArg };
 
       //------------------------------------------------------------------------
       //! Overload of operator>> defined in ConcreteOperation, we're adding
       //! additional capabilities by using ExResp factory (@see ExResp).
       //!
       //! @param hdlr : function/functor/lambda
       //------------------------------------------------------------------------
       template<typename Hdlr>
       OpenImpl<true> operator>>( Hdlr &&hdlr )
       {
         ExResp factory( *this->file );
         return this->StreamImpl( factory.Create( hdlr ) );
       }
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "Open";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param pipelineTimeout : pipeline timeout
       //! @return                : status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         const std::string &url     = std::get<UrlArg>( this->args );
         OpenFlags::Flags   flags   = std::get<FlagsArg>( this->args );
         Access::Mode       mode    = std::get<ModeArg>( this->args );
         uint16_t           timeout = pipelineTimeout < this->timeout ?
                                      pipelineTimeout : this->timeout;
         return this->file->Open( url, flags, mode, handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating ReadImpl objects
   //----------------------------------------------------------------------------
   inline OpenImpl<false> Open( Ctx<File> file, Arg<std::string> url, Arg<OpenFlags::Flags> flags,
                                Arg<Access::Mode> mode = Access::None, uint16_t timeout = 0 )
   {
     return OpenImpl<false>( std::move( file ), std::move( url ), std::move( flags ),
                             std::move( mode ) ).Timeout( timeout );
   }
 
   //----------------------------------------------------------------------------
   //! Read operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class ReadImpl: public FileOperation<ReadImpl, HasHndl, Resp<ChunkInfo>,
       Arg<uint64_t>, Arg<uint32_t>, Arg<void*>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<ReadImpl, HasHndl, Resp<ChunkInfo>, Arg<uint64_t>,
                           Arg<uint32_t>, Arg<void*>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { OffsetArg, SizeArg, BufferArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "Read";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         uint64_t  offset  = std::get<OffsetArg>( this->args ).Get();
         uint32_t  size    = std::get<SizeArg>( this->args ).Get();
         void     *buffer  = std::get<BufferArg>( this->args ).Get();
         uint16_t  timeout = pipelineTimeout < this->timeout ?
                             pipelineTimeout : this->timeout;
         return this->file->Read( offset, size, buffer, handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating ReadImpl objects
   //----------------------------------------------------------------------------
   inline ReadImpl<false> Read( Ctx<File> file, Arg<uint64_t> offset, Arg<uint32_t> size,
                                Arg<void*> buffer, uint16_t timeout = 0 )
   {
     return ReadImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
                             std::move( buffer ) ).Timeout( timeout );
   }
 
   //----------------------------------------------------------------------------
   //! PgRead operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class PgReadImpl: public FileOperation<PgReadImpl, HasHndl, Resp<PageInfo>,
       Arg<uint64_t>, Arg<uint32_t>, Arg<void*>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<PgReadImpl, HasHndl, Resp<PageInfo>, Arg<uint64_t>,
                           Arg<uint32_t>, Arg<void*>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { OffsetArg, SizeArg, BufferArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "PgRead";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         uint64_t  offset  = std::get<OffsetArg>( this->args ).Get();
         uint32_t  size    = std::get<SizeArg>( this->args ).Get();
         void     *buffer  = std::get<BufferArg>( this->args ).Get();
         uint16_t  timeout = pipelineTimeout < this->timeout ?
                             pipelineTimeout : this->timeout;
         return this->file->PgRead( offset, size, buffer, handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating PgReadImpl objects
   //----------------------------------------------------------------------------
   inline PgReadImpl<false> PgRead( Ctx<File> file, Arg<uint64_t> offset,
                                  Arg<uint32_t> size, Arg<void*> buffer,
                                  uint16_t timeout = 0 )
   {
     return PgReadImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
                             std::move( buffer ) ).Timeout( timeout );
   }
 
   //----------------------------------------------------------------------------
   //! RdWithRsp: factory for creating ReadImpl/PgReadImpl objects
   //----------------------------------------------------------------------------
   template<typename RSP> struct ReadTrait { };
 
   template<> struct ReadTrait<ChunkInfo> { using RET = ReadImpl<false>; };
 
   template<> struct ReadTrait<PageInfo> { using RET = PgReadImpl<false>; };
 
   template<typename RSP> inline typename ReadTrait<RSP>::RET
   RdWithRsp( Ctx<File> file, Arg<uint64_t> offset, Arg<uint32_t> size,
              Arg<void*> buffer, uint16_t timeout = 0 );
 
   template<> inline ReadImpl<false>
   RdWithRsp<ChunkInfo>( Ctx<File> file, Arg<uint64_t> offset, Arg<uint32_t> size,
                         Arg<void*> buffer, uint16_t timeout )
   {
     return Read( std::move( file ), std::move( offset ), std::move( size ),
                  std::move( buffer ), timeout );
   }
 
   template<> inline PgReadImpl<false>
   RdWithRsp<PageInfo>( Ctx<File> file, Arg<uint64_t> offset, Arg<uint32_t> size,
                        Arg<void*> buffer, uint16_t timeout )
   {
     return PgRead( std::move( file ), std::move( offset ), std::move( size ),
                    std::move( buffer ), timeout );
   }
 
   //----------------------------------------------------------------------------
   //! PgWrite operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class PgWriteImpl: public FileOperation<PgWriteImpl, HasHndl, Resp<void>,
       Arg<uint64_t>, Arg<uint32_t>, Arg<void*>, Arg<std::vector<uint32_t>>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<PgWriteImpl, HasHndl, Resp<void>, Arg<uint64_t>,
                           Arg<uint32_t>, Arg<void*>, Arg<std::vector<uint32_t>>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { OffsetArg, SizeArg, BufferArg, CksumsArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "PgWrite";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         uint64_t               offset = std::get<OffsetArg>( this->args ).Get();
         uint32_t               size   = std::get<SizeArg>( this->args ).Get();
         void                  *buffer = std::get<BufferArg>( this->args ).Get();
         std::vector<uint32_t>  cksums = std::get<CksumsArg>( this->args ).Get();
         uint16_t  timeout = pipelineTimeout < this->timeout ?
                             pipelineTimeout : this->timeout;
         return this->file->PgWrite( offset, size, buffer, cksums, handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating PgReadImpl objects
   //----------------------------------------------------------------------------
   inline PgWriteImpl<false> PgWrite( Ctx<File> file, Arg<uint64_t> offset,
                                     Arg<uint32_t> size, Arg<void*> buffer,
                                     Arg<std::vector<uint32_t>> cksums,
                                     uint16_t timeout = 0 )
   {
     return PgWriteImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
                                std::move( buffer ), std::move( cksums ) ).Timeout( timeout );
   }
 
   //----------------------------------------------------------------------------
   //! Factory for creating PgReadImpl objects
   //----------------------------------------------------------------------------
   inline PgWriteImpl<false> PgWrite( Ctx<File> file, Arg<uint64_t> offset,
                                     Arg<uint32_t> size, Arg<void*> buffer,
                                     uint16_t timeout = 0 )
   {
     std::vector<uint32_t> cksums;
     return PgWriteImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
                                std::move( buffer ), std::move( cksums ) ).Timeout( timeout );
   }
 
   //----------------------------------------------------------------------------
   //! Close operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class CloseImpl: public FileOperation<CloseImpl, HasHndl, Resp<void>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<CloseImpl, HasHndl, Resp<void>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "Close";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         uint16_t timeout = pipelineTimeout < this->timeout ?
                            pipelineTimeout : this->timeout;
         return this->file->Close( handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating CloseImpl objects
   //----------------------------------------------------------------------------
   inline CloseImpl<false> Close( Ctx<File> file, uint16_t timeout = 0 )
   {
     return CloseImpl<false>( std::move( file ) ).Timeout( timeout );
   }
 
   //----------------------------------------------------------------------------
   //! Stat operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class StatImpl: public FileOperation<StatImpl, HasHndl, Resp<StatInfo>, Arg<bool>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<StatImpl, HasHndl, Resp<StatInfo>, Arg<bool>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { ForceArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "Stat";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         bool     force   = std::get<ForceArg>( this->args ).Get();
         uint16_t timeout = pipelineTimeout < this->timeout ?
                            pipelineTimeout : this->timeout;
         return this->file->Stat( force, handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating StatImpl objects (as there is another Stat in
   //! FileSystem there would be a clash of typenames).
   //----------------------------------------------------------------------------
   inline StatImpl<false> Stat( Ctx<File> file, Arg<bool> force, uint16_t timeout = 0 )
   {
     return StatImpl<false>( std::move( file ), std::move( force ) ).Timeout( timeout );
   }
 
   //----------------------------------------------------------------------------
   //! Write operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class WriteImpl: public FileOperation<WriteImpl, HasHndl, Resp<void>, Arg<uint64_t>,
       Arg<uint32_t>, Arg<const void*>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<WriteImpl, HasHndl, Resp<void>, Arg<uint64_t>, Arg<uint32_t>,
                           Arg<const void*>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { OffsetArg, SizeArg, BufferArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "Write";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         uint64_t    offset = std::get<OffsetArg>( this->args ).Get();
         uint32_t    size   = std::get<SizeArg>( this->args ).Get();
         const void *buffer = std::get<BufferArg>( this->args ).Get();
         uint16_t    timeout = pipelineTimeout < this->timeout ?
                             pipelineTimeout : this->timeout;
         return this->file->Write( offset, size, buffer, handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating WriteImpl objects
   //----------------------------------------------------------------------------
   inline WriteImpl<false> Write( Ctx<File> file, Arg<uint64_t> offset, Arg<uint32_t> size,
                                  Arg<const void*> buffer, uint16_t timeout = 0 )
   {
     return WriteImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
                              std::move( buffer ) ).Timeout( timeout );
   }
 
   //----------------------------------------------------------------------------
   //! Sync operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class SyncImpl: public FileOperation<SyncImpl, HasHndl, Resp<void>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<SyncImpl, HasHndl, Resp<void>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "Sync";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         uint16_t timeout = pipelineTimeout < this->timeout ?
                            pipelineTimeout : this->timeout;
         return this->file->Sync( handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating SyncImpl objects
   //----------------------------------------------------------------------------
   inline SyncImpl<false> Sync( Ctx<File> file, uint16_t timeout = 0 )
   {
     return SyncImpl<false>( std::move( file ) ).Timeout( timeout );
   }
 
   //----------------------------------------------------------------------------
   //! Truncate operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class TruncateImpl: public FileOperation<TruncateImpl, HasHndl, Resp<void>, Arg<uint64_t>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<TruncateImpl, HasHndl, Resp<void>, Arg<uint64_t>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { SizeArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "Truncate";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         uint64_t size    = std::get<SizeArg>( this->args ).Get();
         uint16_t timeout = pipelineTimeout < this->timeout ?
                            pipelineTimeout : this->timeout;
         return this->file->Truncate( size, handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating TruncateImpl objects (as there is another Stat in
   //! FileSystem there would be a clash of typenames).
   //----------------------------------------------------------------------------
   inline TruncateImpl<false> Truncate( Ctx<File> file, Arg<uint64_t> size, uint16_t timeout )
   {
     return TruncateImpl<false>( std::move( file ), std::move( size ) ).Timeout( timeout );
   }
 
   //----------------------------------------------------------------------------
   //! VectorRead operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class VectorReadImpl: public FileOperation<VectorReadImpl, HasHndl,
       Resp<VectorReadInfo>, Arg<ChunkList>, Arg<void*>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<VectorReadImpl, HasHndl, Resp<VectorReadInfo>, Arg<ChunkList>,
                           Arg<void*>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { ChunksArg, BufferArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "VectorRead";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         ChunkList &chunks  = std::get<ChunksArg>( this->args ).Get();
         void      *buffer  = std::get<BufferArg>( this->args ).Get();
         uint16_t   timeout = pipelineTimeout < this->timeout ?
                              pipelineTimeout : this->timeout;
         return this->file->VectorRead( chunks, buffer, handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating VectorReadImpl objects
   //----------------------------------------------------------------------------
   inline VectorReadImpl<false> VectorRead( Ctx<File> file, Arg<ChunkList> chunks,
                                            Arg<void*> buffer, uint16_t timeout = 0 )
   {
     return VectorReadImpl<false>( std::move( file ), std::move( chunks ), std::move( buffer ) ).Timeout( timeout );
   }
 
   inline VectorReadImpl<false> VectorRead( Ctx<File> file, Arg<ChunkList> chunks,
                                            uint16_t timeout = 0 )
   {
     return VectorReadImpl<false>( std::move( file ), std::move( chunks ), nullptr ).Timeout( timeout );
   }
 
   //----------------------------------------------------------------------------
   //! VectorWrite operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class VectorWriteImpl: public FileOperation<VectorWriteImpl, HasHndl, Resp<void>,
       Arg<ChunkList>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<VectorWriteImpl, HasHndl, Resp<void>, Arg<ChunkList>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { ChunksArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "VectorWrite";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         const ChunkList &chunks  = std::get<ChunksArg>( this->args ).Get();
         uint16_t         timeout = pipelineTimeout < this->timeout ?
                                    pipelineTimeout : this->timeout;
         return this->file->VectorWrite( chunks, handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating VectorWriteImpl objects
   //----------------------------------------------------------------------------
   inline VectorWriteImpl<false> VectorWrite( Ctx<File> file, Arg<ChunkList> chunks,
                                              uint16_t timeout = 0 )
   {
     return VectorWriteImpl<false>( std::move( file ), std::move( chunks ) ).Timeout( timeout );
   }
 
   //----------------------------------------------------------------------------
   //! WriteV operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class WriteVImpl: public FileOperation<WriteVImpl, HasHndl, Resp<void>, Arg<uint64_t>,
                                          Arg<std::vector<iovec>>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<WriteVImpl, HasHndl, Resp<void>, Arg<uint64_t>,
                           Arg<std::vector<iovec>>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { OffsetArg, IovArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "WriteV";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         uint64_t            offset  = std::get<OffsetArg>( this->args ).Get();
         std::vector<iovec> &stdiov  = std::get<IovArg>( this->args ).Get();
         uint16_t            timeout = pipelineTimeout < this->timeout ?
                                       pipelineTimeout : this->timeout;
 
         int iovcnt = stdiov.size();
         iovec iov[iovcnt];
         for( size_t i = 0; i < stdiov.size(); ++i )
         {
           iov[i].iov_base = stdiov[i].iov_base;
           iov[i].iov_len  = stdiov[i].iov_len;
         }
 
         return this->file->WriteV( offset, iov, iovcnt, handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating WriteVImpl objects
   //----------------------------------------------------------------------------
   inline WriteVImpl<false> WriteV( Ctx<File> file, Arg<uint64_t> offset,
                                    Arg<std::vector<iovec>> iov, uint16_t timeout = 0 )
   {
     return WriteVImpl<false>( std::move( file ), std::move( offset ),
                               std::move( iov ) ).Timeout( timeout );
   }
 
   //----------------------------------------------------------------------------
   //! Fcntl operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class FcntlImpl: public FileOperation<FcntlImpl, HasHndl, Resp<Buffer>, Arg<Buffer>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<FcntlImpl, HasHndl, Resp<Buffer>, Arg<Buffer>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { BufferArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "Fcntl";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         Buffer   &arg     = std::get<BufferArg>( this->args ).Get();
         uint16_t  timeout = pipelineTimeout < this->timeout ?
                             pipelineTimeout : this->timeout;
         return this->file->Fcntl( arg, handler, timeout );
       }
   };
   typedef FcntlImpl<false> Fcntl;
 
   //----------------------------------------------------------------------------
   //! Visa operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class VisaImpl: public FileOperation<VisaImpl, HasHndl, Resp<Buffer>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<VisaImpl, HasHndl, Resp<Buffer>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "Visa";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         uint16_t timeout = pipelineTimeout < this->timeout ?
                            pipelineTimeout : this->timeout;
         return this->file->Visa( handler, timeout );
       }
   };
   typedef VisaImpl<false> Visa;
 
   //----------------------------------------------------------------------------
   //! SetXAttr operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class SetXAttrImpl: public FileOperation<SetXAttrImpl, HasHndl, Resp<void>,
       Arg<std::string>, Arg<std::string>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<SetXAttrImpl, HasHndl, Resp<void>,
                           Arg<std::string>, Arg<std::string>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { NameArg, ValueArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "SetXAttrImpl";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         std::string &name  = std::get<NameArg>( this->args ).Get();
         std::string &value = std::get<ValueArg>( this->args ).Get();
         // wrap the arguments with a vector
         std::vector<xattr_t> attrs;
         attrs.push_back( xattr_t( name, value ) );
         // wrap the PipelineHandler so the response gets unpacked properly
         UnpackXAttrStatus *h = new UnpackXAttrStatus( handler );
         uint16_t     timeout = pipelineTimeout < this->timeout ?
                                      pipelineTimeout : this->timeout;
         XRootDStatus st = this->file->SetXAttr( attrs, h, timeout );
         if( !st.IsOK() ) delete h;
         return st;
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating SetXAttrImpl objects (as there is another SetXAttr in
   //! FileSystem there would be a clash of typenames).
   //----------------------------------------------------------------------------
   inline SetXAttrImpl<false> SetXAttr( Ctx<File> file, Arg<std::string> name, Arg<std::string> value )
   {
     return SetXAttrImpl<false>( std::move( file ), std::move( name ), std::move( value ) );
   }
 
   //----------------------------------------------------------------------------
   //! SetXAttr bulk operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class SetXAttrBulkImpl: public FileOperation<SetXAttrBulkImpl, HasHndl,
       Resp<std::vector<XAttrStatus>>, Arg<std::vector<xattr_t>>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<SetXAttrBulkImpl, HasHndl, Resp<std::vector<XAttrStatus>>,
                           Arg<std::vector<xattr_t>>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { AttrsArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "SetXAttrBulkImpl";
       }
 
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         std::vector<xattr_t> &attrs   = std::get<AttrsArg>( this->args ).Get();
         uint16_t              timeout = pipelineTimeout < this->timeout ?
                                         pipelineTimeout : this->timeout;
         return this->file->SetXAttr( attrs, handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating SetXAttrBulkImpl objects (as there is another SetXAttr
   //! in FileSystem there would be a clash of typenames).
   //----------------------------------------------------------------------------
   inline SetXAttrBulkImpl<false> SetXAttr( Ctx<File> file, Arg<std::vector<xattr_t>> attrs )
   {
     return SetXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
   }
 
   //----------------------------------------------------------------------------
   //! GetXAttr operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class GetXAttrImpl: public FileOperation<GetXAttrImpl, HasHndl, Resp<std::string>,
       Arg<std::string>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<GetXAttrImpl, HasHndl, Resp<std::string>,
                           Arg<std::string>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { NameArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "GetXAttrImpl";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         std::string &name = std::get<NameArg>( this->args ).Get();
         // wrap the argument with a vector
         std::vector<std::string> attrs;
         attrs.push_back( name );
         // wrap the PipelineHandler so the response gets unpacked properly
         UnpackXAttr   *h = new UnpackXAttr( handler );
         uint16_t timeout = pipelineTimeout < this->timeout ?
                            pipelineTimeout : this->timeout;
         XRootDStatus st = this->file->GetXAttr( attrs, h, timeout );
         if( !st.IsOK() ) delete h;
         return st;
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating GetXAttrImpl objects (as there is another GetXAttr in
   //! FileSystem there would be a clash of typenames).
   //----------------------------------------------------------------------------
   inline GetXAttrImpl<false> GetXAttr( Ctx<File> file, Arg<std::string> name )
   {
     return GetXAttrImpl<false>( std::move( file ), std::move( name ) );
   }
 
   //----------------------------------------------------------------------------
   //! GetXAttr bulk operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class GetXAttrBulkImpl: public FileOperation<GetXAttrBulkImpl, HasHndl, Resp<std::vector<XAttr>>,
       Arg<std::vector<std::string>>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<GetXAttrBulkImpl, HasHndl, Resp<std::vector<XAttr>>,
                           Arg<std::vector<std::string>>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { NamesArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "GetXAttrBulkImpl";
       }
 
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         std::vector<std::string> &attrs   = std::get<NamesArg>( this->args ).Get();
         uint16_t                  timeout = pipelineTimeout < this->timeout ?
                                             pipelineTimeout : this->timeout;
         return this->file->GetXAttr( attrs, handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating GetXAttrBulkImpl objects (as there is another GetXAttr in
   //! FileSystem there would be a clash of typenames).
   //----------------------------------------------------------------------------
   inline GetXAttrBulkImpl<false> GetXAttr( Ctx<File> file, Arg<std::vector<std::string>> attrs )
   {
     return GetXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
   }
 
   //----------------------------------------------------------------------------
   //! DelXAttr operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class DelXAttrImpl: public FileOperation<DelXAttrImpl, HasHndl, Resp<void>,
       Arg<std::string>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<DelXAttrImpl, HasHndl, Resp<void>, Arg<std::string>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { NameArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "DelXAttrImpl";
       }
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         std::string &name = std::get<NameArg>( this->args ).Get();
         // wrap the argument with a vector
         std::vector<std::string> attrs;
         attrs.push_back( name );
         // wrap the PipelineHandler so the response gets unpacked properly
         UnpackXAttrStatus *h = new UnpackXAttrStatus( handler );
         uint16_t     timeout = pipelineTimeout < this->timeout ?
                                pipelineTimeout : this->timeout;
         XRootDStatus st = this->file->DelXAttr( attrs, h, timeout );
         if( !st.IsOK() ) delete h;
         return st;
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating DelXAttrImpl objects (as there is another DelXAttr in
   //! FileSystem there would be a clash of typenames).
   //----------------------------------------------------------------------------
   inline DelXAttrImpl<false> DelXAttr( Ctx<File> file, Arg<std::string> name )
   {
     return DelXAttrImpl<false>( std::move( file ), std::move( name ) );
   }
 
   //----------------------------------------------------------------------------
   //! DelXAttr bulk operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class DelXAttrBulkImpl: public FileOperation<DelXAttrBulkImpl, HasHndl,
       Resp<std::vector<XAttrStatus>>, Arg<std::vector<std::string>>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<DelXAttrBulkImpl, HasHndl, Resp<std::vector<XAttrStatus>>,
                           Arg<std::vector<std::string>>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! Argument indexes in the args tuple
       //------------------------------------------------------------------------
       enum { NamesArg };
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "DelXAttrBulkImpl";
       }
 
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         std::vector<std::string> &attrs   = std::get<NamesArg>( this->args ).Get();
         uint16_t                  timeout = pipelineTimeout < this->timeout ?
                                             pipelineTimeout : this->timeout;
         return this->file->DelXAttr( attrs, handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating DelXAttrBulkImpl objects (as there is another DelXAttr
   //! in FileSystem there would be a clash of typenames).
   //----------------------------------------------------------------------------
   inline DelXAttrBulkImpl<false> DelXAttr( Ctx<File> file, Arg<std::vector<std::string>> attrs )
   {
     return DelXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
   }
 
   //----------------------------------------------------------------------------
   //! ListXAttr bulk operation (@see FileOperation)
   //----------------------------------------------------------------------------
   template<bool HasHndl>
   class ListXAttrImpl: public FileOperation<ListXAttrImpl, HasHndl,
       Resp<std::vector<XAttr>>>
   {
     public:
 
       //------------------------------------------------------------------------
       //! Inherit constructors from FileOperation (@see FileOperation)
       //------------------------------------------------------------------------
       using FileOperation<ListXAttrImpl, HasHndl, Resp<std::vector<XAttr>>>::FileOperation;
 
       //------------------------------------------------------------------------
       //! @return : name of the operation (@see Operation)
       //------------------------------------------------------------------------
       std::string ToString()
       {
         return "ListXAttrImpl";
       }
 
 
     protected:
 
       //------------------------------------------------------------------------
       //! RunImpl operation (@see Operation)
       //!
       //! @param params :  container with parameters forwarded from
       //!                  previous operation
       //! @return       :  status of the operation
       //------------------------------------------------------------------------
       XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
       {
         uint16_t timeout = pipelineTimeout < this->timeout ?
                            pipelineTimeout : this->timeout;
         return this->file->ListXAttr( handler, timeout );
       }
   };
 
   //----------------------------------------------------------------------------
   //! Factory for creating ListXAttrImpl objects (as there is another ListXAttr
   //! in FileSystem there would be a clash of typenames).
   //----------------------------------------------------------------------------
   inline ListXAttrImpl<false> ListXAttr( Ctx<File> file )
   {
     return ListXAttrImpl<false>( std::move( file ) );
   }
 }
 
 #endif // __XRD_CL_FILE_OPERATIONS_HH__
 

This page was automatically generated by the 2.3.7 LXR engine. The LXR team