XrdClFileSystemOperations.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_SYSTEM_OPERATIONS_HH__
#define __XRD_CL_FILE_SYSTEM_OPERATIONS_HH__
 
#include "XrdCl/XrdClFileSystem.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 ... Args>
  class FileSystemOperation: public ConcreteOperation<Derived, HasHndl, Response, Args...>
  {
 
      template<template<bool> class, bool, typename, typename ...> friend class FileSystemOperation;
 
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      FileSystemOperation( Ctx<FileSystem> fs, Args... args): ConcreteOperation<Derived,
          false, Response, Args...>( std::move( args )... ), filesystem( std::move( fs ) )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      template<bool from>
      FileSystemOperation( FileSystemOperation<Derived, from, Response, Args...> && op ):
        ConcreteOperation<Derived, HasHndl, Response, Args...>( std::move( op ) ), filesystem( op.filesystem )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~FileSystemOperation()
      {
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Ctx<FileSystem> filesystem;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class LocateImpl: public FileSystemOperation<LocateImpl, HasHndl, Resp<LocationInfo>,
      Arg<std::string>, Arg<OpenFlags::Flags>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<LocateImpl, HasHndl, Resp<LocationInfo>, Arg<std::string>,
                                Arg<OpenFlags::Flags>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg, FlagsArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Locate";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
          std::string      &path    = std::get<PathArg>( this->args ).Get();
          OpenFlags::Flags  flags   = std::get<FlagsArg>( this->args ).Get();
          uint16_t          timeout = pipelineTimeout < this->timeout ?
                                      pipelineTimeout : this->timeout;
          return this->filesystem->Locate( path, flags, handler, timeout );
      }
  };
  typedef LocateImpl<false> Locate;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class DeepLocateImpl: public FileSystemOperation<DeepLocateImpl, HasHndl,
      Resp<LocationInfo>, Arg<std::string>, Arg<OpenFlags::Flags>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<DeepLocateImpl, HasHndl, Resp<LocationInfo>, Arg<std::string>,
                                Arg<OpenFlags::Flags>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg, FlagsArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "DeepLocate";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string      &path    = std::get<PathArg>( this->args ).Get();
        OpenFlags::Flags  flags   = std::get<FlagsArg>( this->args ).Get();
        uint16_t          timeout = pipelineTimeout < this->timeout ?
                                    pipelineTimeout : this->timeout;
        return this->filesystem->DeepLocate( path, flags, handler, timeout );
      }
  };
  typedef DeepLocateImpl<false> DeepLocate;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class MvImpl: public FileSystemOperation<MvImpl, HasHndl, Resp<void>, Arg<std::string>,
      Arg<std::string>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<MvImpl, HasHndl, Resp<void>, Arg<std::string>,
                                Arg<std::string>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { SourceArg, DestArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Mv";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string &source  = std::get<SourceArg>( this->args ).Get();
        std::string &dest    = std::get<DestArg>( this->args ).Get();
        uint16_t     timeout = pipelineTimeout < this->timeout ?
                               pipelineTimeout : this->timeout;
        return this->filesystem->Mv( source, dest, handler, timeout );
      }
  };
  typedef MvImpl<false> Mv;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class QueryImpl: public FileSystemOperation<QueryImpl, HasHndl, Resp<Buffer>,
      Arg<QueryCode::Code>, Arg<Buffer>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<QueryImpl, HasHndl, Resp<Buffer>, Arg<QueryCode::Code>,
                                Arg<Buffer>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { QueryCodeArg, BufferArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Query";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        QueryCode::Code  queryCode = std::get<QueryCodeArg>( this->args ).Get();
        const Buffer    &buffer( std::get<BufferArg>( this->args ).Get() );
        uint16_t         timeout = pipelineTimeout < this->timeout ?
                                   pipelineTimeout : this->timeout;
        return this->filesystem->Query( queryCode, buffer, handler, timeout );
      }
  };
  typedef QueryImpl<false> Query;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class TruncateFsImpl: public FileSystemOperation<TruncateFsImpl, HasHndl, Resp<void>,
      Arg<std::string>, Arg<uint64_t>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<TruncateFsImpl, HasHndl, Resp<void>, Arg<std::string>,
                                Arg<uint64_t>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg, SizeArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Truncate";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string &path    = std::get<PathArg>( this->args ).Get();
        uint64_t     size    = std::get<SizeArg>( this->args ).Get();
        uint16_t     timeout = pipelineTimeout < this->timeout ?
                               pipelineTimeout : this->timeout;
        return this->filesystem->Truncate( path, size, handler, timeout );
      }
  };
 
  inline TruncateFsImpl<false> Truncate( Ctx<FileSystem> fs, Arg<std::string> path, Arg<uint64_t> size )
  {
    return TruncateFsImpl<false>( std::move( fs ), std::move( path ), std::move( size ) );
  }
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class RmImpl: public FileSystemOperation<RmImpl, HasHndl, Resp<void>, Arg<std::string>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<RmImpl, HasHndl, Resp<void>, Arg<std::string>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Rm";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string &path    = std::get<PathArg>( this->args ).Get();
        uint16_t     timeout = pipelineTimeout < this->timeout ?
                              pipelineTimeout : this->timeout;
        return this->filesystem->Rm( path, handler, timeout );
      }
  };
  typedef RmImpl<false> Rm;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class MkDirImpl: public FileSystemOperation<MkDirImpl, HasHndl, Resp<void>,
      Arg<std::string>, Arg<MkDirFlags::Flags>, Arg<Access::Mode>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<MkDirImpl, HasHndl, Resp<void>, Arg<std::string>,
                                Arg<MkDirFlags::Flags>, Arg<Access::Mode>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg, FlagsArg, ModeArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "MkDir";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string       &path    = std::get<PathArg>( this->args ).Get();
        MkDirFlags::Flags  flags   = std::get<FlagsArg>( this->args ).Get();
        Access::Mode       mode    = std::get<ModeArg>( this->args ).Get();
        uint16_t           timeout = pipelineTimeout < this->timeout ?
                                     pipelineTimeout : this->timeout;
        return this->filesystem->MkDir( path, flags, mode, handler, timeout );
      }
  };
  typedef MkDirImpl<false> MkDir;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class RmDirImpl: public FileSystemOperation<RmDirImpl, HasHndl, Resp<void>,
      Arg<std::string>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<RmDirImpl, HasHndl, Resp<void>, Arg<std::string>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "RmDir";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string &path    = std::get<PathArg>( this->args ).Get();
        uint16_t     timeout = pipelineTimeout < this->timeout ?
                               pipelineTimeout : this->timeout;
        return this->filesystem->RmDir( path, handler, timeout );
      }
  };
  typedef RmDirImpl<false> RmDir;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class ChModImpl: public FileSystemOperation<ChModImpl, HasHndl, Resp<void>,
      Arg<std::string>, Arg<Access::Mode>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<ChModImpl, HasHndl, Resp<void>, Arg<std::string>,
                                Arg<Access::Mode>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg, ModeArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "ChMod";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string  &path    = std::get<PathArg>( this->args ).Get();
        Access::Mode  mode    = std::get<ModeArg>( this->args ).Get();
        uint16_t      timeout = pipelineTimeout < this->timeout ?
                                pipelineTimeout : this->timeout;
        return this->filesystem->ChMod( path, mode, handler, timeout );
      }
  };
  typedef ChModImpl<false> ChMod;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class PingImpl: public FileSystemOperation<PingImpl, HasHndl, Resp<void>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<PingImpl, HasHndl, Resp<void>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Ping";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        uint16_t timeout = pipelineTimeout < this->timeout ?
                           pipelineTimeout : this->timeout;
        return this->filesystem->Ping( handler, timeout );
      }
  };
  typedef PingImpl<false> Ping;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class StatFsImpl: public FileSystemOperation<StatFsImpl, HasHndl, Resp<StatInfo>,
      Arg<std::string>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<StatFsImpl, HasHndl, Resp<StatInfo>,
                                Arg<std::string>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Stat";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string &path    = std::get<PathArg>( this->args ).Get();
        uint16_t     timeout = pipelineTimeout < this->timeout ?
                               pipelineTimeout : this->timeout;
        return this->filesystem->Stat( path, handler, timeout );
      }
  };
 
  inline StatFsImpl<false> Stat( Ctx<FileSystem> fs, Arg<std::string> path )
  {
    return StatFsImpl<false>( std::move( fs ), std::move( path ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class StatVFSImpl: public FileSystemOperation<StatVFSImpl, HasHndl,
      Resp<StatInfoVFS>, Arg<std::string>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<StatVFSImpl, HasHndl, Resp<StatInfoVFS>,
                                Arg<std::string>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "StatVFS";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string &path    = std::get<PathArg>( this->args ).Get();
        uint16_t     timeout = pipelineTimeout < this->timeout ?
                               pipelineTimeout : this->timeout;
        return this->filesystem->StatVFS( path, handler, timeout );
      }
  };
  typedef StatVFSImpl<false> StatVFS;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class ProtocolImpl: public FileSystemOperation<ProtocolImpl, HasHndl,
      Resp<ProtocolInfo>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<ProtocolImpl, HasHndl, Resp<ProtocolInfo>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Protocol";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        uint16_t timeout = pipelineTimeout < this->timeout ?
                           pipelineTimeout : this->timeout;
        return this->filesystem->Protocol( handler, timeout );
      }
  };
  typedef ProtocolImpl<false> Protocol;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class DirListImpl: public FileSystemOperation<DirListImpl, HasHndl, Resp<DirectoryList>,
      Arg<std::string>, Arg<DirListFlags::Flags>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<DirListImpl, HasHndl, Resp<DirectoryList>, Arg<std::string>,
          Arg<DirListFlags::Flags>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg, FlagsArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "DirList";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string         &path    = std::get<PathArg>( this->args ).Get();
        DirListFlags::Flags  flags   = std::get<FlagsArg>( this->args ).Get();
        uint16_t             timeout = pipelineTimeout < this->timeout ?
                                       pipelineTimeout : this->timeout;
        return this->filesystem->DirList( path, flags, handler, timeout );
      }
  };
  typedef DirListImpl<false> DirList;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class SendInfoImpl: public FileSystemOperation<SendInfoImpl, HasHndl, Resp<Buffer>,
      Arg<std::string>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<SendInfoImpl, HasHndl, Resp<Buffer>,
                                Arg<std::string>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { InfoArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "SendInfo";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string &info    = std::get<InfoArg>( this->args ).Get();
        uint16_t     timeout = pipelineTimeout < this->timeout ?
                               pipelineTimeout : this->timeout;
        return this->filesystem->SendInfo( info, handler, timeout );
      }
  };
  typedef SendInfoImpl<false> SendInfo;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class PrepareImpl: public FileSystemOperation<PrepareImpl, HasHndl, Resp<Buffer>,
      Arg<std::vector<std::string>>, Arg<PrepareFlags::Flags>, Arg<uint8_t>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<PrepareImpl, HasHndl, Resp<Buffer>, Arg<std::vector<std::string>>,
                                Arg<PrepareFlags::Flags>, Arg<uint8_t>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { FileListArg, FlagsArg, PriorityArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Prepare";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::vector<std::string> &fileList = std::get<FileListArg>( this->args ).Get();
        PrepareFlags::Flags       flags    = std::get<FlagsArg>( this->args ).Get();
        uint8_t                   priority = std::get<PriorityArg>( this->args ).Get();
        uint16_t                  timeout  = pipelineTimeout < this->timeout ?
                                             pipelineTimeout : this->timeout;
        return this->filesystem->Prepare( fileList, flags, priority,
            handler, timeout );
      }
  };
  typedef PrepareImpl<false> Prepare;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class SetXAttrFsImpl: public FileSystemOperation<SetXAttrFsImpl, HasHndl, Resp<void>,
      Arg<std::string>, Arg<std::string>, Arg<std::string>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<SetXAttrFsImpl, HasHndl, Resp<void>, Arg<std::string>,
                                Arg<std::string>, Arg<std::string>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg, NameArg, ValueArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "SetXAttrFsImpl";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string &path  = std::get<PathArg>( this->args ).Get();
        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->filesystem->SetXAttr( path, attrs, h, timeout );
        if( !st.IsOK() ) delete h;
        return st;
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline SetXAttrFsImpl<false> SetXAttr( Ctx<FileSystem> fs, Arg<std::string> path,
      Arg<std::string> name, Arg<std::string> value )
  {
    return SetXAttrFsImpl<false>( std::move( fs ), std::move( path ), std::move( name ),
                                  std::move( value ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class SetXAttrFsBulkImpl: public FileSystemOperation<SetXAttrFsBulkImpl, HasHndl,
      Resp<std::vector<XAttrStatus>>, Arg<std::string>, Arg<std::vector<xattr_t>>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<SetXAttrFsBulkImpl, HasHndl, Resp<std::vector<XAttrStatus>>,
                          Arg<std::string>, Arg<std::vector<xattr_t>>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg, AttrsArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "SetXAttrBulkImpl";
      }
 
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string          &path    = std::get<PathArg>( this->args ).Get();
        std::vector<xattr_t> &attrs   = std::get<AttrsArg>( this->args ).Get();
        uint16_t              timeout = pipelineTimeout < this->timeout ?
                                        pipelineTimeout : this->timeout;
        return this->filesystem->SetXAttr( path, attrs, handler, timeout );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline SetXAttrFsBulkImpl<false> SetXAttr( Ctx<FileSystem> fs, Arg<std::string> path,
      Arg<std::vector<xattr_t>> attrs )
  {
    return SetXAttrFsBulkImpl<false>( std::move( fs ), std::move( path ), std::move( attrs ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class GetXAttrFsImpl: public FileSystemOperation<GetXAttrFsImpl, HasHndl, Resp<std::string>,
      Arg<std::string>, Arg<std::string>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<GetXAttrFsImpl, HasHndl, Resp<std::string>,
                                Arg<std::string>, Arg<std::string>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg, NameArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "GetXAttrFsImpl";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string &path = std::get<PathArg>( this->args ).Get();
        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->filesystem->GetXAttr( path, attrs, h, timeout );
        if( !st.IsOK() ) delete h;
        return st;
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline GetXAttrFsImpl<false> GetXAttr( Ctx<FileSystem> fs, Arg<std::string> path,
      Arg<std::string> name )
  {
    return GetXAttrFsImpl<false>( std::move( fs ), std::move( path ), std::move( name ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class GetXAttrFsBulkImpl: public FileSystemOperation<GetXAttrFsBulkImpl, HasHndl,
      Resp<std::vector<XAttr>>, Arg<std::string>, Arg<std::vector<std::string>>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<GetXAttrFsBulkImpl, HasHndl, Resp<std::vector<XAttr>>,
                                Arg<std::string>, Arg<std::vector<std::string>>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg, NamesArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "GetXAttrFsBulkImpl";
      }
 
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string              &path    = std::get<PathArg>( this->args ).Get();
        std::vector<std::string> &attrs   = std::get<NamesArg>( this->args ).Get();
        uint16_t                  timeout = pipelineTimeout < this->timeout ?
                                            pipelineTimeout : this->timeout;
        return this->filesystem->GetXAttr( path, attrs, handler, timeout );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline GetXAttrFsBulkImpl<false> GetXAttr( Ctx<FileSystem> fs, Arg<std::string> path,
                                             Arg<std::vector<std::string>> attrs )
  {
    return GetXAttrFsBulkImpl<false>( std::move( fs ), std::move( path ), std::move( attrs ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class DelXAttrFsImpl: public FileSystemOperation<DelXAttrFsImpl, HasHndl, Resp<void>,
      Arg<std::string>, Arg<std::string>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<DelXAttrFsImpl, HasHndl, Resp<void>, Arg<std::string>,
          Arg<std::string>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg, NameArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "DelXAttrFsImpl";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string &path = std::get<PathArg>( this->args ).Get();
        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->filesystem->DelXAttr( path, attrs, h, timeout );
        if( !st.IsOK() ) delete h;
        return st;
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline DelXAttrFsImpl<false> DelXAttr( Ctx<FileSystem> fs, Arg<std::string> path,
                                          Arg<std::string> name )
  {
    return DelXAttrFsImpl<false>( std::move( fs ), std::move( path ), std::move( name ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class DelXAttrFsBulkImpl: public FileSystemOperation<DelXAttrFsBulkImpl, HasHndl,
      Resp<std::vector<XAttrStatus>>, Arg<std::string>, Arg<std::vector<std::string>>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<DelXAttrFsBulkImpl, HasHndl, Resp<std::vector<XAttrStatus>>,
                      Arg<std::string>, Arg<std::vector<std::string>>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg, NamesArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "DelXAttrBulkImpl";
      }
 
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string              &path    = std::get<PathArg>( this->args ).Get();
        std::vector<std::string> &attrs   = std::get<NamesArg>( this->args ).Get();
        uint16_t                  timeout = pipelineTimeout < this->timeout ?
                                            pipelineTimeout : this->timeout;
        return this->filesystem->DelXAttr( path, attrs, handler, timeout );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline DelXAttrFsBulkImpl<false> DelXAttr( Ctx<FileSystem> fs, Arg<std::string> path,
      Arg<std::vector<std::string>> attrs )
  {
    return DelXAttrFsBulkImpl<false>( std::move( fs ), std::move( path ), std::move( attrs ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class ListXAttrFsImpl: public FileSystemOperation<ListXAttrFsImpl, HasHndl,
      Resp<std::vector<XAttr>>, Arg<std::string>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileSystemOperation<ListXAttrFsImpl, HasHndl, Resp<std::vector<XAttr>>,
                                Arg<std::string>>::FileSystemOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { PathArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "ListXAttrFsImpl";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string &path    = std::get<PathArg>( this->args ).Get();
        uint16_t     timeout = pipelineTimeout < this->timeout ?
                               pipelineTimeout : this->timeout;
        return this->filesystem->ListXAttr( path, handler, timeout );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline ListXAttrFsImpl<false> ListXAttr( Ctx<FileSystem> fs, Arg<std::string> path )
  {
    return ListXAttrFsImpl<false>( std::move( fs ), std::move( path ) );
  }
}
 
#endif // __XRD_CL_FILE_SYSTEM_OPERATIONS_HH__