VTK  9.0.20201130
vtkDispatcher_Private.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkDispatcher.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
15 
17 // The Loki Library
18 // Copyright (c) 2001 by Andrei Alexandrescu
19 // This code accompanies the book:
20 // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
21 // Patterns Applied". Copyright (c) 2001. Addison-Wesley.
22 // Permission to use, copy, modify, distribute and sell this software for any
23 // purpose is hereby granted without fee, provided that the above copyright
24 // notice appear in all copies and that both that copyright notice and this
25 // permission notice appear in supporting documentation.
26 // The author or Addison-Wesley Longman make no representations about the
27 // suitability of this software for any purpose. It is provided "as is"
28 // without express or implied warranty.
30 #ifndef vtkDispatcher_Private_h
31 #define vtkDispatcher_Private_h
32 
33 #ifndef __VTK_WRAP__
34 
35 #include "vtkDeprecation.h" // for VTK_DEPRECATED_IN_9_0_0
36 
37 #include <cassert>
38 #include <memory>
39 #include <typeinfo>
40 
42 {
44 // Dispatch helper for reference functors
46 template <class BaseLhs, class SomeLhs, typename RT, class CastLhs, class Fun>
48 {
49  Fun& fun_;
50 
51 public:
52  typedef RT ResultType;
53 
55  : fun_(rhs.fun_)
56  {
57  }
59  : fun_(f)
60  {
61  }
62 
63  ResultType operator()(BaseLhs& lhs) { return fun_(CastLhs::Cast(lhs)); }
64 
65 private:
66  FunctorRefDispatcherHelper& operator=(const FunctorRefDispatcherHelper& b) = delete;
67 };
68 
70 // Dispatch helper
72 template <class BaseLhs, class SomeLhs, typename RT, class CastLhs, class Fun>
74 {
75  Fun fun_;
76 
77 public:
78  typedef RT ResultType;
79 
81  : fun_(rhs.fun_)
82  {
83  }
85  : fun_(fun)
86  {
87  }
88 
89  ResultType operator()(BaseLhs& lhs) { return fun_(CastLhs::Cast(lhs)); }
90 };
91 
93 // Parent class for all FunctorImpl, helps hide functor template args
95 template <typename R, typename P1>
97 {
98 public:
99  typedef R ResultType;
100  typedef P1 Parm1;
101 
102  virtual ~FunctorImpl() = default;
103  virtual R operator()(P1&) = 0;
104  virtual FunctorImpl* DoClone() const = 0;
105 
106  template <class U>
107  static U* Clone(U* pObj)
108  {
109  if (!pObj)
110  return nullptr;
111  U* pClone = static_cast<U*>(pObj->DoClone());
112  assert(typeid(*pClone) == typeid(*pObj));
113  return pClone;
114  }
115 
116 protected:
117  FunctorImpl() = default;
118  FunctorImpl(const FunctorImpl&) = default;
119 
120 private:
121  FunctorImpl& operator=(const FunctorImpl&) = delete;
122 };
123 
125 // Impl functor that calls a user functor
127 template <class ParentFunctor, typename Fun>
128 class FunctorHandler : public ParentFunctor::Impl
129 {
130  typedef typename ParentFunctor::Impl Base;
131 
132 public:
133  typedef typename Base::ResultType ResultType;
134  typedef typename Base::Parm1 Parm1;
135 
136  FunctorHandler(Fun& fun)
137  : f_(fun)
138  {
139  }
140  ~FunctorHandler() override = default;
141 
142  ResultType operator()(Parm1& p1) override { return f_(p1); }
143  FunctorHandler* DoClone() const override { return new FunctorHandler(*this); }
144 
145 private:
146  Fun f_;
148  : ParentFunctor::Impl(b)
149  , f_(b.f_)
150  {
151  }
152  FunctorHandler& operator=(const FunctorHandler& b) = delete;
153 };
154 
156 // Functor wrapper class
158 template <typename R, typename Parm1>
159 class Functor
160 {
161 public:
163  typedef R ResultType;
164 
166  : spImpl_()
167  {
168  }
169 
170  Functor(const Functor& rhs)
171  : spImpl_(Impl::Clone(rhs.spImpl_.get()))
172  {
173  }
174 
175  template <typename Fun>
176  Functor(Fun fun)
177  : spImpl_(new FunctorHandler<Functor, Fun>(fun))
178  {
179  }
180 
181  Functor& operator=(const Functor& rhs)
182  {
183  Functor copy(rhs);
184  spImpl_.swap(copy.spImpl_);
185  return *this;
186  }
187 
188  ResultType operator()(Parm1& p1) { return (*spImpl_)(p1); }
189 
190 private:
191  std::unique_ptr<Impl> spImpl_;
192 };
193 
194 }
195 
197 {
198 
200 // Dispatch helper
202 template <class BaseLhs, class BaseRhs, class SomeLhs, class SomeRhs, typename RT, class CastLhs,
203  class CastRhs, class Fun>
205 {
206  Fun& fun_;
207 
208 public:
209  typedef RT ResultType;
211  : fun_(rhs.fun_)
212  {
213  }
215  : fun_(fun)
216  {
217  }
218 
219  ResultType operator()(BaseLhs& lhs, BaseRhs& rhs)
220  {
221  return fun_(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
222  }
223 
224 private:
225  FunctorRefDispatcherHelper& operator=(const FunctorRefDispatcherHelper& b) = delete;
226 };
227 
228 template <class BaseLhs, class BaseRhs, class SomeLhs, class SomeRhs, typename RT, class CastLhs,
229  class CastRhs, class Fun>
231 {
232  Fun fun_;
233 
234 public:
235  typedef RT ResultType;
237  : fun_(rhs.fun_)
238  {
239  }
241  : fun_(fun)
242  {
243  }
244 
245  ResultType operator()(BaseLhs& lhs, BaseRhs& rhs)
246  {
247  return fun_(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
248  }
249 };
250 
252 // Parent class for all FunctorImpl, helps hide functor template args
254 template <typename R, typename P1, typename P2>
256 {
257 public:
258  typedef R ResultType;
259  typedef P1 Parm1;
260  typedef P2 Parm2;
261 
262  virtual ~FunctorImpl() = default;
263  virtual R operator()(P1&, P2&) = 0;
264  virtual FunctorImpl* DoClone() const = 0;
265 
266  template <class U>
267  static U* Clone(U* pObj)
268  {
269  if (!pObj)
270  return nullptr;
271  U* pClone = static_cast<U*>(pObj->DoClone());
272  assert(typeid(*pClone) == typeid(*pObj));
273  return pClone;
274  }
275 
276 protected:
277  FunctorImpl() = default;
278  FunctorImpl(const FunctorImpl&) = default;
279 
280 private:
281  FunctorImpl& operator=(const FunctorImpl&) = delete;
282 };
283 
285 // Impl functor that calls a user functor
287 template <class ParentFunctor, typename Fun>
288 class FunctorHandler : public ParentFunctor::Impl
289 {
290  typedef typename ParentFunctor::Impl Base;
291 
292 public:
293  typedef typename Base::ResultType ResultType;
294  typedef typename Base::Parm1 Parm1;
295  typedef typename Base::Parm2 Parm2;
296 
297  FunctorHandler(const Fun& fun)
298  : f_(fun)
299  {
300  }
301  ~FunctorHandler() override = default;
302 
303  ResultType operator()(Parm1& p1, Parm2& p2) override { return f_(p1, p2); }
304 
305  FunctorHandler* DoClone() const override { return new FunctorHandler(*this); }
306 
307 private:
308  Fun f_;
310  : ParentFunctor::Impl(b)
311  , f_(b.f_)
312  {
313  }
314  FunctorHandler& operator=(const FunctorHandler& b) = delete;
315 };
316 
318 // Functor wrapper class
320 template <typename R, typename Parm1, typename Parm2>
321 class Functor
322 {
323 public:
325  typedef R ResultType;
326 
328  : spImpl_()
329  {
330  }
331 
332  Functor(const Functor& rhs)
333  : spImpl_(Impl::Clone(rhs.spImpl_.get()))
334  {
335  }
336 
337  template <typename Fun>
338  Functor(const Fun& fun)
339  : spImpl_(new FunctorHandler<Functor, Fun>(fun))
340  {
341  }
342 
343  Functor& operator=(const Functor& rhs)
344  {
345  Functor copy(rhs);
346  spImpl_.swap(copy.spImpl_);
347  return *this;
348  }
349 
350  ResultType operator()(Parm1& p1, Parm2& p2) { return (*spImpl_)(p1, p2); }
351 
352 private:
353  std::unique_ptr<Impl> spImpl_;
354 };
355 }
356 
358 {
359 
360 template <class To, class From>
362 {
363  static To& Cast(From& obj) { return dynamic_cast<To&>(obj); }
364 
365  static To* Cast(From* obj) { return dynamic_cast<To*>(obj); }
366 };
367 
368 template <class To, class From>
369 struct vtkCaster
370 {
371  static To& Cast(From& obj) { return *(To::SafeDownCast(&obj)); }
372 
373  static To* Cast(From* obj) { return To::SafeDownCast(obj); }
374 };
375 
376 class TypeInfo
377 {
378 public:
379  // Constructors
380  TypeInfo(); // needed for containers
381  TypeInfo(const std::type_info&); // non-explicit
382 
383  // Access for the wrapped std::type_info
384  const std::type_info& Get() const;
385  // Compatibility functions
386  bool before(const TypeInfo& rhs) const;
387  const char* name() const;
388 
389 private:
390  const std::type_info* pInfo_;
391 };
392 
393 // Implementation
394 
396 {
397  class Nil
398  {
399  };
400  pInfo_ = &typeid(Nil);
401  assert(pInfo_);
402 }
403 
404 inline TypeInfo::TypeInfo(const std::type_info& ti)
405  : pInfo_(&ti)
406 {
407  assert(pInfo_);
408 }
409 
410 inline bool TypeInfo::before(const TypeInfo& rhs) const
411 {
412  assert(pInfo_);
413  // type_info::before return type is int in some VC libraries
414  return pInfo_->before(*rhs.pInfo_) != 0;
415 }
416 
417 inline const std::type_info& TypeInfo::Get() const
418 {
419  assert(pInfo_);
420  return *pInfo_;
421 }
422 
423 inline const char* TypeInfo::name() const
424 {
425  assert(pInfo_);
426  return pInfo_->name();
427 }
428 
429 // Comparison operators
430 
431 inline bool operator==(const TypeInfo& lhs, const TypeInfo& rhs)
432 // type_info::operator== return type is int in some VC libraries
433 {
434  return (lhs.Get() == rhs.Get()) != 0;
435 }
436 
437 inline bool operator<(const TypeInfo& lhs, const TypeInfo& rhs)
438 {
439  return lhs.before(rhs);
440 }
441 
442 inline bool operator!=(const TypeInfo& lhs, const TypeInfo& rhs)
443 {
444  return !(lhs == rhs);
445 }
446 
447 inline bool operator>(const TypeInfo& lhs, const TypeInfo& rhs)
448 {
449  return rhs < lhs;
450 }
451 
452 inline bool operator<=(const TypeInfo& lhs, const TypeInfo& rhs)
453 {
454  return !(lhs > rhs);
455 }
456 
457 inline bool operator>=(const TypeInfo& lhs, const TypeInfo& rhs)
458 {
459  return !(lhs < rhs);
460 }
461 
462 }
463 
464 #endif // wrapping
465 #endif // vtkDispatcherPrivate_h
466 // VTK-HeaderTest-Exclude: vtkDispatcher_Private.h
vtkDoubleDispatcherPrivate::FunctorRefDispatcherHelper::ResultType
RT ResultType
Definition: vtkDispatcher_Private.h:209
vtkDoubleDispatcherPrivate::FunctorImpl::Parm2
P2 Parm2
Definition: vtkDispatcher_Private.h:260
vtkDispatcherPrivate::FunctorDispatcherHelper::operator()
ResultType operator()(BaseLhs &lhs)
Definition: vtkDispatcher_Private.h:89
vtkDispatcherPrivate::Functor::operator=
Functor & operator=(const Functor &rhs)
Definition: vtkDispatcher_Private.h:181
vtkDispatcherPrivate::FunctorDispatcherHelper::FunctorDispatcherHelper
FunctorDispatcherHelper(const FunctorDispatcherHelper &rhs)
Definition: vtkDispatcher_Private.h:80
vtkDispatcherCommon::TypeInfo
Definition: vtkDispatcher_Private.h:376
vtkDispatcherPrivate::FunctorImpl
Definition: vtkDispatcher_Private.h:96
vtkDispatcherCommon::DynamicCaster::Cast
static To * Cast(From *obj)
Definition: vtkDispatcher_Private.h:365
vtkDoubleDispatcherPrivate
Definition: vtkDispatcher_Private.h:196
vtkDoubleDispatcherPrivate::FunctorImpl::FunctorImpl
FunctorImpl()=default
vtkDoubleDispatcherPrivate::FunctorImpl::~FunctorImpl
virtual ~FunctorImpl()=default
vtkDispatcherCommon::TypeInfo::TypeInfo
TypeInfo()
Definition: vtkDispatcher_Private.h:395
vtkDispatcherCommon::operator>
bool operator>(const TypeInfo &lhs, const TypeInfo &rhs)
Definition: vtkDispatcher_Private.h:447
vtkDispatcherPrivate::FunctorHandler::operator()
ResultType operator()(Parm1 &p1) override
Definition: vtkDispatcher_Private.h:142
vtkDispatcherPrivate::FunctorRefDispatcherHelper::operator()
ResultType operator()(BaseLhs &lhs)
Definition: vtkDispatcher_Private.h:63
vtkDoubleDispatcherPrivate::FunctorHandler::FunctorHandler
FunctorHandler(const Fun &fun)
Definition: vtkDispatcher_Private.h:297
vtkDispatcherCommon::vtkCaster::Cast
static To & Cast(From &obj)
Definition: vtkDispatcher_Private.h:371
vtkDoubleDispatcherPrivate::FunctorHandler::operator()
ResultType operator()(Parm1 &p1, Parm2 &p2) override
Definition: vtkDispatcher_Private.h:303
vtkDispatcherCommon::operator<
bool operator<(const TypeInfo &lhs, const TypeInfo &rhs)
Definition: vtkDispatcher_Private.h:437
vtkDispatcherCommon::vtkCaster::Cast
static To * Cast(From *obj)
Definition: vtkDispatcher_Private.h:373
vtkDoubleDispatcherPrivate::FunctorHandler::DoClone
FunctorHandler * DoClone() const override
Definition: vtkDispatcher_Private.h:305
vtkDispatcherCommon::operator==
bool operator==(const TypeInfo &lhs, const TypeInfo &rhs)
Definition: vtkDispatcher_Private.h:431
vtkDoubleDispatcherPrivate::Functor::ResultType
R ResultType
Definition: vtkDispatcher_Private.h:325
vtkDoubleDispatcherPrivate::FunctorDoubleDispatcherHelper::FunctorDoubleDispatcherHelper
FunctorDoubleDispatcherHelper(const FunctorDoubleDispatcherHelper &rhs)
Definition: vtkDispatcher_Private.h:236
vtkDoubleDispatcherPrivate::FunctorRefDispatcherHelper::operator()
ResultType operator()(BaseLhs &lhs, BaseRhs &rhs)
Definition: vtkDispatcher_Private.h:219
vtkDoubleDispatcherPrivate::Functor
Definition: vtkDispatcher_Private.h:321
vtkDoubleDispatcherPrivate::FunctorHandler
Definition: vtkDispatcher_Private.h:288
vtkDoubleDispatcherPrivate::FunctorImpl::Clone
static U * Clone(U *pObj)
Definition: vtkDispatcher_Private.h:267
vtkDispatcherPrivate
Definition: vtkDispatcher_Private.h:41
vtkDispatcherPrivate::FunctorRefDispatcherHelper::FunctorRefDispatcherHelper
FunctorRefDispatcherHelper(Fun &f)
Definition: vtkDispatcher_Private.h:58
vtkDoubleDispatcherPrivate::FunctorImpl::operator()
virtual R operator()(P1 &, P2 &)=0
vtkDoubleDispatcherPrivate::FunctorHandler::Parm1
Base::Parm1 Parm1
Definition: vtkDispatcher_Private.h:294
vtkDoubleDispatcherPrivate::FunctorDoubleDispatcherHelper::FunctorDoubleDispatcherHelper
FunctorDoubleDispatcherHelper(Fun fun)
Definition: vtkDispatcher_Private.h:240
vtkDispatcherCommon::TypeInfo::Get
const std::type_info & Get() const
Definition: vtkDispatcher_Private.h:417
vtkDispatcherPrivate::FunctorRefDispatcherHelper::FunctorRefDispatcherHelper
FunctorRefDispatcherHelper(const FunctorRefDispatcherHelper &rhs)
Definition: vtkDispatcher_Private.h:54
vtkDoubleDispatcherPrivate::FunctorImpl::Parm1
P1 Parm1
Definition: vtkDispatcher_Private.h:259
vtkDoubleDispatcherPrivate::FunctorHandler::Parm2
Base::Parm2 Parm2
Definition: vtkDispatcher_Private.h:295
vtkDispatcherPrivate::FunctorImpl::ResultType
R ResultType
Definition: vtkDispatcher_Private.h:99
vtkDispatcherPrivate::FunctorHandler::FunctorHandler
FunctorHandler(Fun &fun)
Definition: vtkDispatcher_Private.h:136
vtkDispatcherPrivate::FunctorDispatcherHelper::ResultType
RT ResultType
Definition: vtkDispatcher_Private.h:78
vtkDoubleDispatcherPrivate::Functor::Functor
Functor(const Functor &rhs)
Definition: vtkDispatcher_Private.h:332
boost::get
double get(vtkDataArray *const &arr, vtkIdType key)
Definition: vtkBoostGraphAdapter.h:99
vtkDispatcherPrivate::FunctorImpl::FunctorImpl
FunctorImpl()=default
vtkDispatcherCommon::operator>=
bool operator>=(const TypeInfo &lhs, const TypeInfo &rhs)
Definition: vtkDispatcher_Private.h:457
vtkDoubleDispatcherPrivate::Functor::Functor
Functor()
Definition: vtkDispatcher_Private.h:327
vtkDispatcherPrivate::FunctorHandler
Definition: vtkDispatcher_Private.h:128
vtkDispatcherPrivate::FunctorImpl::operator()
virtual R operator()(P1 &)=0
vtkDispatcherCommon::DynamicCaster::Cast
static To & Cast(From &obj)
Definition: vtkDispatcher_Private.h:363
vtkDispatcherPrivate::FunctorHandler::DoClone
FunctorHandler * DoClone() const override
Definition: vtkDispatcher_Private.h:143
vtkDoubleDispatcherPrivate::FunctorRefDispatcherHelper::FunctorRefDispatcherHelper
FunctorRefDispatcherHelper(const FunctorRefDispatcherHelper &rhs)
Definition: vtkDispatcher_Private.h:210
vtkDispatcherPrivate::FunctorHandler::Parm1
Base::Parm1 Parm1
Definition: vtkDispatcher_Private.h:134
vtkDispatcherPrivate::FunctorImpl::Parm1
P1 Parm1
Definition: vtkDispatcher_Private.h:100
vtkDispatcherPrivate::Functor::Impl
FunctorImpl< R, Parm1 > Impl
Definition: vtkDispatcher_Private.h:162
vtkDispatcherCommon::TypeInfo::name
const char * name() const
Definition: vtkDispatcher_Private.h:423
vtkDispatcherPrivate::Functor::operator()
ResultType operator()(Parm1 &p1)
Definition: vtkDispatcher_Private.h:188
vtkDispatcherCommon::operator<=
bool operator<=(const TypeInfo &lhs, const TypeInfo &rhs)
Definition: vtkDispatcher_Private.h:452
vtkDispatcherPrivate::FunctorImpl::Clone
static U * Clone(U *pObj)
Definition: vtkDispatcher_Private.h:107
vtkDispatcherPrivate::FunctorHandler::ResultType
Base::ResultType ResultType
Definition: vtkDispatcher_Private.h:133
vtkDoubleDispatcherPrivate::Functor::Functor
Functor(const Fun &fun)
Definition: vtkDispatcher_Private.h:338
vtkDispatcherPrivate::Functor::Functor
Functor(const Functor &rhs)
Definition: vtkDispatcher_Private.h:170
vtkDispatcherPrivate::FunctorImpl::DoClone
virtual FunctorImpl * DoClone() const =0
vtkDispatcherPrivate::Functor::Functor
Functor()
Definition: vtkDispatcher_Private.h:165
vtkDispatcherPrivate::FunctorRefDispatcherHelper::ResultType
RT ResultType
Definition: vtkDispatcher_Private.h:52
vtkDoubleDispatcherPrivate::FunctorImpl::ResultType
R ResultType
Definition: vtkDispatcher_Private.h:258
vtkDoubleDispatcherPrivate::Functor::operator()
ResultType operator()(Parm1 &p1, Parm2 &p2)
Definition: vtkDispatcher_Private.h:350
vtkDispatcherCommon::operator!=
bool operator!=(const TypeInfo &lhs, const TypeInfo &rhs)
Definition: vtkDispatcher_Private.h:442
vtkDeprecation.h
vtkDoubleDispatcherPrivate::Functor::Impl
FunctorImpl< R, Parm1, Parm2 > Impl
Definition: vtkDispatcher_Private.h:324
vtkDispatcherCommon::TypeInfo::before
bool before(const TypeInfo &rhs) const
Definition: vtkDispatcher_Private.h:410
vtkDoubleDispatcherPrivate::FunctorHandler::ResultType
Base::ResultType ResultType
Definition: vtkDispatcher_Private.h:293
vtkDispatcherCommon::vtkCaster
Definition: vtkDispatcher_Private.h:369
vtkDispatcherPrivate::FunctorHandler::~FunctorHandler
~FunctorHandler() override=default
vtkDoubleDispatcherPrivate::FunctorDoubleDispatcherHelper
Definition: vtkDispatcher_Private.h:230
vtkDoubleDispatcherPrivate::FunctorImpl::DoClone
virtual FunctorImpl * DoClone() const =0
vtkDoubleDispatcherPrivate::FunctorImpl
Definition: vtkDispatcher_Private.h:255
vtkDispatcherPrivate::FunctorDispatcherHelper::FunctorDispatcherHelper
FunctorDispatcherHelper(Fun fun)
Definition: vtkDispatcher_Private.h:84
vtkDoubleDispatcherPrivate::FunctorRefDispatcherHelper::FunctorRefDispatcherHelper
FunctorRefDispatcherHelper(Fun &fun)
Definition: vtkDispatcher_Private.h:214
vtkDoubleDispatcherPrivate::FunctorDoubleDispatcherHelper::operator()
ResultType operator()(BaseLhs &lhs, BaseRhs &rhs)
Definition: vtkDispatcher_Private.h:245
vtkDispatcherPrivate::FunctorDispatcherHelper
Definition: vtkDispatcher_Private.h:73
vtkDispatcherPrivate::FunctorRefDispatcherHelper
Definition: vtkDispatcher_Private.h:47
vtkDoubleDispatcherPrivate::FunctorHandler::~FunctorHandler
~FunctorHandler() override=default
vtkDispatcherPrivate::Functor::ResultType
R ResultType
Definition: vtkDispatcher_Private.h:163
vtkDispatcherCommon
Definition: vtkDispatcher_Private.h:357
vtkDoubleDispatcherPrivate::Functor::operator=
Functor & operator=(const Functor &rhs)
Definition: vtkDispatcher_Private.h:343
vtkDispatcherPrivate::FunctorImpl::~FunctorImpl
virtual ~FunctorImpl()=default
vtkDispatcherPrivate::Functor::Functor
Functor(Fun fun)
Definition: vtkDispatcher_Private.h:176
vtkDispatcherCommon::DynamicCaster
Definition: vtkDispatcher_Private.h:361
vtkDispatcherPrivate::Functor
Definition: vtkDispatcher_Private.h:159
vtkDoubleDispatcherPrivate::FunctorRefDispatcherHelper
Definition: vtkDispatcher_Private.h:204
vtkDoubleDispatcherPrivate::FunctorDoubleDispatcherHelper::ResultType
RT ResultType
Definition: vtkDispatcher_Private.h:235