You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
840 lines
26 KiB
Plaintext
840 lines
26 KiB
Plaintext
/*=========================================================================
|
|
|
|
Program: Visualization Toolkit
|
|
Module: vtkArrayDispatch.txx
|
|
|
|
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
|
|
All rights reserved.
|
|
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even
|
|
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
PURPOSE. See the above copyright notice for more information.
|
|
|
|
=========================================================================*/
|
|
|
|
#ifndef vtkArrayDispatch_txx
|
|
#define vtkArrayDispatch_txx
|
|
|
|
#include "vtkArrayDispatch.h"
|
|
|
|
#include "vtkConfigure.h" // For warning macro settings.
|
|
#include "vtkSetGet.h" // For warning macros.
|
|
|
|
class vtkDataArray;
|
|
|
|
namespace vtkArrayDispatch {
|
|
namespace impl {
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Implementation of the single-array dispatch mechanism.
|
|
template <typename ArrayList>
|
|
struct Dispatch;
|
|
|
|
// Terminal case:
|
|
template<>
|
|
struct Dispatch<vtkTypeList::NullType>
|
|
{
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *, Worker&)
|
|
{
|
|
#ifdef VTK_WARN_ON_DISPATCH_FAILURE
|
|
vtkGenericWarningMacro("Array dispatch failed.");
|
|
#endif
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Recursive case:
|
|
template <
|
|
typename ArrayHead,
|
|
typename ArrayTail
|
|
>
|
|
struct Dispatch<vtkTypeList::TypeList<ArrayHead, ArrayTail> >
|
|
{
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *inArray, Worker &worker)
|
|
{
|
|
if (ArrayHead *array = vtkArrayDownCast<ArrayHead>(inArray))
|
|
{
|
|
worker(array);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return Dispatch<ArrayTail>::Execute(inArray, worker);
|
|
}
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Description:
|
|
// Implementation of the 2 array dispatch mechanism.
|
|
template <
|
|
typename ArrayList1,
|
|
typename ArrayList2
|
|
>
|
|
struct Dispatch2;
|
|
|
|
//----------------------------//
|
|
// First dispatch trampoline: //
|
|
//----------------------------//
|
|
template <
|
|
typename Array1T,
|
|
typename ArrayList2
|
|
>
|
|
struct Dispatch2Trampoline;
|
|
|
|
// Dispatch2 Terminal case:
|
|
template <typename ArrayList2>
|
|
struct Dispatch2<vtkTypeList::NullType, ArrayList2>
|
|
{
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *, vtkDataArray *, Worker &)
|
|
{
|
|
#ifdef VTK_WARN_ON_DISPATCH_FAILURE
|
|
vtkGenericWarningMacro("Dual array dispatch failed.");
|
|
#endif
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Dispatch2 Recursive case:
|
|
template <
|
|
typename Array1Head,
|
|
typename Array1Tail,
|
|
typename ArrayList2
|
|
>
|
|
struct Dispatch2<vtkTypeList::TypeList<Array1Head, Array1Tail>, ArrayList2>
|
|
{
|
|
typedef Dispatch2<Array1Tail, ArrayList2> NextDispatch;
|
|
typedef Dispatch2Trampoline<Array1Head, ArrayList2> Trampoline;
|
|
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2,
|
|
Worker &worker)
|
|
{
|
|
if (Array1Head *array = vtkArrayDownCast<Array1Head>(array1))
|
|
{
|
|
return Trampoline::Execute(array, array2, worker);
|
|
}
|
|
else
|
|
{
|
|
return NextDispatch::Execute(array1, array2, worker);
|
|
}
|
|
}
|
|
};
|
|
|
|
// Dispatch2 Trampoline terminal case:
|
|
template <typename Array1T>
|
|
struct Dispatch2Trampoline<Array1T, vtkTypeList::NullType>
|
|
{
|
|
template <typename Worker>
|
|
static bool Execute(Array1T *, vtkDataArray *, Worker &)
|
|
{
|
|
#ifdef VTK_WARN_ON_DISPATCH_FAILURE
|
|
vtkGenericWarningMacro("Dual array dispatch failed.");
|
|
#endif
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Dispatch2 Trampoline recursive case:
|
|
template <
|
|
typename Array1T,
|
|
typename Array2Head,
|
|
typename Array2Tail
|
|
>
|
|
struct Dispatch2Trampoline<
|
|
Array1T,
|
|
vtkTypeList::TypeList<Array2Head, Array2Tail>
|
|
>
|
|
{
|
|
typedef Dispatch2Trampoline<Array1T, Array2Tail> NextDispatch;
|
|
|
|
template <typename Worker>
|
|
static bool Execute(Array1T *array1, vtkDataArray *array2, Worker &worker)
|
|
{
|
|
if (Array2Head *array = vtkArrayDownCast<Array2Head>(array2))
|
|
{
|
|
worker(array1, array);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return NextDispatch::Execute(array1, array2, worker);
|
|
}
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Description:
|
|
// Implementation of the 2 array same-type dispatch mechanism.
|
|
template <
|
|
typename ArrayList1,
|
|
typename ArrayList2
|
|
>
|
|
struct Dispatch2Same;
|
|
|
|
// Terminal case:
|
|
template <typename ArrayList2>
|
|
struct Dispatch2Same<vtkTypeList::NullType, ArrayList2>
|
|
{
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *, vtkDataArray *, Worker &)
|
|
{
|
|
#ifdef VTK_WARN_ON_DISPATCH_FAILURE
|
|
vtkGenericWarningMacro("Dual array dispatch failed.");
|
|
#endif
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Recursive case:
|
|
template <
|
|
typename ArrayHead,
|
|
typename ArrayTail,
|
|
typename ArrayList2
|
|
>
|
|
struct Dispatch2Same<
|
|
vtkTypeList::TypeList<ArrayHead, ArrayTail>,
|
|
ArrayList2
|
|
>
|
|
{
|
|
typedef Dispatch2Same<ArrayTail, ArrayList2> NextDispatch;
|
|
typedef vtkTypeList_Create_1(typename ArrayHead::ValueType) ValueType;
|
|
typedef typename FilterArraysByValueType<ArrayList2, ValueType>::Result ValueArrayList;
|
|
typedef Dispatch2Trampoline<ArrayHead, ValueArrayList> Trampoline;
|
|
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2,
|
|
Worker &worker)
|
|
{
|
|
if (ArrayHead *array = vtkArrayDownCast<ArrayHead>(array1))
|
|
{
|
|
return Trampoline::Execute(array, array2, worker);
|
|
}
|
|
else
|
|
{
|
|
return NextDispatch::Execute(array1, array2, worker);
|
|
}
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Description:
|
|
// Implementation of the 3 array dispatch mechanism.
|
|
template <
|
|
typename ArrayList1,
|
|
typename ArrayList2,
|
|
typename ArrayList3
|
|
>
|
|
struct Dispatch3;
|
|
|
|
//-----------------------------//
|
|
// First dispatch trampoline: //
|
|
//---------------------------//
|
|
template <
|
|
typename Array1T,
|
|
typename ArrayList2,
|
|
typename ArrayList3
|
|
>
|
|
struct Dispatch3Trampoline1;
|
|
|
|
//------------------------------//
|
|
// Second dispatch trampoline: //
|
|
//----------------------------//
|
|
template <
|
|
typename Array1T,
|
|
typename Array2T,
|
|
typename ArrayList3
|
|
>
|
|
struct Dispatch3Trampoline2;
|
|
|
|
// Dispatch3 Terminal case:
|
|
template <
|
|
typename ArrayList2,
|
|
typename ArrayList3
|
|
>
|
|
struct Dispatch3<vtkTypeList::NullType, ArrayList2, ArrayList3>
|
|
{
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *, vtkDataArray*, vtkDataArray*, Worker&)
|
|
{
|
|
#ifdef VTK_WARN_ON_DISPATCH_FAILURE
|
|
vtkGenericWarningMacro("Triple array dispatch failed.");
|
|
#endif
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Dispatch3 Recursive case:
|
|
template <
|
|
typename ArrayHead,
|
|
typename ArrayTail,
|
|
typename ArrayList2,
|
|
typename ArrayList3
|
|
>
|
|
struct Dispatch3<vtkTypeList::TypeList<ArrayHead, ArrayTail>, ArrayList2,
|
|
ArrayList3>
|
|
{
|
|
private:
|
|
typedef Dispatch3Trampoline1<ArrayHead, ArrayList2, ArrayList3> Trampoline;
|
|
typedef Dispatch3<ArrayTail, ArrayList2, ArrayList3> NextDispatch;
|
|
public:
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2,
|
|
vtkDataArray *array3, Worker &worker)
|
|
{
|
|
if (ArrayHead *array = vtkArrayDownCast<ArrayHead>(array1))
|
|
{
|
|
return Trampoline::Execute(array, array2, array3, worker);
|
|
}
|
|
else
|
|
{
|
|
return NextDispatch::Execute(array1, array2, array3, worker);
|
|
}
|
|
}
|
|
};
|
|
|
|
// Dispatch3 Trampoline1 terminal case:
|
|
template <
|
|
typename Array1T,
|
|
typename ArrayList3
|
|
>
|
|
struct Dispatch3Trampoline1<Array1T, vtkTypeList::NullType, ArrayList3>
|
|
{
|
|
template <typename Worker>
|
|
static bool Execute(Array1T*, vtkDataArray*, vtkDataArray*, Worker&)
|
|
{
|
|
#ifdef VTK_WARN_ON_DISPATCH_FAILURE
|
|
vtkGenericWarningMacro("Triple array dispatch failed.");
|
|
#endif
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Dispatch3 Trampoline1 recursive case:
|
|
template <
|
|
typename Array1T,
|
|
typename ArrayHead,
|
|
typename ArrayTail,
|
|
typename ArrayList3
|
|
>
|
|
struct Dispatch3Trampoline1<Array1T,
|
|
vtkTypeList::TypeList<ArrayHead, ArrayTail>,
|
|
ArrayList3>
|
|
{
|
|
private:
|
|
typedef Dispatch3Trampoline2<Array1T, ArrayHead, ArrayList3> Trampoline;
|
|
typedef Dispatch3Trampoline1<Array1T, ArrayTail, ArrayList3> NextDispatch;
|
|
public:
|
|
template <typename Worker>
|
|
static bool Execute(Array1T *array1, vtkDataArray *array2,
|
|
vtkDataArray *array3, Worker &worker)
|
|
{
|
|
if (ArrayHead *array = vtkArrayDownCast<ArrayHead>(array2))
|
|
{
|
|
return Trampoline::Execute(array1, array, array3, worker);
|
|
}
|
|
else
|
|
{
|
|
return NextDispatch::Execute(array1, array2, array3, worker);
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
// Dispatch3 Trampoline2 terminal case:
|
|
template <
|
|
typename Array1T,
|
|
typename Array2T
|
|
>
|
|
struct Dispatch3Trampoline2<Array1T, Array2T, vtkTypeList::NullType>
|
|
{
|
|
template <typename Worker>
|
|
static bool Execute(Array1T*, Array2T*, vtkDataArray*, Worker&)
|
|
{
|
|
#ifdef VTK_WARN_ON_DISPATCH_FAILURE
|
|
vtkGenericWarningMacro("Triple array dispatch failed.");
|
|
#endif
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Dispatch3 Trampoline2 recursive case:
|
|
template <
|
|
typename Array1T,
|
|
typename Array2T,
|
|
typename ArrayHead,
|
|
typename ArrayTail
|
|
>
|
|
struct Dispatch3Trampoline2<Array1T, Array2T,
|
|
vtkTypeList::TypeList<ArrayHead, ArrayTail> >
|
|
{
|
|
private:
|
|
typedef Dispatch3Trampoline2<Array1T, Array2T, ArrayTail> NextDispatch;
|
|
public:
|
|
template <typename Worker>
|
|
static bool Execute(Array1T *array1, Array2T *array2,
|
|
vtkDataArray *array3, Worker &worker)
|
|
{
|
|
if (ArrayHead *array = vtkArrayDownCast<ArrayHead>(array3))
|
|
{
|
|
worker(array1, array2, array);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return NextDispatch::Execute(array1, array2, array3, worker);
|
|
}
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Description:
|
|
// Dispatch three arrays, enforcing that all three have the same ValueType.
|
|
// Initially, set both ArraysToTest and ArrayList to the same TypeList.
|
|
// ArraysToTest is iterated through, while ArrayList is preserved for later
|
|
// dispatches.
|
|
template <
|
|
typename ArrayList1,
|
|
typename ArrayList2,
|
|
typename ArrayList3
|
|
>
|
|
struct Dispatch3Same;
|
|
|
|
// Dispatch3Same terminal case:
|
|
template <typename ArrayList2, typename ArrayList3>
|
|
struct Dispatch3Same<vtkTypeList::NullType, ArrayList2, ArrayList3>
|
|
{
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray*, vtkDataArray*,
|
|
vtkDataArray*, Worker&)
|
|
{
|
|
#ifdef VTK_WARN_ON_DISPATCH_FAILURE
|
|
vtkGenericWarningMacro("Triple array dispatch failed.");
|
|
#endif
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Dispatch3Same recursive case:
|
|
template <
|
|
typename ArrayHead,
|
|
typename ArrayTail,
|
|
typename ArrayList2,
|
|
typename ArrayList3
|
|
>
|
|
struct Dispatch3Same<
|
|
vtkTypeList::TypeList<ArrayHead, ArrayTail>,
|
|
ArrayList2,
|
|
ArrayList3
|
|
>
|
|
{
|
|
private:
|
|
typedef vtkTypeList_Create_1(typename ArrayHead::ValueType) ValueType;
|
|
typedef typename FilterArraysByValueType<ArrayList2, ValueType>::Result ValueArrays2;
|
|
typedef typename FilterArraysByValueType<ArrayList3, ValueType>::Result ValueArrays3;
|
|
typedef Dispatch3Trampoline1<ArrayHead, ValueArrays2, ValueArrays3> Trampoline;
|
|
typedef Dispatch3Same<ArrayTail, ArrayList2, ArrayList3> NextDispatch;
|
|
public:
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2,
|
|
vtkDataArray *array3, Worker &worker)
|
|
{
|
|
if (ArrayHead *array = vtkArrayDownCast<ArrayHead>(array1))
|
|
{
|
|
return Trampoline::Execute(array, array2, array3, worker);
|
|
}
|
|
else
|
|
{
|
|
return NextDispatch::Execute(array1, array2, array3, worker);
|
|
}
|
|
}
|
|
};
|
|
|
|
} // end namespace impl
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FilterArraysByValueType implementation:
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Terminal case:
|
|
template <typename ValueList>
|
|
struct FilterArraysByValueType<vtkTypeList::NullType, ValueList>
|
|
{
|
|
typedef vtkTypeList::NullType Result;
|
|
};
|
|
|
|
// Recursive case:
|
|
template <typename ArrayHead, typename ArrayTail, typename ValueList>
|
|
struct FilterArraysByValueType<vtkTypeList::TypeList<ArrayHead, ArrayTail>,
|
|
ValueList>
|
|
{
|
|
private:
|
|
typedef typename ArrayHead::ValueType ValueType;
|
|
enum { ValueIsAllowed =
|
|
vtkTypeList::IndexOf<ValueList, ValueType>::Result >= 0 };
|
|
typedef typename FilterArraysByValueType<ArrayTail, ValueList>::Result NewTail;
|
|
public:
|
|
typedef typename vtkTypeList::Select<ValueIsAllowed,
|
|
vtkTypeList::TypeList<ArrayHead, NewTail>,
|
|
NewTail>::Result Result;
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// DispatchByArray implementation:
|
|
//------------------------------------------------------------------------------
|
|
// Preprocess and pass off to impl::Dispatch:
|
|
template <
|
|
typename ArrayHead,
|
|
typename ArrayTail
|
|
>
|
|
struct DispatchByArray<vtkTypeList::TypeList<ArrayHead, ArrayTail> >
|
|
{
|
|
private:
|
|
typedef vtkTypeList::TypeList<ArrayHead, ArrayTail> ArrayList;
|
|
typedef typename vtkTypeList::Unique<ArrayList>::Result UniqueArrays;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArrays>::Result SortedUniqueArrays;
|
|
typedef impl::Dispatch<SortedUniqueArrays> ArrayDispatcher;
|
|
public:
|
|
DispatchByArray() {}
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *inArray, Worker &worker)
|
|
{
|
|
return ArrayDispatcher::Execute(inArray, worker);
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Dispatch implementation:
|
|
// (defined after DispatchByArray to prevent 'incomplete type' errors)
|
|
//------------------------------------------------------------------------------
|
|
struct Dispatch
|
|
{
|
|
private:
|
|
typedef DispatchByArray<Arrays> Dispatcher;
|
|
public:
|
|
Dispatch() {}
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array, Worker &worker)
|
|
{
|
|
return Dispatcher::Execute(array, worker);
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// DispatchByValueType implementation:
|
|
//------------------------------------------------------------------------------
|
|
// Preprocess and pass off to impl::Dispatch
|
|
template <
|
|
typename ValueTypeHead,
|
|
typename ValueTypeTail
|
|
>
|
|
struct DispatchByValueType<vtkTypeList::TypeList<ValueTypeHead, ValueTypeTail> >
|
|
{
|
|
private:
|
|
typedef vtkTypeList::TypeList<ValueTypeHead, ValueTypeTail> ValueTypeList;
|
|
typedef typename FilterArraysByValueType<Arrays, ValueTypeList>::Result ArrayList;
|
|
typedef typename vtkTypeList::Unique<ArrayList>::Result UniqueArrays;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArrays>::Result SortedUniqueArrays;
|
|
typedef impl::Dispatch<SortedUniqueArrays> ArrayDispatcher;
|
|
public:
|
|
DispatchByValueType() {}
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *inArray, Worker &worker)
|
|
{
|
|
return ArrayDispatcher::Execute(inArray, worker);
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Dispatch2ByArray implementation:
|
|
//------------------------------------------------------------------------------
|
|
// Preprocess and pass off to impl::Dispatch2:
|
|
template <
|
|
typename ArrayList1,
|
|
typename ArrayList2
|
|
>
|
|
struct Dispatch2ByArray
|
|
{
|
|
private:
|
|
typedef typename vtkTypeList::Unique<ArrayList1>::Result UniqueArray1;
|
|
typedef typename vtkTypeList::Unique<ArrayList2>::Result UniqueArray2;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray1>::Result SortedUniqueArray1;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray2>::Result SortedUniqueArray2;
|
|
typedef impl::Dispatch2<SortedUniqueArray1, SortedUniqueArray2> ArrayDispatcher;
|
|
public:
|
|
Dispatch2ByArray() {}
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2,
|
|
Worker &worker)
|
|
{
|
|
return ArrayDispatcher::Execute(array1, array2, worker);
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Dispatch2 implementation:
|
|
//------------------------------------------------------------------------------
|
|
struct Dispatch2
|
|
{
|
|
private:
|
|
typedef Dispatch2ByArray<vtkArrayDispatch::Arrays, vtkArrayDispatch::Arrays> Dispatcher;
|
|
public:
|
|
Dispatch2() {}
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2,
|
|
Worker &worker)
|
|
{
|
|
return Dispatcher::Execute(array1, array2, worker);
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Dispatch2ByValueType implementation:
|
|
//------------------------------------------------------------------------------
|
|
// Preprocess and pass off to impl::Dispatch2
|
|
template <
|
|
typename ValueTypeList1,
|
|
typename ValueTypeList2
|
|
>
|
|
struct Dispatch2ByValueType
|
|
{
|
|
private:
|
|
typedef typename FilterArraysByValueType<Arrays, ValueTypeList1>::Result ArrayList1;
|
|
typedef typename FilterArraysByValueType<Arrays, ValueTypeList2>::Result ArrayList2;
|
|
typedef typename vtkTypeList::Unique<ArrayList1>::Result UniqueArray1;
|
|
typedef typename vtkTypeList::Unique<ArrayList2>::Result UniqueArray2;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray1>::Result SortedUniqueArray1;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray2>::Result SortedUniqueArray2;
|
|
typedef impl::Dispatch2<SortedUniqueArray1, SortedUniqueArray2> ArrayDispatcher;
|
|
public:
|
|
Dispatch2ByValueType() {}
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2, Worker &worker)
|
|
{
|
|
return ArrayDispatcher::Execute(array1, array2, worker);
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Dispatch2BySameValueType implementation:
|
|
//------------------------------------------------------------------------------
|
|
// Preprocess and pass off to impl::Dispatch2Same
|
|
template <typename ValueTypeList>
|
|
struct Dispatch2BySameValueType
|
|
{
|
|
private:
|
|
typedef typename FilterArraysByValueType<Arrays, ValueTypeList>::Result ArrayList;
|
|
typedef typename vtkTypeList::Unique<ArrayList>::Result UniqueArray;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray>::Result SortedUniqueArray;
|
|
typedef impl::Dispatch2Same<SortedUniqueArray, SortedUniqueArray> Dispatcher;
|
|
public:
|
|
Dispatch2BySameValueType() {}
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2,
|
|
Worker &worker)
|
|
{
|
|
return Dispatcher::Execute(array1, array2, worker);
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Dispatch2ByArrayWithSameValueType implementation:
|
|
//------------------------------------------------------------------------------
|
|
// Preprocess and pass off to impl::Dispatch2Same
|
|
template <
|
|
typename ArrayList1,
|
|
typename ArrayList2
|
|
>
|
|
struct Dispatch2ByArrayWithSameValueType
|
|
{
|
|
private:
|
|
typedef typename vtkTypeList::Unique<ArrayList1>::Result UniqueArray1;
|
|
typedef typename vtkTypeList::Unique<ArrayList2>::Result UniqueArray2;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray1>::Result SortedUniqueArray1;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray2>::Result SortedUniqueArray2;
|
|
typedef impl::Dispatch2Same<SortedUniqueArray1, SortedUniqueArray2> Dispatcher;
|
|
public:
|
|
Dispatch2ByArrayWithSameValueType() {}
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2,
|
|
Worker &worker)
|
|
{
|
|
return Dispatcher::Execute(array1, array2, worker);
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Dispatch2SameValueType implementation:
|
|
//------------------------------------------------------------------------------
|
|
struct Dispatch2SameValueType
|
|
{
|
|
private:
|
|
typedef Dispatch2ByArrayWithSameValueType<vtkArrayDispatch::Arrays, vtkArrayDispatch::Arrays> Dispatcher;
|
|
public:
|
|
Dispatch2SameValueType() {}
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2,
|
|
Worker &worker)
|
|
{
|
|
return Dispatcher::Execute(array1, array2, worker);
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Dispatch3ByArray implementation:
|
|
//------------------------------------------------------------------------------
|
|
// Preprocess and pass off to impl::Dispatch3:
|
|
template <
|
|
typename ArrayList1,
|
|
typename ArrayList2,
|
|
typename ArrayList3
|
|
>
|
|
struct Dispatch3ByArray
|
|
{
|
|
private:
|
|
typedef typename vtkTypeList::Unique<ArrayList1>::Result UniqueArray1;
|
|
typedef typename vtkTypeList::Unique<ArrayList2>::Result UniqueArray2;
|
|
typedef typename vtkTypeList::Unique<ArrayList3>::Result UniqueArray3;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray1>::Result SortedUniqueArray1;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray2>::Result SortedUniqueArray2;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray3>::Result SortedUniqueArray3;
|
|
typedef impl::Dispatch3<SortedUniqueArray1, SortedUniqueArray2, SortedUniqueArray3> ArrayDispatcher;
|
|
public:
|
|
Dispatch3ByArray() {}
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2,
|
|
vtkDataArray *array3, Worker &worker)
|
|
{
|
|
return ArrayDispatcher::Execute(array1, array2, array3, worker);
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Dispatch3 implementation:
|
|
//------------------------------------------------------------------------------
|
|
struct Dispatch3
|
|
{
|
|
private:
|
|
typedef Dispatch3ByArray<vtkArrayDispatch::Arrays,
|
|
vtkArrayDispatch::Arrays,
|
|
vtkArrayDispatch::Arrays> Dispatcher;
|
|
public:
|
|
Dispatch3() {}
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2,
|
|
vtkDataArray *array3, Worker &worker)
|
|
{
|
|
return Dispatcher::Execute(array1, array2, array3, worker);
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Dispatch3ByValueType implementation:
|
|
//------------------------------------------------------------------------------
|
|
// Preprocess and pass off to impl::Dispatch3
|
|
template <
|
|
typename ValueTypeList1,
|
|
typename ValueTypeList2,
|
|
typename ValueTypeList3
|
|
>
|
|
struct Dispatch3ByValueType
|
|
{
|
|
private:
|
|
typedef typename FilterArraysByValueType<Arrays, ValueTypeList1>::Result ArrayList1;
|
|
typedef typename FilterArraysByValueType<Arrays, ValueTypeList2>::Result ArrayList2;
|
|
typedef typename FilterArraysByValueType<Arrays, ValueTypeList3>::Result ArrayList3;
|
|
typedef typename vtkTypeList::Unique<ArrayList1>::Result UniqueArray1;
|
|
typedef typename vtkTypeList::Unique<ArrayList2>::Result UniqueArray2;
|
|
typedef typename vtkTypeList::Unique<ArrayList3>::Result UniqueArray3;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray1>::Result SortedUniqueArray1;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray2>::Result SortedUniqueArray2;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray3>::Result SortedUniqueArray3;
|
|
typedef impl::Dispatch3<SortedUniqueArray1, SortedUniqueArray2, SortedUniqueArray3> ArrayDispatcher;
|
|
public:
|
|
Dispatch3ByValueType() {}
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2,
|
|
vtkDataArray *array3, Worker &worker)
|
|
{
|
|
return ArrayDispatcher::Execute(array1, array2, array3, worker);
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Dispatch3BySameValueType implementation:
|
|
//------------------------------------------------------------------------------
|
|
// Preprocess and pass off to impl::Dispatch3Same
|
|
template <typename ValueTypeList>
|
|
struct Dispatch3BySameValueType
|
|
{
|
|
private:
|
|
typedef typename FilterArraysByValueType<Arrays, ValueTypeList>::Result ArrayList;
|
|
typedef typename vtkTypeList::Unique<ArrayList>::Result UniqueArray;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray>::Result SortedUniqueArray;
|
|
typedef impl::Dispatch3Same<SortedUniqueArray, SortedUniqueArray, SortedUniqueArray> Dispatcher;
|
|
public:
|
|
Dispatch3BySameValueType() {}
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2,
|
|
vtkDataArray *array3, Worker &worker)
|
|
{
|
|
return Dispatcher::Execute(array1, array2, array3, worker);
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Dispatch3BySameValueType implementation:
|
|
//------------------------------------------------------------------------------
|
|
// Preprocess and pass off to impl::Dispatch3Same
|
|
template <
|
|
typename ArrayList1,
|
|
typename ArrayList2,
|
|
typename ArrayList3
|
|
>
|
|
struct Dispatch3ByArrayWithSameValueType
|
|
{
|
|
private:
|
|
typedef typename vtkTypeList::Unique<ArrayList1>::Result UniqueArray1;
|
|
typedef typename vtkTypeList::Unique<ArrayList2>::Result UniqueArray2;
|
|
typedef typename vtkTypeList::Unique<ArrayList3>::Result UniqueArray3;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray1>::Result SortedUniqueArray1;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray2>::Result SortedUniqueArray2;
|
|
typedef typename vtkTypeList::DerivedToFront<UniqueArray3>::Result SortedUniqueArray3;
|
|
typedef impl::Dispatch3Same<SortedUniqueArray1, SortedUniqueArray2, SortedUniqueArray3> Dispatcher;
|
|
public:
|
|
Dispatch3ByArrayWithSameValueType() {}
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2,
|
|
vtkDataArray *array3, Worker &worker)
|
|
{
|
|
return Dispatcher::Execute(array1, array2, array3, worker);
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Dispatch3SameValueType implementation:
|
|
//------------------------------------------------------------------------------
|
|
struct Dispatch3SameValueType
|
|
{
|
|
private:
|
|
typedef Dispatch3ByArrayWithSameValueType<vtkArrayDispatch::Arrays,
|
|
vtkArrayDispatch::Arrays,
|
|
vtkArrayDispatch::Arrays> Dispatcher;
|
|
public:
|
|
Dispatch3SameValueType() {}
|
|
template <typename Worker>
|
|
static bool Execute(vtkDataArray *array1, vtkDataArray *array2,
|
|
vtkDataArray *array3, Worker &worker)
|
|
{
|
|
return Dispatcher::Execute(array1, array2, array3, worker);
|
|
}
|
|
};
|
|
|
|
} // end namespace vtkArrayDispatch
|
|
|
|
#endif // vtkArrayDispatch_txx
|