xrootd
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
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 
31 #include <string>
32 #include <sstream>
33 #include <unordered_map>
34 
35 namespace XrdCl
36 {
37 
38  //----------------------------------------------------------------------------
40  //----------------------------------------------------------------------------
41  template<typename T>
42  class ArgBase
43  {
44  public:
45 
46  //------------------------------------------------------------------------
48  //------------------------------------------------------------------------
50  {
51  }
52 
53  //------------------------------------------------------------------------
55  //------------------------------------------------------------------------
56  virtual ~ArgBase()
57  {
58  }
59 
60  //------------------------------------------------------------------------
64  //------------------------------------------------------------------------
65  ArgBase( T value ) : holder( new PlainValue( std::move( value ) ) )
66  {
67  }
68 
69  //------------------------------------------------------------------------
73  //------------------------------------------------------------------------
74  ArgBase( std::future<T> &&ftr ) : holder( new FutureValue( std::move( ftr ) ) )
75  {
76  }
77 
78  //------------------------------------------------------------------------
82  //------------------------------------------------------------------------
83  ArgBase( const Fwd<T> &fwd ) : holder( new FwdValue( fwd ) )
84  {
85  }
86 
87  //------------------------------------------------------------------------
89  //------------------------------------------------------------------------
90  ArgBase( ArgBase &&arg ) : holder( std::move( arg.holder ) )
91  {
92  }
93 
94  //------------------------------------------------------------------------
96  //------------------------------------------------------------------------
97  T Get()
98  {
99  if( !holder ) throw std::logic_error( "XrdCl::ArgBase::Get(): value not set." );
100  return holder->Get();
101  }
102 
103  protected:
104 
105  //------------------------------------------------------------------------
107  //------------------------------------------------------------------------
108  struct ValueHolder
109  {
110  //----------------------------------------------------------------------
112  //----------------------------------------------------------------------
113  virtual ~ValueHolder()
114  {
115  }
116 
117  //----------------------------------------------------------------------
119  //----------------------------------------------------------------------
120  virtual T Get() = 0;
121  };
122 
123  //------------------------------------------------------------------------
125  //------------------------------------------------------------------------
126  struct PlainValue : public ValueHolder
127  {
128  //--------------------------------------------------------------------
132  //--------------------------------------------------------------------
133  PlainValue( T &&value ) : value( std::move( value ) )
134  {
135  }
136 
137  //--------------------------------------------------------------------
139  //--------------------------------------------------------------------
140  T Get()
141  {
142  return std::move( value );
143  }
144 
145  private:
146  //--------------------------------------------------------------------
148  //--------------------------------------------------------------------
149  T value;
150  };
151 
152  //------------------------------------------------------------------------
154  //------------------------------------------------------------------------
155  struct FutureValue : public ValueHolder
156  {
157  //--------------------------------------------------------------------
161  //--------------------------------------------------------------------
162  FutureValue( std::future<T> &&ftr ) : ftr( std::move( ftr ) )
163  {
164  }
165 
166  //--------------------------------------------------------------------
168  //--------------------------------------------------------------------
169  T Get()
170  {
171  return ftr.get();
172  }
173 
174  private:
175  //--------------------------------------------------------------------
177  //--------------------------------------------------------------------
178  std::future<T> ftr;
179  };
180 
181  //------------------------------------------------------------------------
183  //------------------------------------------------------------------------
184  struct FwdValue : public ValueHolder
185  {
186  //--------------------------------------------------------------------
190  //--------------------------------------------------------------------
191  FwdValue( const Fwd<T> &fwd ) : fwd( fwd )
192  {
193  }
194 
195  //--------------------------------------------------------------------
197  //--------------------------------------------------------------------
198  T Get()
199  {
200  return std::move( *fwd );
201  }
202 
203  private:
204  //--------------------------------------------------------------------
206  //--------------------------------------------------------------------
208  };
209 
210  //------------------------------------------------------------------------
212  //------------------------------------------------------------------------
213  std::unique_ptr<ValueHolder> holder;
214  };
215 
216  //----------------------------------------------------------------------------
221  //----------------------------------------------------------------------------
222  template<typename T>
223  class Arg : public ArgBase<T>
224  {
225  public:
226 
227  //------------------------------------------------------------------------
229  //------------------------------------------------------------------------
230  Arg()
231  {
232  }
233 
234  //------------------------------------------------------------------------
238  //------------------------------------------------------------------------
239  Arg( T value ) : ArgBase<T>( std::move( value ) )
240  {
241  }
242 
243  //------------------------------------------------------------------------
247  //------------------------------------------------------------------------
248  Arg( std::future<T> &&ftr ) : ArgBase<T>( std::move( ftr ) )
249  {
250  }
251 
252  //------------------------------------------------------------------------
256  //------------------------------------------------------------------------
257  Arg( const Fwd<T> &fwd ) : ArgBase<T>( fwd )
258  {
259  }
260 
261  //------------------------------------------------------------------------
263  //------------------------------------------------------------------------
264  Arg( Arg &&arg ) : ArgBase<T>( std::move( arg ) )
265  {
266  }
267 
268  //------------------------------------------------------------------------
270  //------------------------------------------------------------------------
271  Arg& operator=( Arg &&arg )
272  {
273  if( &arg == this ) return *this;
274  this->holder = std::move( arg.holder );
275  return *this;
276  }
277  };
278 
279  //----------------------------------------------------------------------------
283  //----------------------------------------------------------------------------
284  template<>
285  class Arg<std::string> : public ArgBase<std::string>
286  {
287  public:
288 
289  //------------------------------------------------------------------------
291  //------------------------------------------------------------------------
292  Arg()
293  {
294  }
295 
296  //------------------------------------------------------------------------
300  //------------------------------------------------------------------------
301  Arg( std::string str ) : ArgBase<std::string>( str )
302  {
303  }
304 
305  //------------------------------------------------------------------------
309  //------------------------------------------------------------------------
310  Arg( const char *cstr ) : ArgBase<std::string>( cstr )
311  {
312  }
313 
314  //------------------------------------------------------------------------
316  //------------------------------------------------------------------------
317  Arg( std::future<std::string> &&ftr ) : ArgBase<std::string>( std::move( ftr ) )
318  {
319  }
320 
321  //------------------------------------------------------------------------
323  //------------------------------------------------------------------------
324  Arg( const Fwd<std::string> &fwd ) : ArgBase<std::string>( fwd )
325  {
326  }
327 
328 
329  //------------------------------------------------------------------------
331  //-----------------------------------------------------------------------
332  Arg( Arg &&arg ) : ArgBase<std::string>( std::move( arg ) )
333  {
334  }
335 
336  //------------------------------------------------------------------------
338  //------------------------------------------------------------------------
339  Arg& operator=( Arg &&arg )
340  {
341  if( &arg == this ) return *this;
342  this->holder = std::move( arg.holder );
343  return *this;
344  }
345  };
346 }
347 
348 #endif // __XRD_CL_OPERATION_PARAMS_HH__
T value
the value
Definition: XrdClArg.hh:149
Arg(Arg &&arg)
Get Constructor.
Definition: XrdClArg.hh:332
ArgBase()
Default Constructor.
Definition: XrdClArg.hh:49
FwdValue(const Fwd< T > &fwd)
Definition: XrdClArg.hh:191
FutureValue(std::future< T > &&ftr)
Definition: XrdClArg.hh:162
T Get()
Definition: XrdClArg.hh:169
Arg & operator=(Arg &&arg)
Get-Assignment.
Definition: XrdClArg.hh:271
Arg()
Default Constructor.
Definition: XrdClArg.hh:292
Arg(std::string str)
Definition: XrdClArg.hh:301
ArgBase(ArgBase &&arg)
Get Constructor.
Definition: XrdClArg.hh:90
Arg & operator=(Arg &&arg)
Get-Assignment.
Definition: XrdClArg.hh:339
ArgBase(std::future< T > &&ftr)
Definition: XrdClArg.hh:74
Arg(Arg &&arg)
Get Constructor.
Definition: XrdClArg.hh:264
Arg(const Fwd< T > &fwd)
Definition: XrdClArg.hh:257
Definition: XrdClArg.hh:223
T Get()
Definition: XrdClArg.hh:97
Arg(const char *cstr)
Definition: XrdClArg.hh:310
ArgBase(const Fwd< T > &fwd)
Definition: XrdClArg.hh:83
virtual ~ValueHolder()
Virtual Destructor (important ;-).
Definition: XrdClArg.hh:113
A helper class for holding forwarded value.
Definition: XrdClArg.hh:184
Arg()
Default Constructor.
Definition: XrdClArg.hh:230
ArgBase(T value)
Definition: XrdClArg.hh:65
PlainValue(T &&value)
Definition: XrdClArg.hh:133
Fwd< T > fwd
the forwarded value
Definition: XrdClArg.hh:207
std::unique_ptr< ValueHolder > holder
Holds the value of the argument.
Definition: XrdClArg.hh:213
std::future< T > ftr
the future value
Definition: XrdClArg.hh:178
virtual ~ArgBase()
Destructor.
Definition: XrdClArg.hh:56
T Get()
Definition: XrdClArg.hh:198
Arg(const Fwd< std::string > &fwd)
Constructor.
Definition: XrdClArg.hh:324
Base class for Arg.
Definition: XrdClArg.hh:42
A helper class for holding future value.
Definition: XrdClArg.hh:155
Abstract class for holding a value.
Definition: XrdClArg.hh:108
T Get()
Definition: XrdClArg.hh:140
A helper class for holding plain value.
Definition: XrdClArg.hh:126
Arg(T value)
Definition: XrdClArg.hh:239
Arg(std::future< T > &&ftr)
Definition: XrdClArg.hh:248
Arg(std::future< std::string > &&ftr)
Constructor.
Definition: XrdClArg.hh:317
Definition: XrdClFwd.hh:117