xrootd
Loading...
Searching...
No Matches
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"
31
32#include <string>
33#include <sstream>
34#include <unordered_map>
35
36namespace 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 //------------------------------------------------------------------------
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 //--------------------------------------------------------------------
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 //------------------------------------------------------------------------
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 //------------------------------------------------------------------------
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__
Base class for Arg.
Definition: XrdClArg.hh:44
ArgBase(ArgBase &&arg)
Get Constructor.
Definition: XrdClArg.hh:91
ArgBase()
Default Constructor.
Definition: XrdClArg.hh:50
ArgBase(T value)
Definition: XrdClArg.hh:66
T & Get() const
Definition: XrdClArg.hh:98
virtual ~ArgBase()
Destructor.
Definition: XrdClArg.hh:57
ArgBase(std::future< T > &&ftr)
Definition: XrdClArg.hh:75
std::unique_ptr< ValueHolder > holder
Holds the value of the argument.
Definition: XrdClArg.hh:222
ArgBase(const Fwd< T > &fwd)
Definition: XrdClArg.hh:84
Arg(Arg &&arg)
Get Constructor.
Definition: XrdClArg.hh:341
Arg(std::future< std::string > &&ftr)
Constructor.
Definition: XrdClArg.hh:326
Arg(std::string str)
Definition: XrdClArg.hh:310
Arg()
Default Constructor.
Definition: XrdClArg.hh:301
Arg(const char *cstr)
Definition: XrdClArg.hh:319
Arg(const Fwd< std::string > &fwd)
Constructor.
Definition: XrdClArg.hh:333
Arg & operator=(Arg &&arg)
Get-Assignment.
Definition: XrdClArg.hh:348
Definition: XrdClArg.hh:233
Arg & operator=(Arg &&arg)
Get-Assignment.
Definition: XrdClArg.hh:280
Arg()
Default Constructor.
Definition: XrdClArg.hh:239
Arg(std::future< T > &&ftr)
Definition: XrdClArg.hh:257
Arg(T value)
Definition: XrdClArg.hh:248
Arg(const Fwd< T > &fwd)
Definition: XrdClArg.hh:266
Arg(Arg &&arg)
Get Constructor.
Definition: XrdClArg.hh:273
Definition: XrdClOptional.hh:44
Definition: XrdClAction.hh:34
Definition: XrdOucJson.hh:4517
A helper class for holding future value.
Definition: XrdClArg.hh:162
FutureValue(std::future< T > &&ftr)
Definition: XrdClArg.hh:168
T & Get()
Definition: XrdClArg.hh:175
Optional< T > val
Definition: XrdClArg.hh:187
std::future< T > ftr
the future value
Definition: XrdClArg.hh:186
A helper class for holding forwarded value.
Definition: XrdClArg.hh:194
FwdValue(const Fwd< T > &fwd)
Definition: XrdClArg.hh:200
T & Get()
Definition: XrdClArg.hh:207
Fwd< T > fwd
the forwarded value
Definition: XrdClArg.hh:216
A helper class for holding plain value.
Definition: XrdClArg.hh:133
PlainValue(T &&value)
Definition: XrdClArg.hh:139
T value
the value
Definition: XrdClArg.hh:155
T & Get()
Definition: XrdClArg.hh:146
Abstract class for holding a value.
Definition: XrdClArg.hh:115
virtual ~ValueHolder()
Virtual Destructor (important ;-).
Definition: XrdClArg.hh:119
Definition: XrdClFwd.hh:134