XrdClZipOperations.hh

Go to the documentation of this file.

/*
 * XrdClZipOperations.hh
 *
 *  Created on: 26 Nov 2020
 *      Author: simonm
 */
 
#ifndef SRC_XRDCL_XRDCLZIPOPERATIONS_HH_
#define SRC_XRDCL_XRDCLZIPOPERATIONS_HH_
 
#include "XrdCl/XrdClZipArchive.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 ZipOperation: public ConcreteOperation<Derived, HasHndl, Response, Arguments...>
  {
 
      template<template<bool> class, bool, typename, typename ...> friend class ZipOperation;
 
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ZipOperation( Ctx<ZipArchive> zip, Arguments... args): ConcreteOperation<Derived, false, Response, Arguments...>( std::move( args )... ), zip( std::move( zip ) )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      template<bool from>
      ZipOperation( ZipOperation<Derived, from, Response, Arguments...> && op ) :
        ConcreteOperation<Derived, HasHndl, Response, Arguments...>( std::move( op ) ), zip( op.zip )
      {
 
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~ZipOperation()
      {
 
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Ctx<ZipArchive> zip;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class OpenArchiveImpl: public ZipOperation<OpenArchiveImpl, HasHndl, Resp<void>,
      Arg<std::string>, Arg<OpenFlags::Flags>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using ZipOperation<OpenArchiveImpl, HasHndl, Resp<void>, Arg<std::string>,
                          Arg<OpenFlags::Flags>>::ZipOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { UrlArg, FlagsArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "ZipOpen";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string      &url     = std::get<UrlArg>( this->args ).Get();
        OpenFlags::Flags  flags   = std::get<FlagsArg>( this->args ).Get();
        uint16_t          timeout = pipelineTimeout < this->timeout ?
                                   pipelineTimeout : this->timeout;
        return this->zip->OpenArchive( url, flags, handler, timeout );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline OpenArchiveImpl<false> OpenArchive( Ctx<ZipArchive> zip, Arg<std::string> fn,
      Arg<OpenFlags::Flags> flags, uint16_t timeout = 0 )
  {
    return OpenArchiveImpl<false>( std::move( zip ), std::move( fn ),
                                   std::move( flags ) ).Timeout( timeout );
  }
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class OpenFileImpl: public ZipOperation<OpenFileImpl, HasHndl, Resp<void>,
      Arg<std::string>, Arg<OpenFlags::Flags>, Arg<uint64_t>, Arg<uint32_t>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using ZipOperation<OpenFileImpl, HasHndl, Resp<void>, Arg<std::string>,
          Arg<OpenFlags::Flags>, Arg<uint64_t>, Arg<uint32_t>>::ZipOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { FnArg, FlagsArg, SizeArg, Crc32Arg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "ZipOpenFile";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string      &fn      = std::get<FnArg>( this->args ).Get();
        OpenFlags::Flags  flags   = std::get<FlagsArg>( this->args ).Get();
        uint64_t          size    = std::get<SizeArg>( this->args ).Get();
        uint32_t          crc32   = std::get<Crc32Arg>( this->args ).Get();
        XRootDStatus st = this->zip->OpenFile( fn, flags, size, crc32 );
        if( !st.IsOK() ) return st;
        handler->HandleResponse( new XRootDStatus(), nullptr );
        return XRootDStatus();
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline OpenFileImpl<false> OpenFile( Ctx<ZipArchive> zip, Arg<std::string> fn,
      Arg<OpenFlags::Flags> flags = OpenFlags::None, Arg<uint64_t> size = 0,
      Arg<uint32_t> crc32 = 0, uint16_t timeout = 0 )
  {
    return OpenFileImpl<false>( std::move( zip ), std::move( fn ), std::move( flags ),
        std::move( size ), std::move( crc32 ) ).Timeout( timeout );
  }
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class ZipReadImpl: public ZipOperation<ZipReadImpl, HasHndl, Resp<ChunkInfo>,
      Arg<uint64_t>, Arg<uint32_t>, Arg<void*>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using ZipOperation<ZipReadImpl, HasHndl, Resp<ChunkInfo>, Arg<uint64_t>,
          Arg<uint32_t>, Arg<void*>>::ZipOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { OffsetArg, SizeArg, BufferArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "ZipRead";
      }
 
    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->zip->Read( offset, size, buffer, handler, timeout );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline ZipReadImpl<false> Read( Ctx<ZipArchive> zip, Arg<uint64_t> offset, Arg<uint32_t> size,
                                  Arg<void*> buffer, uint16_t timeout = 0 )
  {
    return ZipReadImpl<false>( std::move( zip ), std::move( offset ), std::move( size ),
                               std::move( buffer ) ).Timeout( timeout );
  }
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class ZipReadFromImpl: public ZipOperation<ZipReadFromImpl, HasHndl, Resp<ChunkInfo>,
      Arg<std::string>, Arg<uint64_t>, Arg<uint32_t>, Arg<void*>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using ZipOperation<ZipReadFromImpl, HasHndl, Resp<ChunkInfo>, Arg<std::string>,
          Arg<uint64_t>, Arg<uint32_t>, Arg<void*>>::ZipOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { FileNameArg, OffsetArg, SizeArg, BufferArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "ZipReadFrom";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string &fn = std::get<FileNameArg>( this->args ).Get();
        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->zip->ReadFrom( fn, offset, size, buffer, handler, timeout );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline ZipReadFromImpl<false> ReadFrom( Ctx<ZipArchive> zip, Arg<std::string> fn,
                                  Arg<uint64_t> offset, Arg<uint32_t> size,
                                  Arg<void*> buffer, uint16_t timeout = 0 )
  {
    return ZipReadFromImpl<false>( std::move( zip ), std::move( fn ), std::move( offset ),
                                   std::move( size ), std::move( buffer ) ).Timeout( timeout );
  }
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class ZipWriteImpl: public ZipOperation<ZipWriteImpl, HasHndl, Resp<void>,
      Arg<uint32_t>, Arg<const void*>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using ZipOperation<ZipWriteImpl, HasHndl, Resp<void>, Arg<uint32_t>,
                         Arg<const void*>>::ZipOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { SizeArg, BufferArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "ZipWrite";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        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->zip->Write( size, buffer, handler, timeout );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline ZipWriteImpl<false> Write( Ctx<ZipArchive> zip, Arg<uint32_t> size, Arg<const void*> buffer,
                                    uint16_t timeout = 0 )
  {
    return ZipWriteImpl<false>( std::move( zip ), std::move( size ),
                                std::move( buffer ) ).Timeout( timeout );
  }
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class AppendFileImpl: public ZipOperation<AppendFileImpl, HasHndl, Resp<void>,
      Arg<std::string>, Arg<uint32_t>, Arg<uint32_t>, Arg<const void*>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using ZipOperation<AppendFileImpl, HasHndl, Resp<void>, Arg<std::string>,
          Arg<uint32_t>, Arg<uint32_t>, Arg<const void*>>::ZipOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { FnArg, CrcArg, SizeArg, BufferArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "AppendFile";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        std::string &fn      = std::get<FnArg>( this->args ).Get();
        uint32_t     crc32   = std::get<CrcArg>( 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->zip->AppendFile( fn, crc32, size, buffer, handler, timeout );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline AppendFileImpl<false> AppendFile( Ctx<ZipArchive> zip, Arg<std::string> fn,
                                           Arg<uint32_t> crc32, Arg<uint32_t> size,
                                           Arg<const void*> buffer, uint16_t timeout = 0 )
  {
    return AppendFileImpl<false>( std::move( zip ), std::move( fn ), std::move( crc32 ),
                                  std::move( size ), std::move( buffer ) ).Timeout( timeout );
  }
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class CloseFileImpl: public ZipOperation<CloseFileImpl, HasHndl, Resp<void>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using ZipOperation<CloseFileImpl, HasHndl, Resp<void>>::ZipOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "ZipCloseFile";
      }
 
    private:
 
      //------------------------------------------------------------------------
      // this is not an async operation so we don't need a handler
      //------------------------------------------------------------------------
      using ZipOperation<CloseFileImpl, HasHndl, Resp<void>>::operator>>;
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        XRootDStatus st = this->zip->CloseFile();
        if( !st.IsOK() ) return st;
        handler->HandleResponse( new XRootDStatus(), nullptr );
        return XRootDStatus();
      }
  };
  typedef CloseFileImpl<false> CloseFile;
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class ZipStatImpl: public ZipOperation<ZipStatImpl, HasHndl, Resp<StatInfo>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using ZipOperation<ZipStatImpl, HasHndl, Resp<StatInfo>>::ZipOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "ZipStat";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        StatInfo *info = nullptr;
        XRootDStatus st = this->zip->Stat( info );
        if( !st.IsOK() ) return st;
        AnyObject *rsp = new AnyObject();
        rsp->Set( info );
        handler->HandleResponse( new XRootDStatus(), rsp );
        return XRootDStatus();
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline ZipStatImpl<false> Stat( Ctx<ZipArchive> zip )
  {
    return ZipStatImpl<false>( std::move( zip ) );
  }
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class ZipListImpl: public ZipOperation<ZipListImpl, HasHndl, Resp<DirectoryList>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using ZipOperation<ZipListImpl, HasHndl, Resp<DirectoryList>>::ZipOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "ZipStat";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        DirectoryList *list = nullptr;
        XRootDStatus st = this->zip->List( list );
        if( !st.IsOK() ) return st;
        AnyObject *rsp = new AnyObject();
        rsp->Set( list );
        handler->HandleResponse( new XRootDStatus(), rsp );
        return XRootDStatus();
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline ZipListImpl<false> List( Ctx<ZipArchive> zip )
  {
    return ZipListImpl<false>( std::move( zip ) );
  }
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class CloseArchiveImpl: public ZipOperation<CloseArchiveImpl, HasHndl, Resp<void>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using ZipOperation<CloseArchiveImpl, HasHndl, Resp<void>>::ZipOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "ZipClose";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl( PipelineHandler *handler, uint16_t pipelineTimeout )
      {
        uint16_t timeout = pipelineTimeout < this->timeout ?
                           pipelineTimeout : this->timeout;
        return this->zip->CloseArchive( handler, timeout );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  inline CloseArchiveImpl<false> CloseArchive( Ctx<ZipArchive> zip, uint16_t timeout = 0 )
  {
    return CloseArchiveImpl<false>( std::move( zip ) ).Timeout( timeout );
  }
 
}
 
#endif /* SRC_XRDCL_XRDCLZIPOPERATIONS_HH_ */