XrdClOperationHandlers.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_OPERATION_HANDLERS_HH__
#define __XRD_CL_OPERATION_HANDLERS_HH__
 
#include "XrdCl/XrdClFile.hh"
 
namespace XrdCl
{
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Hdlr>
  struct IsResponseHandler
  {
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static constexpr bool value = std::is_base_of<XrdCl::ResponseHandler, Hdlr>::value;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Hdlr>
  struct IsResponseHandler<Hdlr*>
  {
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static constexpr bool value = std::is_base_of<XrdCl::ResponseHandler, Hdlr>::value;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class SimpleFunctionWrapper: public ResponseHandler
  {
    public:
 
      //------------------------------------------------------------------------
      //
      //------------------------------------------------------------------------
      SimpleFunctionWrapper(
          std::function<void( XRootDStatus& )> handleFunction ) :
          fun( handleFunction )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponse( XRootDStatus *status, AnyObject *response )
      {
        fun( *status );
        delete status;
        delete response;
        delete this;
      }
 
    private:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::function<void( XRootDStatus& )> fun;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename ResponseType>
  class FunctionWrapper: public ResponseHandler
  {
    public:
 
      //------------------------------------------------------------------------
      //
      //------------------------------------------------------------------------
      FunctionWrapper(
          std::function<void( XRootDStatus&, ResponseType& )> handleFunction ) :
          fun( handleFunction )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponse( XRootDStatus *status, AnyObject *response )
      {
        ResponseType *res = nullptr;
        if( status->IsOK() )
          response->Get( res );
        else
          res = &nullref;
        fun( *status, *res );
        delete status;
        delete response;
        delete this;
      }
 
    private:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::function<void( XRootDStatus&, ResponseType& )> fun;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static ResponseType nullref;
  };
 
  //----------------------------------------------------------------------------
  // Initialize the 'null-reference'
  //----------------------------------------------------------------------------
  template<typename ResponseType>
  ResponseType FunctionWrapper<ResponseType>::nullref;
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Response, typename Return>
  class TaskWrapper: public ResponseHandler
  {
    public:
 
      //------------------------------------------------------------------------
      //
      //------------------------------------------------------------------------
      TaskWrapper( std::packaged_task<Return( XRootDStatus&, Response& )> && task ) :
        task( std::move( task ) )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponse( XRootDStatus *status, AnyObject *response )
      {
        Response *resp = nullptr;
        if( status->IsOK() )
          response->Get( resp );
        else
          resp = &nullref;
        task( *status, *resp );
        delete status;
        delete response;
        delete this;
      }
 
    private:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::packaged_task<Return( XRootDStatus&, Response& )> task;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static Response nullref;
  };
 
  //----------------------------------------------------------------------------
  // Initialize the 'null-reference'
  //----------------------------------------------------------------------------
  template<typename Response, typename Return>
  Response TaskWrapper<Response, Return>::nullref;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Return>
  class TaskWrapper<void, Return>
  {
    public:
 
      //------------------------------------------------------------------------
      //
      //------------------------------------------------------------------------
      TaskWrapper( std::packaged_task<Return( XRootDStatus& )> && task ) :
        task( std::move( task ) )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponse( XRootDStatus *status, AnyObject *response )
      {
        task( *status );
        delete status;
        delete response;
        delete this;
      }
 
    private:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::packaged_task<Return( XRootDStatus& )> task;
  };
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class ExOpenFuncWrapper: public ResponseHandler
  {
    public:
 
      //------------------------------------------------------------------------
      //
      //------------------------------------------------------------------------
      ExOpenFuncWrapper( File &f,
          std::function<void( XRootDStatus&, StatInfo& )> handleFunction ) :
          f( f ), fun( handleFunction )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponse( XRootDStatus *status, AnyObject *response )
      {
        StatInfo *info = nullptr;
        if( status->IsOK() )
          XRootDStatus st = f.Stat( false, info );
        else
          info = &nullref;
        fun( *status, *info );
        if( info != &nullref ) delete info;
        delete status;
        delete response;
        delete this;
      }
 
    private:
      File &f;
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::function<void( XRootDStatus&, StatInfo& )> fun;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static StatInfo nullref;
  };
 
  //----------------------------------------------------------------------------
  // Initialize the 'null-reference'
  //----------------------------------------------------------------------------
  StatInfo ExOpenFuncWrapper::nullref;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class PipelineException : public std::exception
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      PipelineException( const XRootDStatus &error ) : error( error )
      {
 
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      PipelineException( const PipelineException &ex ) : error( ex.error )
      {
 
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      PipelineException& operator=( const PipelineException &ex )
      {
        error = ex.error;
        return *this;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const char* what() const noexcept
      {
        return error.ToString().c_str();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const XRootDStatus& GetError() const
      {
        return error;
      }
 
    private:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus error;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Response>
  class FutureWrapperBase : public ResponseHandler
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      FutureWrapperBase( std::future<Response> &ftr ) : called( false )
      {
        ftr = prms.get_future();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ~FutureWrapperBase()
      {
        if( !called )
          this->SetException( XRootDStatus( stError, errPipelineFailed ) );
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void SetException( const XRootDStatus &err )
      {
        std::exception_ptr ex = std::make_exception_ptr( PipelineException( err ) );
        prms.set_exception( ex );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::promise<Response> prms;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool called;
 
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Response>
  class FutureWrapper : public FutureWrapperBase<Response>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      FutureWrapper( std::future<Response> &ftr ) : FutureWrapperBase<Response>( ftr )
      {
 
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponse( XRootDStatus *status, AnyObject *response )
      {
        this->called = true;
 
        if( status->IsOK() )
        {
          Response *resp = 0;
          response->Get( resp );
          this->prms.set_value( std::move( *resp ) );
        }
        else
          this->SetException( *status );
 
        delete status;
        delete response;
        delete this;
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<>
  class FutureWrapper<void> : public FutureWrapperBase<void>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      FutureWrapper( std::future<void> &ftr ) : FutureWrapperBase<void>( ftr )
      {
 
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponse( XRootDStatus *status, AnyObject *response )
      {
        this->called = true;
 
 
        if( status->IsOK() )
        {
          prms.set_value();
        }
        else
          SetException( *status );
 
        delete status;
        delete response;
        delete this;
      }
  };
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Response>
  struct RespBase
  {
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline static ResponseHandler* Create( ResponseHandler *hdlr )
      {
        return hdlr;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline static ResponseHandler* Create( ResponseHandler &hdlr )
      {
        return &hdlr;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline static ResponseHandler* Create( std::future<Response> &ftr )
      {
        return new FutureWrapper<Response>( ftr );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Response>
  struct Resp: RespBase<Response>
  {
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline static ResponseHandler* Create( std::function<void( XRootDStatus&,
          Response& )> func )
      {
        return new FunctionWrapper<Response>( func );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      template<typename Return>
      inline static ResponseHandler* Create( std::packaged_task<Return( XRootDStatus&,
          Response& )> &task )
      {
        return new TaskWrapper<Response, Return>( std::move( task ) );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using RespBase<Response>::Create;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<>
  struct Resp<void>: RespBase<void>
  {
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline static ResponseHandler* Create( std::function<void( XRootDStatus& )> func )
      {
        return new SimpleFunctionWrapper( func );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      template<typename Return>
      inline static ResponseHandler* Create( std::packaged_task<Return( XRootDStatus& )> &task )
      {
        return new TaskWrapper<void, Return>( std::move( task ) );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using RespBase<void>::Create;
  };
}
 
#endif // __XRD_CL_OPERATIONS_HANDLERS_HH__