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 <string>
33 #include <sstream>
34 #include <unordered_map>
35 
36 namespace XrdCl
37 {
38 
39  //----------------------------------------------------------------------------
41  //----------------------------------------------------------------------------
42  template<typename T>
43  class ArgBase
44  {
45  public:
46 
47  //------------------------------------------------------------------------
49  //------------------------------------------------------------------------
51  {
52  }
53 
54  //------------------------------------------------------------------------
56  //------------------------------------------------------------------------
57  virtual ~ArgBase()
58  {
59  }
60 
61  //------------------------------------------------------------------------
65  //------------------------------------------------------------------------
66  ArgBase( T value ) : holder( new PlainValue( std::move( value ) ) )
67  {
68  }
69 
70  //------------------------------------------------------------------------
74  //------------------------------------------------------------------------
75  ArgBase( std::future<T> &&ftr ) : holder( new FutureValue( std::move( ftr ) ) )
76  {
77  }
78 
79  //------------------------------------------------------------------------
83  //------------------------------------------------------------------------
84  ArgBase( const Fwd<T> &fwd ) : holder( new FwdValue( fwd ) )
85  {
86  }
87 
88  //------------------------------------------------------------------------
90  //------------------------------------------------------------------------
91  ArgBase( ArgBase &&arg ) : holder( std::move( arg.holder ) )
92  {
93  }
94 
95  //------------------------------------------------------------------------
97  //------------------------------------------------------------------------
98  inline T& Get() const
99  {
100  if( !holder ) throw std::logic_error( "XrdCl::ArgBase::Get(): value not set." );
101  return holder->Get();
102  }
103 
104  operator T() const
105  {
106  return Get();
107  }
108 
109  protected:
110 
111  //------------------------------------------------------------------------
113  //------------------------------------------------------------------------
114  struct ValueHolder
115  {
116  //----------------------------------------------------------------------
118  //----------------------------------------------------------------------
119  virtual ~ValueHolder()
120  {
121  }
122 
123  //----------------------------------------------------------------------
125  //----------------------------------------------------------------------
126  virtual T& Get() = 0;
127  };
128 
129  //------------------------------------------------------------------------
131  //------------------------------------------------------------------------
132  struct PlainValue : public ValueHolder
133  {
134  //--------------------------------------------------------------------
138  //--------------------------------------------------------------------
139  PlainValue( T &&value ) : value( std::move( value ) )
140  {
141  }
142 
143  //--------------------------------------------------------------------
145  //--------------------------------------------------------------------
146  T& Get()
147  {
148  return value;
149  }
150 
151  private:
152  //--------------------------------------------------------------------
154  //--------------------------------------------------------------------
155  T value;
156  };
157 
158  //------------------------------------------------------------------------
160  //------------------------------------------------------------------------
161  struct FutureValue : public ValueHolder
162  {
163  //--------------------------------------------------------------------
167  //--------------------------------------------------------------------
168  FutureValue( std::future<T> &&ftr ) : ftr( std::move( ftr ) )
169  {
170  }
171 
172  //--------------------------------------------------------------------
174  //--------------------------------------------------------------------
175  T& Get()
176  {
177  if( val ) return *val;
178  val = ftr.get();
179  return *val;
180  }
181 
182  private:
183  //--------------------------------------------------------------------
185  //--------------------------------------------------------------------
186  std::future<T> ftr;
188  };
189 
190  //------------------------------------------------------------------------
192  //------------------------------------------------------------------------
193  struct FwdValue : public ValueHolder
194  {
195  //--------------------------------------------------------------------
199  //--------------------------------------------------------------------
200  FwdValue( const Fwd<T> &fwd ) : fwd( fwd )
201  {
202  }
203 
204  //--------------------------------------------------------------------
206  //--------------------------------------------------------------------
207  T& Get()
208  {
209  return *fwd;
210  }
211 
212  private:
213  //--------------------------------------------------------------------
215  //--------------------------------------------------------------------
217  };
218 
219  //------------------------------------------------------------------------
221  //------------------------------------------------------------------------
222  std::unique_ptr<ValueHolder> holder;
223  };
224 
225  //----------------------------------------------------------------------------
230  //----------------------------------------------------------------------------
231  template<typename T>
232  class Arg : public ArgBase<T>
233  {
234  public:
235 
236  //------------------------------------------------------------------------
238  //------------------------------------------------------------------------
239  Arg()
240  {
241  }
242 
243  //------------------------------------------------------------------------
247  //------------------------------------------------------------------------
248  Arg( T value ) : ArgBase<T>( std::move( value ) )
249  {
250  }
251 
252  //------------------------------------------------------------------------
256  //------------------------------------------------------------------------
257  Arg( std::future<T> &&ftr ) : ArgBase<T>( std::move( ftr ) )
258  {
259  }
260 
261  //------------------------------------------------------------------------
265  //------------------------------------------------------------------------
266  Arg( const Fwd<T> &fwd ) : ArgBase<T>( fwd )
267  {
268  }
269 
270  //------------------------------------------------------------------------
272  //------------------------------------------------------------------------
273  Arg( Arg &&arg ) : ArgBase<T>( std::move( arg ) )
274  {
275  }
276 
277  //------------------------------------------------------------------------
279  //------------------------------------------------------------------------
280  Arg& operator=( Arg &&arg )
281  {
282  if( &arg == this ) return *this;
283  this->holder = std::move( arg.holder );
284  return *this;
285  }
286  };
287 
288  //----------------------------------------------------------------------------
292  //----------------------------------------------------------------------------
293  template<>
294  class Arg<std::string> : public ArgBase<std::string>
295  {
296  public:
297 
298  //------------------------------------------------------------------------
300  //------------------------------------------------------------------------
301  Arg()
302  {
303  }
304 
305  //------------------------------------------------------------------------
309  //------------------------------------------------------------------------
310  Arg( std::string str ) : ArgBase<std::string>( str )
311  {
312  }
313 
314  //------------------------------------------------------------------------
318  //------------------------------------------------------------------------
319  Arg( const char *cstr ) : ArgBase<std::string>( cstr )
320  {
321  }
322 
323  //------------------------------------------------------------------------
325  //------------------------------------------------------------------------
326  Arg( std::future<std::string> &&ftr ) : ArgBase<std::string>( std::move( ftr ) )
327  {
328  }
329 
330  //------------------------------------------------------------------------
332  //------------------------------------------------------------------------
333  Arg( const Fwd<std::string> &fwd ) : ArgBase<std::string>( fwd )
334  {
335  }
336 
337 
338  //------------------------------------------------------------------------
340  //-----------------------------------------------------------------------
341  Arg( Arg &&arg ) : ArgBase<std::string>( std::move( arg ) )
342  {
343  }
344 
345  //------------------------------------------------------------------------
347  //------------------------------------------------------------------------
348  Arg& operator=( Arg &&arg )
349  {
350  if( &arg == this ) return *this;
351  this->holder = std::move( arg.holder );
352  return *this;
353  }
354  };
355 }
356 
357 #endif // __XRD_CL_OPERATION_PARAMS_HH__
T value
the value
Definition: XrdClArg.hh:155
Arg(Arg &&arg)
Get Constructor.
Definition: XrdClArg.hh:341
Optional< T > val
Definition: XrdClArg.hh:187
ArgBase()
Default Constructor.
Definition: XrdClArg.hh:50
FwdValue(const Fwd< T > &fwd)
Definition: XrdClArg.hh:200
FutureValue(std::future< T > &&ftr)
Definition: XrdClArg.hh:168
T & Get()
Definition: XrdClArg.hh:175
Arg & operator=(Arg &&arg)
Get-Assignment.
Definition: XrdClArg.hh:280
Definition: XrdClOptional.hh:43
Arg()
Default Constructor.
Definition: XrdClArg.hh:301
Arg(std::string str)
Definition: XrdClArg.hh:310
ArgBase(ArgBase &&arg)
Get Constructor.
Definition: XrdClArg.hh:91
Arg & operator=(Arg &&arg)
Get-Assignment.
Definition: XrdClArg.hh:348
ArgBase(std::future< T > &&ftr)
Definition: XrdClArg.hh:75
Arg(Arg &&arg)
Get Constructor.
Definition: XrdClArg.hh:273
Arg(const Fwd< T > &fwd)
Definition: XrdClArg.hh:266
T & Get() const
Definition: XrdClArg.hh:98
Definition: XrdClArg.hh:232
Definition: XrdClAnyObject.hh:25
Arg(const char *cstr)
Definition: XrdClArg.hh:319
T & Get()
Definition: XrdClArg.hh:207
ArgBase(const Fwd< T > &fwd)
Definition: XrdClArg.hh:84
virtual ~ValueHolder()
Virtual Destructor (important ;-).
Definition: XrdClArg.hh:119
A helper class for holding forwarded value.
Definition: XrdClArg.hh:193
Arg()
Default Constructor.
Definition: XrdClArg.hh:239
ArgBase(T value)
Definition: XrdClArg.hh:66
PlainValue(T &&value)
Definition: XrdClArg.hh:139
Fwd< T > fwd
the forwarded value
Definition: XrdClArg.hh:216
std::unique_ptr< ValueHolder > holder
Holds the value of the argument.
Definition: XrdClArg.hh:222
std::future< T > ftr
the future value
Definition: XrdClArg.hh:186
virtual ~ArgBase()
Destructor.
Definition: XrdClArg.hh:57
Arg(const Fwd< std::string > &fwd)
Constructor.
Definition: XrdClArg.hh:333
Base class for Arg.
Definition: XrdClArg.hh:43
A helper class for holding future value.
Definition: XrdClArg.hh:161
Abstract class for holding a value.
Definition: XrdClArg.hh:114
A helper class for holding plain value.
Definition: XrdClArg.hh:132
Arg(T value)
Definition: XrdClArg.hh:248
Arg(std::future< T > &&ftr)
Definition: XrdClArg.hh:257
T & Get()
Definition: XrdClArg.hh:146
Definition: XrdClFwd.hh:133
Arg(std::future< std::string > &&ftr)
Constructor.
Definition: XrdClArg.hh:326