VTK
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 #ifndef __VTK_WRAP__
33 
34 #include <cassert>
35 #include <memory>
36 #include <typeinfo>
37 
39 {
41 // Dispatch helper for reference functors
43 template <class BaseLhs, class SomeLhs, typename RT, class CastLhs, class Fun>
45 {
46  Fun& fun_;
47 
48 public:
49  typedef RT ResultType;
50 
52  : fun_(rhs.fun_)
53  {
54  }
56  : fun_(f)
57  {
58  }
59 
60  ResultType operator()(BaseLhs& lhs) { return fun_(CastLhs::Cast(lhs)); }
61 
62 private:
64 };
65 
67 // Dispatch helper
69 template <class BaseLhs, class SomeLhs, typename RT, class CastLhs, class Fun>
71 {
72  Fun fun_;
73 
74 public:
75  typedef RT ResultType;
76 
78  : fun_(rhs.fun_)
79  {
80  }
82  : fun_(fun)
83  {
84  }
85 
86  ResultType operator()(BaseLhs& lhs) { return fun_(CastLhs::Cast(lhs)); }
87 };
88 
90 // Parent class for all FunctorImpl, helps hide functor template args
92 template <typename R, typename P1>
94 {
95 public:
96  typedef R ResultType;
97  typedef P1 Parm1;
98 
99  virtual ~FunctorImpl() {}
100  virtual R operator()(P1&) = 0;
101  virtual FunctorImpl* DoClone() const = 0;
102 
103  template <class U>
104  static U* Clone(U* pObj)
105  {
106  if (!pObj)
107  return nullptr;
108  U* pClone = static_cast<U*>(pObj->DoClone());
109  assert(typeid(*pClone) == typeid(*pObj));
110  return pClone;
111  }
112 
113 protected:
116 
117 private:
118  FunctorImpl& operator=(const FunctorImpl&) = delete;
119 };
120 
122 // Impl functor that calls a user functor
124 template <class ParentFunctor, typename Fun>
125 class FunctorHandler : public ParentFunctor::Impl
126 {
127  typedef typename ParentFunctor::Impl Base;
128 
129 public:
130  typedef typename Base::ResultType ResultType;
131  typedef typename Base::Parm1 Parm1;
132 
133  FunctorHandler(Fun& fun)
134  : f_(fun)
135  {
136  }
137  ~FunctorHandler() override {}
138 
139  ResultType operator()(Parm1& p1) override { return f_(p1); }
140  FunctorHandler* DoClone() const override { return new FunctorHandler(*this); }
141 
142 private:
143  Fun f_;
145  : ParentFunctor::Impl(b)
146  , f_(b.f_)
147  {
148  }
149  FunctorHandler& operator=(const FunctorHandler& b) = delete;
150 };
151 
153 // Functor wrapper class
155 template <typename R, typename Parm1>
156 class Functor
157 {
158 public:
160  typedef R ResultType;
161 
163  : spImpl_()
164  {
165  }
166 
167  Functor(const Functor& rhs)
168  : spImpl_(Impl::Clone(rhs.spImpl_.get()))
169  {
170  }
171 
172  template <typename Fun>
173  Functor(Fun fun)
174  : spImpl_(new FunctorHandler<Functor, Fun>(fun))
175  {
176  }
177 
178  Functor& operator=(const Functor& rhs)
179  {
180  Functor copy(rhs);
181  spImpl_.swap(copy.spImpl_);
182  return *this;
183  }
184 
185  ResultType operator()(Parm1& p1) { return (*spImpl_)(p1); }
186 
187 private:
188  std::unique_ptr<Impl> spImpl_;
189 };
190 
191 }
192 
194 {
195 
197 // Dispatch helper
199 template <class BaseLhs, class BaseRhs, class SomeLhs, class SomeRhs, typename RT, class CastLhs,
200  class CastRhs, class Fun>
202 {
203  Fun& fun_;
204 
205 public:
206  typedef RT ResultType;
208  : fun_(rhs.fun_)
209  {
210  }
212  : fun_(fun)
213  {
214  }
215 
216  ResultType operator()(BaseLhs& lhs, BaseRhs& rhs)
217  {
218  return fun_(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
219  }
220 
221 private:
223 };
224 
225 template <class BaseLhs, class BaseRhs, class SomeLhs, class SomeRhs, typename RT, class CastLhs,
226  class CastRhs, class Fun>
228 {
229  Fun fun_;
230 
231 public:
232  typedef RT ResultType;
234  : fun_(rhs.fun_)
235  {
236  }
238  : fun_(fun)
239  {
240  }
241 
242  ResultType operator()(BaseLhs& lhs, BaseRhs& rhs)
243  {
244  return fun_(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
245  }
246 };
247 
249 // Parent class for all FunctorImpl, helps hide functor template args
251 template <typename R, typename P1, typename P2>
253 {
254 public:
255  typedef R ResultType;
256  typedef P1 Parm1;
257  typedef P2 Parm2;
258 
259  virtual ~FunctorImpl() {}
260  virtual R operator()(P1&, P2&) = 0;
261  virtual FunctorImpl* DoClone() const = 0;
262 
263  template <class U>
264  static U* Clone(U* pObj)
265  {
266  if (!pObj)
267  return nullptr;
268  U* pClone = static_cast<U*>(pObj->DoClone());
269  assert(typeid(*pClone) == typeid(*pObj));
270  return pClone;
271  }
272 
273 protected:
276 
277 private:
278  FunctorImpl& operator=(const FunctorImpl&) = delete;
279 };
280 
282 // Impl functor that calls a user functor
284 template <class ParentFunctor, typename Fun>
285 class FunctorHandler : public ParentFunctor::Impl
286 {
287  typedef typename ParentFunctor::Impl Base;
288 
289 public:
290  typedef typename Base::ResultType ResultType;
291  typedef typename Base::Parm1 Parm1;
292  typedef typename Base::Parm2 Parm2;
293 
294  FunctorHandler(const Fun& fun)
295  : f_(fun)
296  {
297  }
298  ~FunctorHandler() override {}
299 
300  ResultType operator()(Parm1& p1, Parm2& p2) override { return f_(p1, p2); }
301 
302  FunctorHandler* DoClone() const override { return new FunctorHandler(*this); }
303 
304 private:
305  Fun f_;
307  : ParentFunctor::Impl(b)
308  , f_(b.f_)
309  {
310  }
311  FunctorHandler& operator=(const FunctorHandler& b) = delete;
312 };
313 
315 // Functor wrapper class
317 template <typename R, typename Parm1, typename Parm2>
318 class Functor
319 {
320 public:
322  typedef R ResultType;
323 
325  : spImpl_()
326  {
327  }
328 
329  Functor(const Functor& rhs)
330  : spImpl_(Impl::Clone(rhs.spImpl_.get()))
331  {
332  }
333 
334  template <typename Fun>
335  Functor(const Fun& fun)
336  : spImpl_(new FunctorHandler<Functor, Fun>(fun))
337  {
338  }
339 
340  Functor& operator=(const Functor& rhs)
341  {
342  Functor copy(rhs);
343  spImpl_.swap(copy.spImpl_);
344  return *this;
345  }
346 
347  ResultType operator()(Parm1& p1, Parm2& p2) { return (*spImpl_)(p1, p2); }
348 
349 private:
350  std::unique_ptr<Impl> spImpl_;
351 };
352 }
353 
355 {
356 
357 template <class To, class From>
359 {
360  static To& Cast(From& obj) { return dynamic_cast<To&>(obj); }
361 
362  static To* Cast(From* obj) { return dynamic_cast<To*>(obj); }
363 };
364 
365 template <class To, class From>
366 struct vtkCaster
367 {
368  static To& Cast(From& obj) { return *(To::SafeDownCast(&obj)); }
369 
370  static To* Cast(From* obj) { return To::SafeDownCast(obj); }
371 };
372 
373 class TypeInfo
374 {
375 public:
376  // Constructors
377  TypeInfo(); // needed for containers
378  TypeInfo(const std::type_info&); // non-explicit
379 
380  // Access for the wrapped std::type_info
381  const std::type_info& Get() const;
382  // Compatibility functions
383  bool before(const TypeInfo& rhs) const;
384  const char* name() const;
385 
386 private:
387  const std::type_info* pInfo_;
388 };
389 
390 // Implementation
391 
393 {
394  class Nil
395  {
396  };
397  pInfo_ = &typeid(Nil);
398  assert(pInfo_);
399 }
400 
401 inline TypeInfo::TypeInfo(const std::type_info& ti)
402  : pInfo_(&ti)
403 {
404  assert(pInfo_);
405 }
406 
407 inline bool TypeInfo::before(const TypeInfo& rhs) const
408 {
409  assert(pInfo_);
410  // type_info::before return type is int in some VC libraries
411  return pInfo_->before(*rhs.pInfo_) != 0;
412 }
413 
414 inline const std::type_info& TypeInfo::Get() const
415 {
416  assert(pInfo_);
417  return *pInfo_;
418 }
419 
420 inline const char* TypeInfo::name() const
421 {
422  assert(pInfo_);
423  return pInfo_->name();
424 }
425 
426 // Comparison operators
427 
428 inline bool operator==(const TypeInfo& lhs, const TypeInfo& rhs)
429 // type_info::operator== return type is int in some VC libraries
430 {
431  return (lhs.Get() == rhs.Get()) != 0;
432 }
433 
434 inline bool operator<(const TypeInfo& lhs, const TypeInfo& rhs)
435 {
436  return lhs.before(rhs);
437 }
438 
439 inline bool operator!=(const TypeInfo& lhs, const TypeInfo& rhs)
440 {
441  return !(lhs == rhs);
442 }
443 
444 inline bool operator>(const TypeInfo& lhs, const TypeInfo& rhs)
445 {
446  return rhs < lhs;
447 }
448 
449 inline bool operator<=(const TypeInfo& lhs, const TypeInfo& rhs)
450 {
451  return !(lhs > rhs);
452 }
453 
454 inline bool operator>=(const TypeInfo& lhs, const TypeInfo& rhs)
455 {
456  return !(lhs < rhs);
457 }
458 
459 }
460 
461 #endif
462 #endif // vtkDispatcherPrivate_h
463 // VTK-HeaderTest-Exclude: vtkDispatcher_Private.h
vtkDoubleDispatcherPrivate::FunctorRefDispatcherHelper::ResultType
RT ResultType
Definition: vtkDispatcher_Private.h:206
vtkDoubleDispatcherPrivate::FunctorImpl::Parm2
P2 Parm2
Definition: vtkDispatcher_Private.h:257
vtkDispatcherPrivate::FunctorDispatcherHelper::operator()
ResultType operator()(BaseLhs &lhs)
Definition: vtkDispatcher_Private.h:86
vtkDispatcherPrivate::Functor::operator=
Functor & operator=(const Functor &rhs)
Definition: vtkDispatcher_Private.h:178
vtkDispatcherPrivate::FunctorDispatcherHelper::FunctorDispatcherHelper
FunctorDispatcherHelper(const FunctorDispatcherHelper &rhs)
Definition: vtkDispatcher_Private.h:77
vtkDispatcherCommon::TypeInfo
Definition: vtkDispatcher_Private.h:373
vtkDispatcherPrivate::FunctorImpl
Definition: vtkDispatcher_Private.h:93
vtkDispatcherCommon::DynamicCaster::Cast
static To * Cast(From *obj)
Definition: vtkDispatcher_Private.h:362
vtkDoubleDispatcherPrivate
Definition: vtkDispatcher_Private.h:193
vtkDispatcherCommon::TypeInfo::TypeInfo
TypeInfo()
Definition: vtkDispatcher_Private.h:392
vtkDispatcherCommon::operator>
bool operator>(const TypeInfo &lhs, const TypeInfo &rhs)
Definition: vtkDispatcher_Private.h:444
vtkDispatcherPrivate::FunctorHandler::operator()
ResultType operator()(Parm1 &p1) override
Definition: vtkDispatcher_Private.h:139
vtkDispatcherPrivate::FunctorRefDispatcherHelper::operator()
ResultType operator()(BaseLhs &lhs)
Definition: vtkDispatcher_Private.h:60
vtkDoubleDispatcherPrivate::FunctorHandler::FunctorHandler
FunctorHandler(const Fun &fun)
Definition: vtkDispatcher_Private.h:294
vtkDispatcherCommon::vtkCaster::Cast
static To & Cast(From &obj)
Definition: vtkDispatcher_Private.h:368
vtkDoubleDispatcherPrivate::FunctorHandler::operator()
ResultType operator()(Parm1 &p1, Parm2 &p2) override
Definition: vtkDispatcher_Private.h:300
vtkDispatcherCommon::operator<
bool operator<(const TypeInfo &lhs, const TypeInfo &rhs)
Definition: vtkDispatcher_Private.h:434
vtkDispatcherCommon::vtkCaster::Cast
static To * Cast(From *obj)
Definition: vtkDispatcher_Private.h:370
vtkDoubleDispatcherPrivate::FunctorHandler::DoClone
FunctorHandler * DoClone() const override
Definition: vtkDispatcher_Private.h:302
vtkDispatcherCommon::operator==
bool operator==(const TypeInfo &lhs, const TypeInfo &rhs)
Definition: vtkDispatcher_Private.h:428
vtkDispatcherPrivate::FunctorHandler::~FunctorHandler
~FunctorHandler() override
Definition: vtkDispatcher_Private.h:137
vtkDoubleDispatcherPrivate::Functor::ResultType
R ResultType
Definition: vtkDispatcher_Private.h:322
vtkDoubleDispatcherPrivate::FunctorDoubleDispatcherHelper::FunctorDoubleDispatcherHelper
FunctorDoubleDispatcherHelper(const FunctorDoubleDispatcherHelper &rhs)
Definition: vtkDispatcher_Private.h:233
vtkDoubleDispatcherPrivate::FunctorRefDispatcherHelper::operator()
ResultType operator()(BaseLhs &lhs, BaseRhs &rhs)
Definition: vtkDispatcher_Private.h:216
vtkDoubleDispatcherPrivate::Functor
Definition: vtkDispatcher_Private.h:318
vtkDoubleDispatcherPrivate::FunctorHandler
Definition: vtkDispatcher_Private.h:285
vtkDoubleDispatcherPrivate::FunctorImpl::Clone
static U * Clone(U *pObj)
Definition: vtkDispatcher_Private.h:264
vtkDispatcherPrivate
Definition: vtkDispatcher_Private.h:38
vtkDispatcherPrivate::FunctorRefDispatcherHelper::FunctorRefDispatcherHelper
FunctorRefDispatcherHelper(Fun &f)
Definition: vtkDispatcher_Private.h:55
vtkDoubleDispatcherPrivate::FunctorImpl::operator()
virtual R operator()(P1 &, P2 &)=0
vtkDoubleDispatcherPrivate::FunctorHandler::Parm1
Base::Parm1 Parm1
Definition: vtkDispatcher_Private.h:291
vtkDoubleDispatcherPrivate::FunctorDoubleDispatcherHelper::FunctorDoubleDispatcherHelper
FunctorDoubleDispatcherHelper(Fun fun)
Definition: vtkDispatcher_Private.h:237
vtkDispatcherCommon::TypeInfo::Get
const std::type_info & Get() const
Definition: vtkDispatcher_Private.h:414
vtkDispatcherPrivate::FunctorImpl::~FunctorImpl
virtual ~FunctorImpl()
Definition: vtkDispatcher_Private.h:99
vtkDispatcherPrivate::FunctorRefDispatcherHelper::FunctorRefDispatcherHelper
FunctorRefDispatcherHelper(const FunctorRefDispatcherHelper &rhs)
Definition: vtkDispatcher_Private.h:51
vtkDoubleDispatcherPrivate::FunctorImpl::Parm1
P1 Parm1
Definition: vtkDispatcher_Private.h:256
vtkDoubleDispatcherPrivate::FunctorHandler::Parm2
Base::Parm2 Parm2
Definition: vtkDispatcher_Private.h:292
vtkDispatcherPrivate::FunctorImpl::ResultType
R ResultType
Definition: vtkDispatcher_Private.h:96
vtkDoubleDispatcherPrivate::FunctorHandler::~FunctorHandler
~FunctorHandler() override
Definition: vtkDispatcher_Private.h:298
vtkDispatcherPrivate::FunctorHandler::FunctorHandler
FunctorHandler(Fun &fun)
Definition: vtkDispatcher_Private.h:133
vtkDispatcherPrivate::FunctorDispatcherHelper::ResultType
RT ResultType
Definition: vtkDispatcher_Private.h:75
vtkDoubleDispatcherPrivate::Functor::Functor
Functor(const Functor &rhs)
Definition: vtkDispatcher_Private.h:329
boost::get
double get(vtkDataArray *const &arr, vtkIdType key)
Definition: vtkBoostGraphAdapter.h:99
vtkDoubleDispatcherPrivate::FunctorImpl::FunctorImpl
FunctorImpl(const FunctorImpl &)
Definition: vtkDispatcher_Private.h:275
vtkDispatcherCommon::operator>=
bool operator>=(const TypeInfo &lhs, const TypeInfo &rhs)
Definition: vtkDispatcher_Private.h:454
vtkDoubleDispatcherPrivate::Functor::Functor
Functor()
Definition: vtkDispatcher_Private.h:324
vtkDispatcherPrivate::FunctorImpl::FunctorImpl
FunctorImpl(const FunctorImpl &)
Definition: vtkDispatcher_Private.h:115
vtkDispatcherPrivate::FunctorHandler
Definition: vtkDispatcher_Private.h:125
vtkDispatcherPrivate::FunctorImpl::operator()
virtual R operator()(P1 &)=0
vtkDispatcherCommon::DynamicCaster::Cast
static To & Cast(From &obj)
Definition: vtkDispatcher_Private.h:360
vtkDispatcherPrivate::FunctorHandler::DoClone
FunctorHandler * DoClone() const override
Definition: vtkDispatcher_Private.h:140
vtkDoubleDispatcherPrivate::FunctorRefDispatcherHelper::FunctorRefDispatcherHelper
FunctorRefDispatcherHelper(const FunctorRefDispatcherHelper &rhs)
Definition: vtkDispatcher_Private.h:207
vtkDispatcherPrivate::FunctorHandler::Parm1
Base::Parm1 Parm1
Definition: vtkDispatcher_Private.h:131
vtkDispatcherPrivate::FunctorImpl::Parm1
P1 Parm1
Definition: vtkDispatcher_Private.h:97
vtkDispatcherPrivate::Functor::Impl
FunctorImpl< R, Parm1 > Impl
Definition: vtkDispatcher_Private.h:159
vtkDispatcherCommon::TypeInfo::name
const char * name() const
Definition: vtkDispatcher_Private.h:420
vtkDispatcherPrivate::Functor::operator()
ResultType operator()(Parm1 &p1)
Definition: vtkDispatcher_Private.h:185
vtkDispatcherCommon::operator<=
bool operator<=(const TypeInfo &lhs, const TypeInfo &rhs)
Definition: vtkDispatcher_Private.h:449
vtkDispatcherPrivate::FunctorImpl::Clone
static U * Clone(U *pObj)
Definition: vtkDispatcher_Private.h:104
vtkDispatcherPrivate::FunctorHandler::ResultType
Base::ResultType ResultType
Definition: vtkDispatcher_Private.h:130
vtkDoubleDispatcherPrivate::Functor::Functor
Functor(const Fun &fun)
Definition: vtkDispatcher_Private.h:335
vtkDispatcherPrivate::Functor::Functor
Functor(const Functor &rhs)
Definition: vtkDispatcher_Private.h:167
vtkDispatcherPrivate::FunctorImpl::DoClone
virtual FunctorImpl * DoClone() const =0
vtkDispatcherPrivate::Functor::Functor
Functor()
Definition: vtkDispatcher_Private.h:162
vtkDispatcherPrivate::FunctorRefDispatcherHelper::ResultType
RT ResultType
Definition: vtkDispatcher_Private.h:49
vtkDoubleDispatcherPrivate::FunctorImpl::ResultType
R ResultType
Definition: vtkDispatcher_Private.h:255
vtkDoubleDispatcherPrivate::Functor::operator()
ResultType operator()(Parm1 &p1, Parm2 &p2)
Definition: vtkDispatcher_Private.h:347
vtkDispatcherCommon::operator!=
bool operator!=(const TypeInfo &lhs, const TypeInfo &rhs)
Definition: vtkDispatcher_Private.h:439
vtkDoubleDispatcherPrivate::FunctorImpl::FunctorImpl
FunctorImpl()
Definition: vtkDispatcher_Private.h:274
vtkDoubleDispatcherPrivate::Functor::Impl
FunctorImpl< R, Parm1, Parm2 > Impl
Definition: vtkDispatcher_Private.h:321
vtkDispatcherCommon::TypeInfo::before
bool before(const TypeInfo &rhs) const
Definition: vtkDispatcher_Private.h:407
vtkDoubleDispatcherPrivate::FunctorHandler::ResultType
Base::ResultType ResultType
Definition: vtkDispatcher_Private.h:290
vtkDispatcherCommon::vtkCaster
Definition: vtkDispatcher_Private.h:366
vtkDoubleDispatcherPrivate::FunctorDoubleDispatcherHelper
Definition: vtkDispatcher_Private.h:227
vtkDispatcherPrivate::FunctorImpl::FunctorImpl
FunctorImpl()
Definition: vtkDispatcher_Private.h:114
vtkDoubleDispatcherPrivate::FunctorImpl::DoClone
virtual FunctorImpl * DoClone() const =0
vtkDoubleDispatcherPrivate::FunctorImpl
Definition: vtkDispatcher_Private.h:252
vtkDispatcherPrivate::FunctorDispatcherHelper::FunctorDispatcherHelper
FunctorDispatcherHelper(Fun fun)
Definition: vtkDispatcher_Private.h:81
vtkDoubleDispatcherPrivate::FunctorRefDispatcherHelper::FunctorRefDispatcherHelper
FunctorRefDispatcherHelper(Fun &fun)
Definition: vtkDispatcher_Private.h:211
vtkDoubleDispatcherPrivate::FunctorDoubleDispatcherHelper::operator()
ResultType operator()(BaseLhs &lhs, BaseRhs &rhs)
Definition: vtkDispatcher_Private.h:242
vtkDispatcherPrivate::FunctorDispatcherHelper
Definition: vtkDispatcher_Private.h:70
vtkDispatcherPrivate::FunctorRefDispatcherHelper
Definition: vtkDispatcher_Private.h:44
vtkDoubleDispatcherPrivate::FunctorImpl::~FunctorImpl
virtual ~FunctorImpl()
Definition: vtkDispatcher_Private.h:259
vtkDispatcherPrivate::Functor::ResultType
R ResultType
Definition: vtkDispatcher_Private.h:160
vtkDispatcherCommon
Definition: vtkDispatcher_Private.h:354
vtkDoubleDispatcherPrivate::Functor::operator=
Functor & operator=(const Functor &rhs)
Definition: vtkDispatcher_Private.h:340
vtkDispatcherPrivate::Functor::Functor
Functor(Fun fun)
Definition: vtkDispatcher_Private.h:173
vtkDispatcherCommon::DynamicCaster
Definition: vtkDispatcher_Private.h:358
vtkDispatcherPrivate::Functor
Definition: vtkDispatcher_Private.h:156
vtkDoubleDispatcherPrivate::FunctorRefDispatcherHelper
Definition: vtkDispatcher_Private.h:201
vtkDoubleDispatcherPrivate::FunctorDoubleDispatcherHelper::ResultType
RT ResultType
Definition: vtkDispatcher_Private.h:232