XrdClFileOperations.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// 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
{
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      FileOperation( Ctx<File> f, Arguments... args): ConcreteOperation<Derived, false, Response, Arguments...>( std::move( args )... ), file( std::move( f ) )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      template<bool from>
      FileOperation( FileOperation<Derived, from, Response, Arguments...> && op ) :
        ConcreteOperation<Derived, HasHndl, Response, Arguments...>( std::move( op ) ), file( op.file )
      {
 
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~FileOperation()
      {
 
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Ctx<File> file;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class OpenImpl: public FileOperation<OpenImpl, HasHndl, Resp<void>, Arg<std::string>,
      Arg<OpenFlags::Flags>, Arg<Access::Mode>>
  {
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      struct ExResp : public Resp<void>
      {
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          ExResp( const Ctx<File> &file ): file( file )
          {
          }
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          inline ResponseHandler* Create( std::function<void( XRootDStatus&,
              StatInfo& )> func )
          {
            return new ExOpenFuncWrapper( this->file, func );
          }
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          using Resp<void>::Create;
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          Ctx<File> file;
      };
 
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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 ) )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      template<bool from>
      OpenImpl( OpenImpl<from> && open ) :
          FileOperation<OpenImpl, HasHndl, Resp<void>, Arg<std::string>, Arg<OpenFlags::Flags>,
            Arg<Access::Mode>>( std::move( open ) )
      {
      }
 
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { UrlArg, FlagsArg, ModeArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      template<typename Hdlr>
      OpenImpl<true> operator>>( Hdlr &&hdlr )
      {
        ExResp factory( *this->file );
        return this->StreamImpl( factory.Create( hdlr ) );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Open";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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 );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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 );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class ReadImpl: public FileOperation<ReadImpl, HasHndl, Resp<ChunkInfo>,
      Arg<uint64_t>, Arg<uint32_t>, Arg<void*>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<ReadImpl, HasHndl, Resp<ChunkInfo>, Arg<uint64_t>,
                          Arg<uint32_t>, Arg<void*>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { OffsetArg, SizeArg, BufferArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Read";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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 );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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 );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class PgReadImpl: public FileOperation<PgReadImpl, HasHndl, Resp<PageInfo>,
      Arg<uint64_t>, Arg<uint32_t>, Arg<void*>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<PgReadImpl, HasHndl, Resp<PageInfo>, Arg<uint64_t>,
                          Arg<uint32_t>, Arg<void*>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { OffsetArg, SizeArg, BufferArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "PgRead";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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 );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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 );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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 );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<PgWriteImpl, HasHndl, Resp<void>, Arg<uint64_t>,
                          Arg<uint32_t>, Arg<void*>, Arg<std::vector<uint32_t>>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { OffsetArg, SizeArg, BufferArg, CksumsArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "PgWrite";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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 );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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 );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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 );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class CloseImpl: public FileOperation<CloseImpl, HasHndl, Resp<void>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<CloseImpl, HasHndl, Resp<void>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Close";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        uint16_t timeout = pipelineTimeout < this->timeout ?
                           pipelineTimeout : this->timeout;
        return this->file->Close( handler, timeout );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline CloseImpl<false> Close( Ctx<File> file, uint16_t timeout = 0 )
  {
    return CloseImpl<false>( std::move( file ) ).Timeout( timeout );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class StatImpl: public FileOperation<StatImpl, HasHndl, Resp<StatInfo>, Arg<bool>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<StatImpl, HasHndl, Resp<StatInfo>, Arg<bool>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { ForceArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Stat";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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 );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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 );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class WriteImpl: public FileOperation<WriteImpl, HasHndl, Resp<void>, Arg<uint64_t>,
      Arg<uint32_t>, Arg<const void*>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<WriteImpl, HasHndl, Resp<void>, Arg<uint64_t>, Arg<uint32_t>,
                          Arg<const void*>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { OffsetArg, SizeArg, BufferArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Write";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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 );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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 );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class SyncImpl: public FileOperation<SyncImpl, HasHndl, Resp<void>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<SyncImpl, HasHndl, Resp<void>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Sync";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        uint16_t timeout = pipelineTimeout < this->timeout ?
                           pipelineTimeout : this->timeout;
        return this->file->Sync( handler, timeout );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline SyncImpl<false> Sync( Ctx<File> file, uint16_t timeout = 0 )
  {
    return SyncImpl<false>( std::move( file ) ).Timeout( timeout );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class TruncateImpl: public FileOperation<TruncateImpl, HasHndl, Resp<void>, Arg<uint64_t>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<TruncateImpl, HasHndl, Resp<void>, Arg<uint64_t>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { SizeArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Truncate";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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 );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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 );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class VectorReadImpl: public FileOperation<VectorReadImpl, HasHndl,
      Resp<VectorReadInfo>, Arg<ChunkList>, Arg<void*>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<VectorReadImpl, HasHndl, Resp<VectorReadInfo>, Arg<ChunkList>,
                          Arg<void*>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { ChunksArg, BufferArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "VectorRead";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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 );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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 );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class VectorWriteImpl: public FileOperation<VectorWriteImpl, HasHndl, Resp<void>,
      Arg<ChunkList>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<VectorWriteImpl, HasHndl, Resp<void>, Arg<ChunkList>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { ChunksArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "VectorWrite";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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 );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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 );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class WriteVImpl: public FileOperation<WriteVImpl, HasHndl, Resp<void>, Arg<uint64_t>,
                                         Arg<std::vector<iovec>>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<WriteVImpl, HasHndl, Resp<void>, Arg<uint64_t>,
                          Arg<std::vector<iovec>>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { OffsetArg, IovArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "WriteV";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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 );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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 );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class FcntlImpl: public FileOperation<FcntlImpl, HasHndl, Resp<Buffer>, Arg<Buffer>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<FcntlImpl, HasHndl, Resp<Buffer>, Arg<Buffer>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { BufferArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Fcntl";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class VisaImpl: public FileOperation<VisaImpl, HasHndl, Resp<Buffer>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<VisaImpl, HasHndl, Resp<Buffer>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Visa";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class SetXAttrImpl: public FileOperation<SetXAttrImpl, HasHndl, Resp<void>,
      Arg<std::string>, Arg<std::string>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<SetXAttrImpl, HasHndl, Resp<void>,
                          Arg<std::string>, Arg<std::string>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { NameArg, ValueArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "SetXAttrImpl";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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;
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  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 ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class SetXAttrBulkImpl: public FileOperation<SetXAttrBulkImpl, HasHndl,
      Resp<std::vector<XAttrStatus>>, Arg<std::vector<xattr_t>>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<SetXAttrBulkImpl, HasHndl, Resp<std::vector<XAttrStatus>>,
                          Arg<std::vector<xattr_t>>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { AttrsArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "SetXAttrBulkImpl";
      }
 
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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 );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline SetXAttrBulkImpl<false> SetXAttr( Ctx<File> file, Arg<std::vector<xattr_t>> attrs )
  {
    return SetXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class GetXAttrImpl: public FileOperation<GetXAttrImpl, HasHndl, Resp<std::string>,
      Arg<std::string>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<GetXAttrImpl, HasHndl, Resp<std::string>,
                          Arg<std::string>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { NameArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "GetXAttrImpl";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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;
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline GetXAttrImpl<false> GetXAttr( Ctx<File> file, Arg<std::string> name )
  {
    return GetXAttrImpl<false>( std::move( file ), std::move( name ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class GetXAttrBulkImpl: public FileOperation<GetXAttrBulkImpl, HasHndl, Resp<std::vector<XAttr>>,
      Arg<std::vector<std::string>>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<GetXAttrBulkImpl, HasHndl, Resp<std::vector<XAttr>>,
                          Arg<std::vector<std::string>>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { NamesArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "GetXAttrBulkImpl";
      }
 
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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 );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline GetXAttrBulkImpl<false> GetXAttr( Ctx<File> file, Arg<std::vector<std::string>> attrs )
  {
    return GetXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class DelXAttrImpl: public FileOperation<DelXAttrImpl, HasHndl, Resp<void>,
      Arg<std::string>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<DelXAttrImpl, HasHndl, Resp<void>, Arg<std::string>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { NameArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "DelXAttrImpl";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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;
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline DelXAttrImpl<false> DelXAttr( Ctx<File> file, Arg<std::string> name )
  {
    return DelXAttrImpl<false>( std::move( file ), std::move( name ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class DelXAttrBulkImpl: public FileOperation<DelXAttrBulkImpl, HasHndl,
      Resp<std::vector<XAttrStatus>>, Arg<std::vector<std::string>>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<DelXAttrBulkImpl, HasHndl, Resp<std::vector<XAttrStatus>>,
                          Arg<std::vector<std::string>>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { NamesArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "DelXAttrBulkImpl";
      }
 
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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 );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline DelXAttrBulkImpl<false> DelXAttr( Ctx<File> file, Arg<std::vector<std::string>> attrs )
  {
    return DelXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class ListXAttrImpl: public FileOperation<ListXAttrImpl, HasHndl,
      Resp<std::vector<XAttr>>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<ListXAttrImpl, HasHndl, Resp<std::vector<XAttr>>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "ListXAttrImpl";
      }
 
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        uint16_t timeout = pipelineTimeout < this->timeout ?
                           pipelineTimeout : this->timeout;
        return this->file->ListXAttr( handler, timeout );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline ListXAttrImpl<false> ListXAttr( Ctx<File> file )
  {
    return ListXAttrImpl<false>( std::move( file ) );
  }
}
 
#endif // __XRD_CL_FILE_OPERATIONS_HH__