XRootD
XrdClArg.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_OPERATION_PARAMS_HH__
27 #define __XRD_CL_OPERATION_PARAMS_HH__
28 
29 #include "XrdCl/XrdClFwd.hh"
30 #include "XrdCl/XrdClOptional.hh"
31 
32 #include <future>
33 #include <string>
34 #include <sstream>
35 #include <unordered_map>
36 
37 namespace XrdCl
38 {
39 
40  //----------------------------------------------------------------------------
42  //----------------------------------------------------------------------------
43  template<typename T>
44  class ArgBase
45  {
46  public:
47 
48  //------------------------------------------------------------------------
50  //------------------------------------------------------------------------
52  {
53  }
54 
55  //------------------------------------------------------------------------
57  //------------------------------------------------------------------------
58  virtual ~ArgBase()
59  {
60  }
61 
62  //------------------------------------------------------------------------
66  //------------------------------------------------------------------------
67  ArgBase( T value ) : holder( new PlainValue( std::move( value ) ) )
68  {
69  }
70 
71  //------------------------------------------------------------------------
75  //------------------------------------------------------------------------
76  ArgBase( std::future<T> &&ftr ) : holder( new FutureValue( std::move( ftr ) ) )
77  {
78  }
79 
80  //------------------------------------------------------------------------
84  //------------------------------------------------------------------------
85  ArgBase( const Fwd<T> &fwd ) : holder( new FwdValue( fwd ) )
86  {
87  }
88 
89  //------------------------------------------------------------------------
91  //------------------------------------------------------------------------
92  ArgBase( ArgBase &&arg ) : holder( std::move( arg.holder ) )
93  {
94  }
95 
96  //------------------------------------------------------------------------
98  //------------------------------------------------------------------------
99  inline T& Get() const
100  {
101  if( !holder ) throw std::logic_error( "XrdCl::ArgBase::Get(): value not set." );
102  return holder->Get();
103  }
104 
105  operator T() const
106  {
107  return Get();
108  }
109 
110  protected:
111 
112  //------------------------------------------------------------------------
114  //------------------------------------------------------------------------
115  struct ValueHolder
116  {
117  //----------------------------------------------------------------------
119  //----------------------------------------------------------------------
120  virtual ~ValueHolder()
121  {
122  }
123 
124  //----------------------------------------------------------------------
126  //----------------------------------------------------------------------
127  virtual T& Get() = 0;
128  };
129 
130  //------------------------------------------------------------------------
132  //------------------------------------------------------------------------
133  struct PlainValue : public ValueHolder
134  {
135  //--------------------------------------------------------------------
139  //--------------------------------------------------------------------
140  PlainValue( T &&value ) : value( std::move( value ) )
141  {
142  }
143 
144  //--------------------------------------------------------------------
146  //--------------------------------------------------------------------
147  T& Get()
148  {
149  return value;
150  }
151 
152  private:
153  //--------------------------------------------------------------------
155  //--------------------------------------------------------------------
156  T value;
157  };
158 
159  //------------------------------------------------------------------------
161  //------------------------------------------------------------------------
162  struct FutureValue : public ValueHolder
163  {
164  //--------------------------------------------------------------------
168  //--------------------------------------------------------------------
169  FutureValue( std::future<T> &&ftr ) : ftr( std::move( ftr ) )
170  {
171  }
172 
173  //--------------------------------------------------------------------
175  //--------------------------------------------------------------------
176  T& Get()
177  {
178  if( val ) return *val;
179  val = ftr.get();
180  return *val;
181  }
182 
183  private:
184  //--------------------------------------------------------------------
186  //--------------------------------------------------------------------
187  std::future<T> ftr;
188  Optional<T> val;
189  };
190 
191  //------------------------------------------------------------------------
193  //------------------------------------------------------------------------
194  struct FwdValue : public ValueHolder
195  {
196  //--------------------------------------------------------------------
200  //--------------------------------------------------------------------
201  FwdValue( const Fwd<T> &fwd ) : fwd( fwd )
202  {
203  }
204 
205  //--------------------------------------------------------------------
207  //--------------------------------------------------------------------
208  T& Get()
209  {
210  return *fwd;
211  }
212 
213  private:
214  //--------------------------------------------------------------------
216  //--------------------------------------------------------------------
217  Fwd<T> fwd;
218  };
219 
220  //------------------------------------------------------------------------
222  //------------------------------------------------------------------------
223  std::unique_ptr<ValueHolder> holder;
224  };
225 
226  //----------------------------------------------------------------------------
231  //----------------------------------------------------------------------------
232  template<typename T>
233  class Arg : public ArgBase<T>
234  {
235  public:
236 
237  //------------------------------------------------------------------------
239  //------------------------------------------------------------------------
240  Arg()
241  {
242  }
243 
244  //------------------------------------------------------------------------
248  //------------------------------------------------------------------------
249  Arg( T value ) : ArgBase<T>( std::move( value ) )
250  {
251  }
252 
253  //------------------------------------------------------------------------
257  //------------------------------------------------------------------------
258  Arg( std::future<T> &&ftr ) : ArgBase<T>( std::move( ftr ) )
259  {
260  }
261 
262  //------------------------------------------------------------------------
266  //------------------------------------------------------------------------
267  Arg( const Fwd<T> &fwd ) : ArgBase<T>( fwd )
268  {
269  }
270 
271  //------------------------------------------------------------------------
273  //------------------------------------------------------------------------
274  Arg( Arg &&arg ) : ArgBase<T>( std::move( arg ) )
275  {
276  }
277 
278  //------------------------------------------------------------------------
280  //------------------------------------------------------------------------
281  Arg& operator=( Arg &&arg )
282  {
283  if( &arg == this ) return *this;
284  this->holder = std::move( arg.holder );
285  return *this;
286  }
287  };
288 
289  //----------------------------------------------------------------------------
293  //----------------------------------------------------------------------------
294  template<>
295  class Arg<std::string> : public ArgBase<std::string>
296  {
297  public:
298 
299  //------------------------------------------------------------------------
301  //------------------------------------------------------------------------
302  Arg()
303  {
304  }
305 
306  //------------------------------------------------------------------------
310  //------------------------------------------------------------------------
311  Arg( std::string str ) : ArgBase<std::string>( str )
312  {
313  }
314 
315  //------------------------------------------------------------------------
319  //------------------------------------------------------------------------
320  Arg( const char *cstr ) : ArgBase<std::string>( cstr )
321  {
322  }
323 
324  //------------------------------------------------------------------------
326  //------------------------------------------------------------------------
327  Arg( std::future<std::string> &&ftr ) : ArgBase<std::string>( std::move( ftr ) )
328  {
329  }
330 
331  //------------------------------------------------------------------------
333  //------------------------------------------------------------------------
334  Arg( const Fwd<std::string> &fwd ) : ArgBase<std::string>( fwd )
335  {
336  }
337 
338 
339  //------------------------------------------------------------------------
341  //-----------------------------------------------------------------------
342  Arg( Arg &&arg ) : ArgBase<std::string>( std::move( arg ) )
343  {
344  }
345 
346  //------------------------------------------------------------------------
348  //------------------------------------------------------------------------
349  Arg& operator=( Arg &&arg )
350  {
351  if( &arg == this ) return *this;
352  this->holder = std::move( arg.holder );
353  return *this;
354  }
355  };
356 }
357 
358 #endif // __XRD_CL_OPERATION_PARAMS_HH__
Base class for Arg.
Definition: XrdClArg.hh:45
ArgBase(ArgBase &&arg)
Get Constructor.
Definition: XrdClArg.hh:92
ArgBase()
Default Constructor.
Definition: XrdClArg.hh:51
T & Get() const
Definition: XrdClArg.hh:99
ArgBase(T value)
Definition: XrdClArg.hh:67
virtual ~ArgBase()
Destructor.
Definition: XrdClArg.hh:58
ArgBase(std::future< T > &&ftr)
Definition: XrdClArg.hh:76
std::unique_ptr< ValueHolder > holder
Holds the value of the argument.
Definition: XrdClArg.hh:223
ArgBase(const Fwd< T > &fwd)
Definition: XrdClArg.hh:85
Arg(Arg &&arg)
Get Constructor.
Definition: XrdClArg.hh:342
Arg(std::future< std::string > &&ftr)
Constructor.
Definition: XrdClArg.hh:327
Arg & operator=(Arg &&arg)
Get-Assignment.
Definition: XrdClArg.hh:349
Arg(std::string str)
Definition: XrdClArg.hh:311
Arg()
Default Constructor.
Definition: XrdClArg.hh:302
Arg(const char *cstr)
Definition: XrdClArg.hh:320
Arg(const Fwd< std::string > &fwd)
Constructor.
Definition: XrdClArg.hh:334
Arg()
Default Constructor.
Definition: XrdClArg.hh:240
Arg(std::future< T > &&ftr)
Definition: XrdClArg.hh:258
Arg(T value)
Definition: XrdClArg.hh:249
Arg(const Fwd< T > &fwd)
Definition: XrdClArg.hh:267
Arg(Arg &&arg)
Get Constructor.
Definition: XrdClArg.hh:274
Arg & operator=(Arg &&arg)
Get-Assignment.
Definition: XrdClArg.hh:281
A helper class for holding future value.
Definition: XrdClArg.hh:163
FutureValue(std::future< T > &&ftr)
Definition: XrdClArg.hh:169
A helper class for holding forwarded value.
Definition: XrdClArg.hh:195
FwdValue(const Fwd< T > &fwd)
Definition: XrdClArg.hh:201
A helper class for holding plain value.
Definition: XrdClArg.hh:134
Abstract class for holding a value.
Definition: XrdClArg.hh:116
virtual ~ValueHolder()
Virtual Destructor (important ;-).
Definition: XrdClArg.hh:120