xrootd
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
XrdClOperations.hh
Go to the documentation of this file.
1 //------------------------------------------------------------------------------
2 // Copyright (c) 2011-2017 by European Organization for Nuclear Research (CERN)
3 // Author: Krzysztof Jamrog <krzysztof.piotr.jamrog@cern.ch>,
4 // Michal Simon <michal.simon@cern.ch>
5 //------------------------------------------------------------------------------
6 // This file is part of the XRootD software suite.
7 //
8 // XRootD is free software: you can redistribute it and/or modify
9 // it under the terms of the GNU Lesser General Public License as published by
10 // the Free Software Foundation, either version 3 of the License, or
11 // (at your option) any later version.
12 //
13 // XRootD is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
17 //
18 // You should have received a copy of the GNU Lesser General Public License
19 // along with XRootD. If not, see <http://www.gnu.org/licenses/>.
20 //
21 // In applying this licence, CERN does not waive the privileges and immunities
22 // granted to it by virtue of its status as an Intergovernmental Organization
23 // or submit itself to any jurisdiction.
24 //------------------------------------------------------------------------------
25 
26 #ifndef __XRD_CL_OPERATIONS_HH__
27 #define __XRD_CL_OPERATIONS_HH__
28 
29 #include <memory>
30 #include <stdexcept>
31 #include <sstream>
32 #include <tuple>
33 #include <future>
36 #include "XrdCl/XrdClArg.hh"
39 #include "XrdSys/XrdSysPthread.hh"
40 
41 namespace XrdCl
42 {
43 
44  template<bool HasHndl> class Operation;
45 
46  class Pipeline;
47 
48 
49  //----------------------------------------------------------------------------
51  //----------------------------------------------------------------------------
52  typedef std::function<Operation<true>*(const XRootDStatus&)> rcvry_func;
53 
54  //----------------------------------------------------------------------------
57  //----------------------------------------------------------------------------
59  {
60  template<bool> friend class Operation;
61 
62  public:
63 
64  //------------------------------------------------------------------------
69  //------------------------------------------------------------------------
70  PipelineHandler( ResponseHandler *handler );
71 
72  //------------------------------------------------------------------------
74  //------------------------------------------------------------------------
76  {
77  }
78 
79  //------------------------------------------------------------------------
81  //------------------------------------------------------------------------
82  void HandleResponseWithHosts( XRootDStatus *status, AnyObject *response,
83  HostList *hostList );
84 
85  //------------------------------------------------------------------------
87  //------------------------------------------------------------------------
88  void HandleResponse( XRootDStatus *status, AnyObject *response );
89 
90  //------------------------------------------------------------------------
92  //------------------------------------------------------------------------
94  {
95  }
96 
97  //------------------------------------------------------------------------
101  //------------------------------------------------------------------------
102  void AddOperation( Operation<true> *operation );
103 
104  //------------------------------------------------------------------------
111  //------------------------------------------------------------------------
112  void Assign( const Timeout &timeout,
113  std::promise<XRootDStatus> prms,
114  std::function<void(const XRootDStatus&)> final,
115  Operation<true> *opr );
116 
117  //------------------------------------------------------------------------
119  //------------------------------------------------------------------------
120  void Assign( std::function<void(const XRootDStatus&)> final );
121 
122  private:
123 
124  //------------------------------------------------------------------------
126  //------------------------------------------------------------------------
127  void HandleResponseImpl( XRootDStatus *status, AnyObject *response,
128  HostList *hostList = nullptr );
129 
130  inline void dealloc( XRootDStatus *status, AnyObject *response,
131  HostList *hostList )
132  {
133  delete status;
134  delete response;
135  delete hostList;
136  }
137 
138  //------------------------------------------------------------------------
140  //------------------------------------------------------------------------
141  std::unique_ptr<ResponseHandler> responseHandler;
142 
143  //------------------------------------------------------------------------
145  //------------------------------------------------------------------------
146  std::unique_ptr<Operation<true>> currentOperation;
147 
148  //------------------------------------------------------------------------
150  //------------------------------------------------------------------------
151  std::unique_ptr<Operation<true>> nextOperation;
152 
153  //------------------------------------------------------------------------
155  //------------------------------------------------------------------------
157 
158  //------------------------------------------------------------------------
160  //------------------------------------------------------------------------
161  std::promise<XRootDStatus> prms;
162 
163  //------------------------------------------------------------------------
166  //------------------------------------------------------------------------
167  std::function<void(const XRootDStatus&)> final;
168  };
169 
170  //----------------------------------------------------------------------------
176  //----------------------------------------------------------------------------
177  template<bool HasHndl>
178  class Operation
179  {
180  // Declare friendship between templates
181  template<bool>
182  friend class Operation;
183 
184  friend std::future<XRootDStatus> Async( Pipeline, uint16_t );
185 
186  friend class Pipeline;
187  friend class PipelineHandler;
188 
189  public:
190 
191  //------------------------------------------------------------------------
193  //------------------------------------------------------------------------
194  Operation() : valid( true )
195  {
196  }
197 
198  //------------------------------------------------------------------------
200  //------------------------------------------------------------------------
201  template<bool from>
203  handler( std::move( op.handler ) ), valid( true )
204  {
205  if( !op.valid ) throw std::invalid_argument( "Cannot construct "
206  "Operation from an invalid Operation!" );
207  op.valid = false;
208  }
209 
210  //------------------------------------------------------------------------
212  //------------------------------------------------------------------------
213  virtual ~Operation()
214  {
215  }
216 
217  //------------------------------------------------------------------------
219  //------------------------------------------------------------------------
220  virtual std::string ToString() = 0;
221 
222  //------------------------------------------------------------------------
226  //------------------------------------------------------------------------
227  virtual Operation<HasHndl>* Move() = 0;
228 
229  //------------------------------------------------------------------------
234  //------------------------------------------------------------------------
235  virtual Operation<true>* ToHandled() = 0;
236 
237  protected:
238 
239  //------------------------------------------------------------------------
249  //------------------------------------------------------------------------
250  void Run( Timeout timeout,
251  std::promise<XRootDStatus> prms,
252  std::function<void(const XRootDStatus&)> final )
253  {
254  static_assert(HasHndl, "Only an operation that has a handler can be assigned to workflow");
255  handler->Assign( timeout, std::move( prms ), std::move( final ), this );
256 
257  PipelineHandler *h = handler.release();
258  XRootDStatus st;
259  try
260  {
261  st = RunImpl( h, timeout );
262  }
263  catch( const operation_expired& ex )
264  {
266  }
267  catch( const PipelineException& ex ) // probably not needed
268  {
269  st = ex.GetError();
270  }
271  catch( const std::exception& ex )
272  {
273  st = XRootDStatus( stError, errInternal, 0, ex.what() );
274  }
275 
276  if( !st.IsOK() )
277  h->HandleResponse( new XRootDStatus( st ), nullptr );
278  }
279 
280  //------------------------------------------------------------------------
287  //------------------------------------------------------------------------
288  virtual XRootDStatus RunImpl( PipelineHandler *handler, uint16_t timeout ) = 0;
289 
290  //------------------------------------------------------------------------
294  //------------------------------------------------------------------------
296  {
297  if( handler )
298  handler->AddOperation( op );
299  }
300 
301  //------------------------------------------------------------------------
303  //------------------------------------------------------------------------
304  std::unique_ptr<PipelineHandler> handler;
305 
306  //------------------------------------------------------------------------
308  //------------------------------------------------------------------------
309  bool valid;
310  };
311 
312  //----------------------------------------------------------------------------
318  //----------------------------------------------------------------------------
319  class Pipeline
320  {
321  template<bool> friend class ParallelOperation;
322  friend std::future<XRootDStatus> Async( Pipeline, uint16_t );
323  friend class PipelineHandler;
324 
325  public:
326 
327  //------------------------------------------------------------------------
329  //------------------------------------------------------------------------
331  {
332  }
333 
334  //------------------------------------------------------------------------
336  //------------------------------------------------------------------------
338  operation( op->Move() )
339  {
340  }
341 
342  //------------------------------------------------------------------------
344  //------------------------------------------------------------------------
346  operation( op.Move() )
347  {
348  }
349 
350  //------------------------------------------------------------------------
352  //------------------------------------------------------------------------
354  operation( op.Move() )
355  {
356  }
357 
359  operation( op->ToHandled() )
360  {
361  }
362 
363  //------------------------------------------------------------------------
365  //------------------------------------------------------------------------
367  operation( op.ToHandled() )
368  {
369  }
370 
371  //------------------------------------------------------------------------
373  //------------------------------------------------------------------------
375  operation( op.ToHandled() )
376  {
377  }
378 
379  Pipeline( Pipeline &&pipe ) :
380  operation( std::move( pipe.operation ) )
381  {
382  }
383 
384  //------------------------------------------------------------------------
386  //------------------------------------------------------------------------
388  {
389  operation = std::move( pipe.operation );
390  return *this;
391  }
392 
393  //------------------------------------------------------------------------
395  //------------------------------------------------------------------------
397  {
398  operation->AddOperation( op.Move() );
399  return *this;
400  }
401 
402  //------------------------------------------------------------------------
404  //------------------------------------------------------------------------
406  {
407  operation->AddOperation( op.ToHandled() );
408  return *this;
409  }
410 
411  //------------------------------------------------------------------------
415  //------------------------------------------------------------------------
416  operator Operation<true>&()
417  {
418  if( !bool( operation ) ) throw std::logic_error( "Invalid pipeline." );
419  return *operation.get();
420  }
421 
422  //------------------------------------------------------------------------
426  //------------------------------------------------------------------------
427  operator bool()
428  {
429  return bool( operation );
430  }
431 
432  //------------------------------------------------------------------------
436  //------------------------------------------------------------------------
437  static void Stop( const XRootDStatus &status = XrdCl::XRootDStatus() );
438 
439  //------------------------------------------------------------------------
441  //------------------------------------------------------------------------
442  static void Repeat();
443 
444  //------------------------------------------------------------------------
446  //------------------------------------------------------------------------
447  static void Replace( Operation<false> &&opr );
448 
449  //------------------------------------------------------------------------
451  //------------------------------------------------------------------------
452  static void Replace( Pipeline p );
453 
454  //------------------------------------------------------------------------
456  //------------------------------------------------------------------------
457  static void Ignore();
458 
459  private:
460 
461  //------------------------------------------------------------------------
466  //------------------------------------------------------------------------
468  {
469  return operation.get();
470  }
471 
472  //------------------------------------------------------------------------
477  //------------------------------------------------------------------------
478  void Run( Timeout timeout, std::function<void(const XRootDStatus&)> final = nullptr )
479  {
480  if( ftr.valid() )
481  throw std::logic_error( "Pipeline is already running!" );
482 
483  // a promise that the pipe will have a result
484  std::promise<XRootDStatus> prms;
485  ftr = prms.get_future();
486 
487  if( !operation ) std::logic_error( "Empty pipeline!" );
488 
489  Operation<true> *opr = operation.release();
490  opr->Run( timeout, std::move( prms ), std::move( final ) );
491  }
492 
493  //------------------------------------------------------------------------
495  //------------------------------------------------------------------------
496  std::unique_ptr<Operation<true>> operation;
497 
498  //------------------------------------------------------------------------
500  //------------------------------------------------------------------------
501  std::future<XRootDStatus> ftr;
502 
503  };
504 
505  //----------------------------------------------------------------------------
512  //----------------------------------------------------------------------------
513  inline std::future<XRootDStatus> Async( Pipeline pipeline, uint16_t timeout = 0 )
514  {
515  pipeline.Run( timeout );
516  return std::move( pipeline.ftr );
517  }
518 
519  //----------------------------------------------------------------------------
526  //----------------------------------------------------------------------------
527  inline XRootDStatus WaitFor( Pipeline pipeline, uint16_t timeout = 0 )
528  {
529  return Async( std::move( pipeline ), timeout ).get();
530  }
531 
532  //----------------------------------------------------------------------------
539  //----------------------------------------------------------------------------
540  template<template<bool> class Derived, bool HasHndl, typename HdlrFactory, typename ... Args>
541  class ConcreteOperation: public Operation<HasHndl>
542  {
543  template<template<bool> class, bool, typename, typename ...>
544  friend class ConcreteOperation;
545 
546  public:
547 
548  //------------------------------------------------------------------------
552  //------------------------------------------------------------------------
553  ConcreteOperation( Args&&... args ) : args( std::tuple<Args...>( std::move( args )... ) ),
554  timeout( 0 )
555  {
556  static_assert( !HasHndl, "It is only possible to construct operation without handler" );
557  }
558 
559  //------------------------------------------------------------------------
565  //------------------------------------------------------------------------
566  template<bool from>
568  Operation<HasHndl>( std::move( op ) ), args( std::move( op.args ) ), timeout( 0 )
569  {
570  }
571 
572  //------------------------------------------------------------------------
580  //------------------------------------------------------------------------
581  template<typename Hdlr>
582  Derived<true> operator>>( Hdlr &&hdlr )
583  {
584  return this->StreamImpl( HdlrFactory::Create( hdlr ) );
585  }
586 
587  //------------------------------------------------------------------------
593  //------------------------------------------------------------------------
594  Derived<true> operator|( Operation<true> &op )
595  {
596  return PipeImpl( *this, op );
597  }
598 
599  //------------------------------------------------------------------------
605  //------------------------------------------------------------------------
606  Derived<true> operator|( Operation<true> &&op )
607  {
608  return PipeImpl( *this, op );
609  }
610 
611  //------------------------------------------------------------------------
617  //------------------------------------------------------------------------
618  Derived<true> operator|( Operation<false> &op )
619  {
620  return PipeImpl( *this, op );
621  }
622 
623  //------------------------------------------------------------------------
629  //------------------------------------------------------------------------
630  Derived<true> operator|( Operation<false> &&op )
631  {
632  return PipeImpl( *this, op );
633  }
634 
635  //------------------------------------------------------------------------
637  //------------------------------------------------------------------------
638  Derived<true> operator|( FinalOperation &&fo )
639  {
640  AllocHandler( *this );
641  this->handler->Assign( fo.final );
642  return this->template Transform<true>();
643  }
644 
645  //------------------------------------------------------------------------
649  //------------------------------------------------------------------------
651  {
652  Derived<HasHndl> *me = static_cast<Derived<HasHndl>*>( this );
653  return new Derived<HasHndl>( std::move( *me ) );
654  }
655 
656  //------------------------------------------------------------------------
660  //------------------------------------------------------------------------
662  {
663  this->handler.reset( new PipelineHandler() );
664  Derived<HasHndl> *me = static_cast<Derived<HasHndl>*>( this );
665  return new Derived<true>( std::move( *me ) );
666  }
667 
668  //------------------------------------------------------------------------
670  //------------------------------------------------------------------------
671  Derived<HasHndl> Timeout( uint16_t timeout )
672  {
673  this->timeout = timeout;
674  Derived<HasHndl> *me = static_cast<Derived<HasHndl>*>( this );
675  return std::move( *me );
676  }
677 
678  protected:
679 
680  //------------------------------------------------------------------------
684  //------------------------------------------------------------------------
685  template<bool to>
686  inline Derived<to> Transform()
687  {
688  Derived<HasHndl> *me = static_cast<Derived<HasHndl>*>( this );
689  return Derived<to>( std::move( *me ) );
690  }
691 
692  //------------------------------------------------------------------------
698  //------------------------------------------------------------------------
699  inline Derived<true> StreamImpl( ResponseHandler *handler )
700  {
701  static_assert( !HasHndl, "Operator >> is available only for operation without handler" );
702  this->handler.reset( new PipelineHandler( handler ) );
703  return Transform<true>();
704  }
705 
706  //------------------------------------------------------------------------
707  // Allocate handler if necessary
708  //------------------------------------------------------------------------
709  inline static
711  {
712  // nothing to do
713  }
714 
715  //------------------------------------------------------------------------
716  // Allocate handler if necessary
717  //------------------------------------------------------------------------
718  inline static
720  {
721  me.handler.reset( new PipelineHandler() );
722  }
723 
724  //------------------------------------------------------------------------
731  //------------------------------------------------------------------------
732  inline static
733  Derived<true> PipeImpl( ConcreteOperation<Derived, HasHndl, HdlrFactory,
734  Args...> &me, Operation<true> &op )
735  {
736  AllocHandler( me ); // if HasHndl is false allocate handler
737  me.AddOperation( op.Move() );
738  return me.template Transform<true>();
739  }
740 
741  //------------------------------------------------------------------------
748  //------------------------------------------------------------------------
749  inline static
750  Derived<true> PipeImpl( ConcreteOperation<Derived, HasHndl, HdlrFactory,
751  Args...> &me, Operation<false> &op )
752  {
753  AllocHandler( me ); // if HasHndl is false allocate handler
754  me.AddOperation( op.ToHandled() );
755  return me.template Transform<true>();
756  }
757 
758  //------------------------------------------------------------------------
760  //------------------------------------------------------------------------
761  std::tuple<Args...> args;
762 
763  //------------------------------------------------------------------------
765  //------------------------------------------------------------------------
766  uint16_t timeout;
767  };
768 }
769 
770 #endif // __XRD_CL_OPERATIONS_HH__
std::unique_ptr< Operation< true > > operation
First operation in the pipeline.
Definition: XrdClOperations.hh:496
Definition: XrdClAnyObject.hh:32
Operation(Operation< from > &&op)
Move constructor between template instances.
Definition: XrdClOperations.hh:202
bool valid
Flag indicating if it is a valid object.
Definition: XrdClOperations.hh:309
Pipeline & operator|=(Operation< false > &&op)
Extend pipeline.
Definition: XrdClOperations.hh:405
friend std::future< XRootDStatus > Async(Pipeline, uint16_t)
Definition: XrdClOperations.hh:513
std::future< XRootDStatus > ftr
The future result of the pipeline.
Definition: XrdClOperations.hh:501
Pipeline(Operation< false > &&op)
Constructor.
Definition: XrdClOperations.hh:374
Definition: XrdClOperationTimeout.hh:19
ssize_t Move(KernelBuffer &kbuff, char *&ubuff)
Definition: XrdSysKernelBuffer.hh:452
Derived< true > operator|(Operation< true > &&op)
Definition: XrdClOperations.hh:606
Pipeline & operator=(Pipeline &&pipe)
Constructor.
Definition: XrdClOperations.hh:387
static void Repeat()
Repeat current operation.
Derived< true > operator|(Operation< true > &op)
Definition: XrdClOperations.hh:594
Derived< true > operator>>(Hdlr &&hdlr)
Definition: XrdClOperations.hh:582
uint16_t timeout
Operation timeout.
Definition: XrdClOperations.hh:766
Pipeline & operator|=(Operation< true > &&op)
Extend pipeline.
Definition: XrdClOperations.hh:396
Pipeline()
Default constructor.
Definition: XrdClOperations.hh:330
void HandleResponseImpl(XRootDStatus *status, AnyObject *response, HostList *hostList=nullptr)
Callback function implementation;.
void dealloc(XRootDStatus *status, AnyObject *response, HostList *hostList)
Definition: XrdClOperations.hh:130
Derived< true > operator|(FinalOperation &&fo)
Adds a final operation to the pipeline.
Definition: XrdClOperations.hh:638
void AddOperation(Operation< true > *op)
Definition: XrdClOperations.hh:295
ConcreteOperation(ConcreteOperation< Derived, from, HdlrFactory, Args...> &&op)
Definition: XrdClOperations.hh:567
Derived< true > StreamImpl(ResponseHandler *handler)
Definition: XrdClOperations.hh:699
const XRootDStatus & GetError() const
Definition: XrdClOperationHandlers.hh:396
Definition: XrdClFinalOperation.hh:39
Derived< HasHndl > Timeout(uint16_t timeout)
Set operation timeout.
Definition: XrdClOperations.hh:671
friend std::future< XRootDStatus > Async(Pipeline, uint16_t)
Definition: XrdClOperations.hh:513
~PipelineHandler()
Destructor.
Definition: XrdClOperations.hh:93
Definition: XrdClOperationTimeout.hh:17
std::future< XRootDStatus > Async(Pipeline pipeline, uint16_t timeout=0)
Definition: XrdClOperations.hh:513
Derived< true > operator|(Operation< false > &op)
Definition: XrdClOperations.hh:618
static void Replace(Operation< false > &&opr)
Replace current operation.
virtual ~Operation()
Destructor.
Definition: XrdClOperations.hh:213
Pipeline exception, wrapps an XRootDStatus.
Definition: XrdClOperationHandlers.hh:356
Pipeline(Operation< true > &&op)
Constructor.
Definition: XrdClOperations.hh:353
std::function< Operation< true > *(const XRootDStatus &)> rcvry_func
Type of the recovery function to be provided by the user.
Definition: XrdClOperations.hh:46
std::vector< HostInfo > HostList
Definition: XrdClXRootDResponses.hh:1111
void Run(Timeout timeout, std::function< void(const XRootDStatus &)> final=nullptr)
Definition: XrdClOperations.hh:478
Timeout timeout
Pipeline timeout.
Definition: XrdClOperations.hh:156
void HandleResponseWithHosts(XRootDStatus *status, AnyObject *response, HostList *hostList)
Callback function.
static void Ignore()
Ignore error and proceed with the pipeline.
friend class ConcreteOperation
Definition: XrdClOperations.hh:544
std::tuple< Args...> args
Operation arguments.
Definition: XrdClOperations.hh:761
Pipeline(Pipeline &&pipe)
Definition: XrdClOperations.hh:379
PipelineHandler()
Default Constructor.
Definition: XrdClOperations.hh:75
virtual std::string ToString()=0
Name of the operation.
std::unique_ptr< Operation< true > > nextOperation
Next operation in the pipeline.
Definition: XrdClOperations.hh:151
Pipeline(Operation< false > &op)
Constructor.
Definition: XrdClOperations.hh:366
const uint16_t stError
An error occurred that could potentially be retried.
Definition: XrdClStatus.hh:32
Request status.
Definition: XrdClXRootDResponses.hh:218
XRootDStatus WaitFor(Pipeline pipeline, uint16_t timeout=0)
Definition: XrdClOperations.hh:527
Definition: XrdClOperations.hh:44
const uint16_t errOperationExpired
Definition: XrdClStatus.hh:90
Operation()
Constructor.
Definition: XrdClOperations.hh:194
static Derived< true > PipeImpl(ConcreteOperation< Derived, HasHndl, HdlrFactory, Args...> &me, Operation< false > &op)
Definition: XrdClOperations.hh:750
static void AllocHandler(ConcreteOperation< Derived, true, HdlrFactory, Args...> &me)
Definition: XrdClOperations.hh:710
Definition: XrdClOperations.hh:58
static void AllocHandler(ConcreteOperation< Derived, false, HdlrFactory, Args...> &me)
Definition: XrdClOperations.hh:719
Operation< HasHndl > * Move()
Definition: XrdClOperations.hh:650
void HandleResponse(XRootDStatus *status, AnyObject *response)
Callback function.
Pipeline(Operation< true > &op)
Constructor.
Definition: XrdClOperations.hh:345
std::promise< XRootDStatus > prms
The promise that there will be a result (traveling along the pipeline)
Definition: XrdClOperations.hh:161
Handle an async response.
Definition: XrdClXRootDResponses.hh:1116
Operation< true > * operator->()
Definition: XrdClOperations.hh:467
std::unique_ptr< Operation< true > > currentOperation
The operation the handler is assigned to.
Definition: XrdClOperations.hh:146
Derived< to > Transform()
Definition: XrdClOperations.hh:686
void AddOperation(Operation< true > *operation)
Pipeline(Operation< false > *op)
Definition: XrdClOperations.hh:358
const uint16_t errInternal
Internal error.
Definition: XrdClStatus.hh:56
static Derived< true > PipeImpl(ConcreteOperation< Derived, HasHndl, HdlrFactory, Args...> &me, Operation< true > &op)
Definition: XrdClOperations.hh:733
virtual Operation< true > * ToHandled()=0
friend class PipelineHandler
Definition: XrdClOperations.hh:187
void Run(Timeout timeout, std::promise< XRootDStatus > prms, std::function< void(const XRootDStatus &)> final)
Definition: XrdClOperations.hh:250
virtual XRootDStatus RunImpl(PipelineHandler *handler, uint16_t timeout)=0
Operation< true > * ToHandled()
Definition: XrdClOperations.hh:661
static void Stop(const XRootDStatus &status=XrdCl::XRootDStatus())
ConcreteOperation(Args &&...args)
Definition: XrdClOperations.hh:553
Pipeline(Operation< true > *op)
Constructor.
Definition: XrdClOperations.hh:337
std::unique_ptr< ResponseHandler > responseHandler
The handler of our operation.
Definition: XrdClOperations.hh:141
bool IsOK() const
We&#39;re fine.
Definition: XrdClStatus.hh:123
Derived< true > operator|(Operation< false > &&op)
Definition: XrdClOperations.hh:630
Definition: XrdClOperations.hh:319
Definition: XrdClParallelOperation.hh:79
void Assign(const Timeout &timeout, std::promise< XRootDStatus > prms, std::function< void(const XRootDStatus &)> final, Operation< true > *opr)
virtual Operation< HasHndl > * Move()=0
std::unique_ptr< PipelineHandler > handler
Operation handler.
Definition: XrdClOperations.hh:304
Definition: XrdClOperations.hh:541