Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-08 13:23:51 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Clarify intent of TypeString and TypeName functions.

Browse Source 
TypeName is used for logging, and is now TypeToString.

TypeString is used for serialization, and is now SerializableTypeString.
This commit is contained in:
Allison Vacanti 2019-02-28 13:15:27 -05:00
parent 702e22765f
commit d1db4ef8b3
38 changed files with 175 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
vtkm/cont/ArrayHandle.h
View File

@ -29,6 +29,7 @@
#include <vtkm/cont/ArrayPortalToIterators.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/ErrorInternal.h>
#include <vtkm/cont/SerializableTypeString.h>
#include <vtkm/cont/Serialization.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/StorageBasic.h>
@ -683,11 +684,11 @@ namespace cont
{
template <typename T>
struct TypeString<ArrayHandle<T>>
struct SerializableTypeString<ArrayHandle<T>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH<" + TypeString<T>::Get() + ">";
static std::string name = "AH<" + SerializableTypeString<T>::Get() + ">";
return name;
}
};

10
vtkm/cont/ArrayHandleCartesianProduct.h
View File

@ -438,21 +438,21 @@ namespace cont
{
template <typename AH1, typename AH2, typename AH3>
struct TypeString<vtkm::cont::ArrayHandleCartesianProduct<AH1, AH2, AH3>>
struct SerializableTypeString<vtkm::cont::ArrayHandleCartesianProduct<AH1, AH2, AH3>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH_CartesianProduct<" + TypeString<AH1>::Get() + "," +
TypeString<AH2>::Get() + "," + TypeString<AH3>::Get() + ">";
static std::string name = "AH_CartesianProduct<" + SerializableTypeString<AH1>::Get() + "," +
SerializableTypeString<AH2>::Get() + "," + SerializableTypeString<AH3>::Get() + ">";
return name;
}
};
template <typename AH1, typename AH2, typename AH3>
struct TypeString<
struct SerializableTypeString<
vtkm::cont::ArrayHandle<vtkm::Vec<typename AH1::ValueType, 3>,
vtkm::cont::internal::StorageTagCartesianProduct<AH1, AH2, AH3>>>
: TypeString<vtkm::cont::ArrayHandleCartesianProduct<AH1, AH2, AH3>>
: SerializableTypeString<vtkm::cont::ArrayHandleCartesianProduct<AH1, AH2, AH3>>
{
};
}

10
vtkm/cont/ArrayHandleCast.h
View File

@ -110,19 +110,19 @@ namespace cont
{
template <typename T1, typename T2>
struct TypeString<vtkm::cont::internal::Cast<T1, T2>>
struct SerializableTypeString<vtkm::cont::internal::Cast<T1, T2>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_Cast_Functor<" + TypeString<T1>::Get() + "," + TypeString<T2>::Get() + ">";
static std::string name = "AH_Cast_Functor<" + SerializableTypeString<T1>::Get() + "," +
SerializableTypeString<T2>::Get() + ">";
return name;
}
};
template <typename T, typename AH>
struct TypeString<vtkm::cont::ArrayHandleCast<T, AH>>
: TypeString<
struct SerializableTypeString<vtkm::cont::ArrayHandleCast<T, AH>>
: SerializableTypeString<
vtkm::cont::ArrayHandleTransform<AH, vtkm::cont::internal::Cast<typename AH::ValueType, T>>>
{
};

8
vtkm/cont/ArrayHandleCompositeVector.h
View File

@ -732,21 +732,21 @@ namespace cont
{
template <typename... AHs>
struct TypeString<vtkm::cont::ArrayHandleCompositeVector<AHs...>>
struct SerializableTypeString<vtkm::cont::ArrayHandleCompositeVector<AHs...>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_CompositeVector<" + internal::GetVariadicTypeString(AHs{}...) + ">";
"AH_CompositeVector<" + internal::GetVariadicSerializableTypeString(AHs{}...) + ">";
return name;
}
};
template <typename... AHs>
struct TypeString<vtkm::cont::ArrayHandle<
struct SerializableTypeString<vtkm::cont::ArrayHandle<
typename vtkm::cont::internal::compvec::GetValueType<vtkmstd::tuple<AHs...>>::ValueType,
vtkm::cont::internal::StorageTagCompositeVector<vtkmstd::tuple<AHs...>>>>
: TypeString<vtkm::cont::ArrayHandleCompositeVector<AHs...>>
: SerializableTypeString<vtkm::cont::ArrayHandleCompositeVector<AHs...>>
{
};
}

10
vtkm/cont/ArrayHandleConcatenate.h
View File

@ -332,20 +332,20 @@ namespace cont
{
template <typename AH1, typename AH2>
struct TypeString<vtkm::cont::ArrayHandleConcatenate<AH1, AH2>>
struct SerializableTypeString<vtkm::cont::ArrayHandleConcatenate<AH1, AH2>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_Concatenate<" + TypeString<AH1>::Get() + "," + TypeString<AH2>::Get() + ">";
static std::string name = "AH_Concatenate<" + SerializableTypeString<AH1>::Get() + "," +
SerializableTypeString<AH2>::Get() + ">";
return name;
}
};
template <typename AH1, typename AH2>
struct TypeString<
struct SerializableTypeString<
vtkm::cont::ArrayHandle<typename AH1::ValueType, vtkm::cont::StorageTagConcatenate<AH1, AH2>>>
: TypeString<vtkm::cont::ArrayHandleConcatenate<AH1, AH2>>
: SerializableTypeString<vtkm::cont::ArrayHandleConcatenate<AH1, AH2>>
{
};
}

8
vtkm/cont/ArrayHandleConstant.h
View File

@ -93,18 +93,18 @@ namespace cont
{
template <typename T>
struct TypeString<vtkm::cont::detail::ConstantFunctor<T>>
struct SerializableTypeString<vtkm::cont::detail::ConstantFunctor<T>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH_ConstantFunctor<" + TypeString<T>::Get() + ">";
static std::string name = "AH_ConstantFunctor<" + SerializableTypeString<T>::Get() + ">";
return name;
}
};
template <typename T>
struct TypeString<vtkm::cont::ArrayHandleConstant<T>>
: TypeString<vtkm::cont::ArrayHandleImplicit<vtkm::cont::detail::ConstantFunctor<T>>>
struct SerializableTypeString<vtkm::cont::ArrayHandleConstant<T>>
: SerializableTypeString<vtkm::cont::ArrayHandleImplicit<vtkm::cont::detail::ConstantFunctor<T>>>
{
};
}

8
vtkm/cont/ArrayHandleCounting.h
View File

@ -156,19 +156,19 @@ namespace cont
{
template <typename T>
struct TypeString<vtkm::cont::ArrayHandleCounting<T>>
struct SerializableTypeString<vtkm::cont::ArrayHandleCounting<T>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH_Counting<" + TypeString<T>::Get() + ">";
static std::string name = "AH_Counting<" + SerializableTypeString<T>::Get() + ">";
return name;
}
};
template <typename T>
struct TypeString<
struct SerializableTypeString<
vtkm::cont::ArrayHandle<T, typename vtkm::cont::ArrayHandleCounting<T>::StorageTag>>
: TypeString<vtkm::cont::ArrayHandleCounting<T>>
: SerializableTypeString<vtkm::cont::ArrayHandleCounting<T>>
{
};
}

8
vtkm/cont/ArrayHandleExtractComponent.h
View File

@ -318,20 +318,20 @@ namespace cont
{
template <typename AH>
struct TypeString<vtkm::cont::ArrayHandleExtractComponent<AH>>
struct SerializableTypeString<vtkm::cont::ArrayHandleExtractComponent<AH>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH_ExtractComponent<" + TypeString<AH>::Get() + ">";
static std::string name = "AH_ExtractComponent<" + SerializableTypeString<AH>::Get() + ">";
return name;
}
};
template <typename AH>
struct TypeString<
struct SerializableTypeString<
vtkm::cont::ArrayHandle<typename vtkm::VecTraits<typename AH::ValueType>::ComponentType,
vtkm::cont::StorageTagExtractComponent<AH>>>
: TypeString<vtkm::cont::ArrayHandleExtractComponent<AH>>
: SerializableTypeString<vtkm::cont::ArrayHandleExtractComponent<AH>>
{
};
}

11
vtkm/cont/ArrayHandleGroupVec.h
View File

@ -374,20 +374,21 @@ namespace cont
{
template <typename AH, vtkm::IdComponent NUM_COMPS>
struct TypeString<vtkm::cont::ArrayHandleGroupVec<AH, NUM_COMPS>>
struct SerializableTypeString<vtkm::cont::ArrayHandleGroupVec<AH, NUM_COMPS>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_GroupVec<" + TypeString<AH>::Get() + "," + std::to_string(NUM_COMPS) + ">";
"AH_GroupVec<" + SerializableTypeString<AH>::Get() + "," + std::to_string(NUM_COMPS) + ">";
return name;
}
};
template <typename AH, vtkm::IdComponent NUM_COMPS>
struct TypeString<vtkm::cont::ArrayHandle<vtkm::Vec<typename AH::ValueType, NUM_COMPS>,
vtkm::cont::internal::StorageTagGroupVec<AH, NUM_COMPS>>>
: TypeString<vtkm::cont::ArrayHandleGroupVec<AH, NUM_COMPS>>
struct SerializableTypeString<
vtkm::cont::ArrayHandle<vtkm::Vec<typename AH::ValueType, NUM_COMPS>,
vtkm::cont::internal::StorageTagGroupVec<AH, NUM_COMPS>>>
: SerializableTypeString<vtkm::cont::ArrayHandleGroupVec<AH, NUM_COMPS>>
{
};
}

10
vtkm/cont/ArrayHandleGroupVecVariable.h
View File

@ -514,21 +514,21 @@ namespace cont
{
template <typename SAH, typename OAH>
struct TypeString<vtkm::cont::ArrayHandleGroupVecVariable<SAH, OAH>>
struct SerializableTypeString<vtkm::cont::ArrayHandleGroupVecVariable<SAH, OAH>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_GroupVecVariable<" + TypeString<SAH>::Get() + "," + TypeString<OAH>::Get() + ">";
static std::string name = "AH_GroupVecVariable<" + SerializableTypeString<SAH>::Get() + "," +
SerializableTypeString<OAH>::Get() + ">";
return name;
}
};
template <typename SAH, typename OAH>
struct TypeString<
struct SerializableTypeString<
vtkm::cont::ArrayHandle<vtkm::VecFromPortal<typename SAH::PortalControl>,
vtkm::cont::internal::StorageTagGroupVecVariable<SAH, OAH>>>
: TypeString<vtkm::cont::ArrayHandleGroupVecVariable<SAH, OAH>>
: SerializableTypeString<vtkm::cont::ArrayHandleGroupVecVariable<SAH, OAH>>
{
};
}

8
vtkm/cont/ArrayHandleImplicit.h
View File

@ -154,20 +154,20 @@ namespace cont
{
template <typename Functor>
struct TypeString<vtkm::cont::ArrayHandleImplicit<Functor>>
struct SerializableTypeString<vtkm::cont::ArrayHandleImplicit<Functor>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH_Implicit<" + TypeString<Functor>::Get() + ">";
static std::string name = "AH_Implicit<" + SerializableTypeString<Functor>::Get() + ">";
return name;
}
};
template <typename Functor>
struct TypeString<vtkm::cont::ArrayHandle<
struct SerializableTypeString<vtkm::cont::ArrayHandle<
typename vtkm::cont::detail::ArrayHandleImplicitTraits<Functor>::ValueType,
vtkm::cont::StorageTagImplicit<vtkm::cont::detail::ArrayPortalImplicit<Functor>>>>
: TypeString<vtkm::cont::ArrayHandleImplicit<Functor>>
: SerializableTypeString<vtkm::cont::ArrayHandleImplicit<Functor>>
{
};
}

6
vtkm/cont/ArrayHandleIndex.h
View File

@ -70,14 +70,14 @@ namespace cont
{
template <>
struct TypeString<vtkm::cont::detail::IndexFunctor>
struct SerializableTypeString<vtkm::cont::detail::IndexFunctor>
{
static VTKM_CONT const std::string Get() { return "AH_IndexFunctor"; }
};
template <>
struct TypeString<vtkm::cont::ArrayHandleIndex>
: TypeString<vtkm::cont::ArrayHandleImplicit<vtkm::cont::detail::IndexFunctor>>
struct SerializableTypeString<vtkm::cont::ArrayHandleIndex>
: SerializableTypeString<vtkm::cont::ArrayHandleImplicit<vtkm::cont::detail::IndexFunctor>>
{
};
}

10
vtkm/cont/ArrayHandlePermutation.h
View File

@ -380,21 +380,21 @@ namespace cont
{
template <typename IdxAH, typename ValAH>
struct TypeString<vtkm::cont::ArrayHandlePermutation<IdxAH, ValAH>>
struct SerializableTypeString<vtkm::cont::ArrayHandlePermutation<IdxAH, ValAH>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_Permutation<" + TypeString<IdxAH>::Get() + "," + TypeString<ValAH>::Get() + ">";
static std::string name = "AH_Permutation<" + SerializableTypeString<IdxAH>::Get() + "," +
SerializableTypeString<ValAH>::Get() + ">";
return name;
}
};
template <typename IdxAH, typename ValAH>
struct TypeString<
struct SerializableTypeString<
vtkm::cont::ArrayHandle<typename ValAH::ValueType,
vtkm::cont::internal::StorageTagPermutation<IdxAH, ValAH>>>
: TypeString<vtkm::cont::ArrayHandlePermutation<IdxAH, ValAH>>
: SerializableTypeString<vtkm::cont::ArrayHandlePermutation<IdxAH, ValAH>>
{
};
}

8
vtkm/cont/ArrayHandleReverse.h
View File

@ -251,19 +251,19 @@ namespace cont
{
template <typename AH>
struct TypeString<vtkm::cont::ArrayHandleReverse<AH>>
struct SerializableTypeString<vtkm::cont::ArrayHandleReverse<AH>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH_Reverse<" + TypeString<AH>::Get() + ">";
static std::string name = "AH_Reverse<" + SerializableTypeString<AH>::Get() + ">";
return name;
}
};
template <typename AH>
struct TypeString<
struct SerializableTypeString<
vtkm::cont::ArrayHandle<typename AH::ValueType, vtkm::cont::StorageTagReverse<AH>>>
: TypeString<vtkm::cont::ArrayHandleReverse<AH>>
: SerializableTypeString<vtkm::cont::ArrayHandleReverse<AH>>
{
};
}

8
vtkm/cont/ArrayHandleSwizzle.h
View File

@ -406,21 +406,21 @@ namespace cont
{
template <typename AH, vtkm::IdComponent NComps>
struct TypeString<vtkm::cont::ArrayHandleSwizzle<AH, NComps>>
struct SerializableTypeString<vtkm::cont::ArrayHandleSwizzle<AH, NComps>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_Swizzle<" + TypeString<AH>::Get() + "," + std::to_string(NComps) + ">";
"AH_Swizzle<" + SerializableTypeString<AH>::Get() + "," + std::to_string(NComps) + ">";
return name;
}
};
template <typename AH, vtkm::IdComponent NComps>
struct TypeString<vtkm::cont::ArrayHandle<
struct SerializableTypeString<vtkm::cont::ArrayHandle<
vtkm::Vec<typename vtkm::VecTraits<typename AH::ValueType>::ComponentType, NComps>,
vtkm::cont::StorageTagSwizzle<AH, NComps>>>
: TypeString<vtkm::cont::ArrayHandleSwizzle<AH, NComps>>
: SerializableTypeString<vtkm::cont::ArrayHandleSwizzle<AH, NComps>>
{
};
}

17
vtkm/cont/ArrayHandleTransform.h
View File

@ -747,32 +747,33 @@ namespace cont
{
template <typename AH, typename Functor, typename InvFunctor>
struct TypeString<vtkm::cont::ArrayHandleTransform<AH, Functor, InvFunctor>>
struct SerializableTypeString<vtkm::cont::ArrayHandleTransform<AH, Functor, InvFunctor>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH_Transform<" + TypeString<AH>::Get() + "," +
TypeString<Functor>::Get() + "," + TypeString<InvFunctor>::Get() + ">";
static std::string name = "AH_Transform<" + SerializableTypeString<AH>::Get() + "," +
SerializableTypeString<Functor>::Get() + "," + SerializableTypeString<InvFunctor>::Get() +
">";
return name;
}
};
template <typename AH, typename Functor>
struct TypeString<vtkm::cont::ArrayHandleTransform<AH, Functor>>
struct SerializableTypeString<vtkm::cont::ArrayHandleTransform<AH, Functor>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_Transform<" + TypeString<AH>::Get() + "," + TypeString<Functor>::Get() + ">";
static std::string name = "AH_Transform<" + SerializableTypeString<AH>::Get() + "," +
SerializableTypeString<Functor>::Get() + ">";
return name;
}
};
template <typename AH, typename Functor, typename InvFunctor>
struct TypeString<vtkm::cont::ArrayHandle<
struct SerializableTypeString<vtkm::cont::ArrayHandle<
typename vtkm::cont::internal::StorageTagTransform<AH, Functor, InvFunctor>::ValueType,
vtkm::cont::internal::StorageTagTransform<AH, Functor, InvFunctor>>>
: TypeString<vtkm::cont::ArrayHandleTransform<AH, Functor, InvFunctor>>
: SerializableTypeString<vtkm::cont::ArrayHandleTransform<AH, Functor, InvFunctor>>
{
};
}

6
vtkm/cont/ArrayHandleUniformPointCoordinates.h
View File

@ -70,16 +70,16 @@ namespace cont
{
template <>
struct TypeString<vtkm::cont::ArrayHandleUniformPointCoordinates>
struct SerializableTypeString<vtkm::cont::ArrayHandleUniformPointCoordinates>
{
static VTKM_CONT const std::string Get() { return "AH_UniformPointCoordinates"; }
};
template <>
struct TypeString<vtkm::cont::ArrayHandle<
struct SerializableTypeString<vtkm::cont::ArrayHandle<
vtkm::Vec<vtkm::FloatDefault, 3>,
vtkm::cont::StorageTagImplicit<vtkm::internal::ArrayPortalUniformPointCoordinates>>>
: TypeString<vtkm::cont::ArrayHandleUniformPointCoordinates>
: SerializableTypeString<vtkm::cont::ArrayHandleUniformPointCoordinates>
{
};
}

10
vtkm/cont/ArrayHandleVirtual.h
View File

@ -393,7 +393,7 @@ private:
std::true_type vtkmNotUsed(notFromArrayHandleVirtual)) const
{
VTKM_LOG_CAST_FAIL(*this, ArrayHandleType);
throwFailedDynamicCast("ArrayHandleVirtual", vtkm::cont::TypeName<ArrayHandleType>());
throwFailedDynamicCast("ArrayHandleVirtual", vtkm::cont::TypeToString<ArrayHandleType>());
return ArrayHandleType{};
}
@ -402,7 +402,7 @@ private:
std::false_type vtkmNotUsed(notFromArrayHandleVirtual)) const
{
VTKM_LOG_CAST_FAIL(*this, ArrayHandleType);
throwFailedDynamicCast("ArrayHandleVirtual", vtkm::cont::TypeName<ArrayHandleType>());
throwFailedDynamicCast("ArrayHandleVirtual", vtkm::cont::TypeToString<ArrayHandleType>());
return ArrayHandleType{};
}
@ -417,7 +417,7 @@ private:
if (!derived)
{
VTKM_LOG_CAST_FAIL(*this, ArrayHandleType);
throwFailedDynamicCast("ArrayHandleVirtual", vtkm::cont::TypeName<ArrayHandleType>());
throwFailedDynamicCast("ArrayHandleVirtual", vtkm::cont::TypeToString<ArrayHandleType>());
}
VTKM_LOG_CAST_SUCC(*this, derived);
return *derived;
@ -492,11 +492,11 @@ void CastAndCall(vtkm::cont::ArrayHandleVirtual<vtkm::Vec<vtkm::FloatDefault, 3>
//=============================================================================
// Specializations of serialization related classes
template <typename T>
struct TypeString<vtkm::cont::ArrayHandleVirtual<T>>
struct SerializableTypeString<vtkm::cont::ArrayHandleVirtual<T>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH_Virtual<" + TypeString<T>::Get() + ">";
static std::string name = "AH_Virtual<" + SerializableTypeString<T>::Get() + ">";
return name;
}
};

12
vtkm/cont/ArrayHandleVirtual.hxx
View File

@ -38,7 +38,7 @@ ArrayHandleType inline ArrayHandle<T, StorageTagVirtual>::CastToType(
if (!this->Storage)
{
VTKM_LOG_CAST_FAIL(*this, ArrayHandleType);
throwFailedDynamicCast("ArrayHandleVirtual", vtkm::cont::TypeName<ArrayHandleType>());
throwFailedDynamicCast("ArrayHandleVirtual", vtkm::cont::TypeToString<ArrayHandleType>());
}
using S = typename ArrayHandleType::StorageTag;
const auto* any = this->Storage->template Cast<vtkm::cont::StorageAny<T, S>>();
@ -86,7 +86,7 @@ struct IntAnySerializer
{
if (obj.template IsType<CountingType>())
{
vtkmdiy::save(bb, vtkm::cont::TypeString<CountingType>::Get());
vtkmdiy::save(bb, vtkm::cont::SerializableTypeString<CountingType>::Get());
using S = typename CountingType::StorageTag;
const vtkm::cont::StorageVirtual* storage = obj.GetStorage();
@ -95,7 +95,7 @@ struct IntAnySerializer
}
else if (obj.template IsType<ConstantType>())
{
vtkmdiy::save(bb, vtkm::cont::TypeString<ConstantType>::Get());
vtkmdiy::save(bb, vtkm::cont::SerializableTypeString<ConstantType>::Get());
using S = typename ConstantType::StorageTag;
const vtkm::cont::StorageVirtual* storage = obj.GetStorage();
@ -104,7 +104,7 @@ struct IntAnySerializer
}
else
{
vtkmdiy::save(bb, vtkm::cont::TypeString<BasicType>::Get());
vtkmdiy::save(bb, vtkm::cont::SerializableTypeString<BasicType>::Get());
vtkm::cont::internal::ArrayHandleDefaultSerialization(bb, obj);
}
}
@ -114,13 +114,13 @@ struct IntAnySerializer
std::string typeString;
vtkmdiy::load(bb, typeString);
if (typeString == vtkm::cont::TypeString<CountingType>::Get())
if (typeString == vtkm::cont::SerializableTypeString<CountingType>::Get())
{
CountingType array;
vtkmdiy::load(bb, array);
obj = std::move(vtkm::cont::ArrayHandleVirtual<T>{ array });
}
else if (typeString == vtkm::cont::TypeString<ConstantType>::Get())
else if (typeString == vtkm::cont::SerializableTypeString<ConstantType>::Get())
{
ConstantType array;
vtkmdiy::load(bb, array);

15
vtkm/cont/ArrayHandleVirtualCoordinates.h
View File

@ -96,7 +96,7 @@ void CastAndCall(const vtkm::cont::ArrayHandleVirtualCoordinates& coords,
template <>
struct TypeString<vtkm::cont::ArrayHandleVirtualCoordinates>
struct SerializableTypeString<vtkm::cont::ArrayHandleVirtualCoordinates>
{
static VTKM_CONT const std::string Get() { return "AH_VirtualCoordinates"; }
};
@ -132,7 +132,7 @@ public:
using T = typename HandleType::ValueType;
using S = typename HandleType::StorageTag;
auto array = storage->Cast<vtkm::cont::StorageAny<T, S>>();
vtkmdiy::save(bb, vtkm::cont::TypeString<HandleType>::Get());
vtkmdiy::save(bb, vtkm::cont::SerializableTypeString<HandleType>::Get());
vtkmdiy::save(bb, array->GetHandle());
}
else if (obj.IsType<RectilinearCoordsArrayType>())
@ -141,12 +141,12 @@ public:
using T = typename HandleType::ValueType;
using S = typename HandleType::StorageTag;
auto array = storage->Cast<vtkm::cont::StorageAny<T, S>>();
vtkmdiy::save(bb, vtkm::cont::TypeString<HandleType>::Get());
vtkmdiy::save(bb, vtkm::cont::SerializableTypeString<HandleType>::Get());
vtkmdiy::save(bb, array->GetHandle());
}
else
{
vtkmdiy::save(bb, vtkm::cont::TypeString<BasicCoordsType>::Get());
vtkmdiy::save(bb, vtkm::cont::SerializableTypeString<BasicCoordsType>::Get());
vtkm::cont::internal::ArrayHandleDefaultSerialization(bb, obj);
}
}
@ -156,19 +156,20 @@ public:
std::string typeString;
vtkmdiy::load(bb, typeString);
if (typeString == vtkm::cont::TypeString<vtkm::cont::ArrayHandleUniformPointCoordinates>::Get())
if (typeString ==
vtkm::cont::SerializableTypeString<vtkm::cont::ArrayHandleUniformPointCoordinates>::Get())
{
vtkm::cont::ArrayHandleUniformPointCoordinates array;
vtkmdiy::load(bb, array);
obj = vtkm::cont::ArrayHandleVirtualCoordinates(array);
}
else if (typeString == vtkm::cont::TypeString<RectilinearCoordsArrayType>::Get())
else if (typeString == vtkm::cont::SerializableTypeString<RectilinearCoordsArrayType>::Get())
{
RectilinearCoordsArrayType array;
vtkmdiy::load(bb, array);
obj = vtkm::cont::ArrayHandleVirtualCoordinates(array);
}
else if (typeString == vtkm::cont::TypeString<BasicCoordsType>::Get())
else if (typeString == vtkm::cont::SerializableTypeString<BasicCoordsType>::Get())
{
BasicCoordsType array;
vtkmdiy::load(bb, array);

10
vtkm/cont/ArrayHandleZip.h
View File

@ -392,21 +392,21 @@ namespace cont
{
template <typename AH1, typename AH2>
struct TypeString<vtkm::cont::ArrayHandleZip<AH1, AH2>>
struct SerializableTypeString<vtkm::cont::ArrayHandleZip<AH1, AH2>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_Zip<" + TypeString<AH1>::Get() + "," + TypeString<AH2>::Get() + ">";
static std::string name = "AH_Zip<" + SerializableTypeString<AH1>::Get() + "," +
SerializableTypeString<AH2>::Get() + ">";
return name;
}
};
template <typename AH1, typename AH2>
struct TypeString<
struct SerializableTypeString<
vtkm::cont::ArrayHandle<vtkm::Pair<typename AH1::ValueType, typename AH2::ValueType>,
vtkm::cont::internal::StorageTagZip<AH1, AH2>>>
: TypeString<vtkm::cont::ArrayHandleZip<AH1, AH2>>
: SerializableTypeString<vtkm::cont::ArrayHandleZip<AH1, AH2>>
{
};
}

2
vtkm/cont/CMakeLists.txt
View File

@ -107,7 +107,7 @@ set(headers
StorageVirtual.h
Timer.h
TryExecute.h
TypeString.h
SerializableTypeString.h
VariantArrayHandle.h
VirtualObjectHandle.h
)

11
vtkm/cont/CellSetExplicit.h
View File

@ -350,15 +350,16 @@ namespace cont
{
template <typename ShapeST, typename CountST, typename ConnectivityST, typename OffsetST>
struct TypeString<vtkm::cont::CellSetExplicit<ShapeST, CountST, ConnectivityST, OffsetST>>
struct SerializableTypeString<
vtkm::cont::CellSetExplicit<ShapeST, CountST, ConnectivityST, OffsetST>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "CS_Explicit<" +
TypeString<vtkm::cont::ArrayHandle<vtkm::UInt8, ShapeST>>::Get() + "_ST," +
TypeString<vtkm::cont::ArrayHandle<vtkm::IdComponent, CountST>>::Get() + "_ST," +
TypeString<vtkm::cont::ArrayHandle<vtkm::Id, ConnectivityST>>::Get() + "_ST," +
TypeString<vtkm::cont::ArrayHandle<vtkm::Id, OffsetST>>::Get() + "_ST>";
SerializableTypeString<vtkm::cont::ArrayHandle<vtkm::UInt8, ShapeST>>::Get() + "_ST," +
SerializableTypeString<vtkm::cont::ArrayHandle<vtkm::IdComponent, CountST>>::Get() + "_ST," +
SerializableTypeString<vtkm::cont::ArrayHandle<vtkm::Id, ConnectivityST>>::Get() + "_ST," +
SerializableTypeString<vtkm::cont::ArrayHandle<vtkm::Id, OffsetST>>::Get() + "_ST>";
return name;
}

6
vtkm/cont/CellSetPermutation.h
View File

@ -402,12 +402,12 @@ namespace cont
{
template <typename CSType, typename AHValidCellIds>
struct TypeString<vtkm::cont::CellSetPermutation<CSType, AHValidCellIds>>
struct SerializableTypeString<vtkm::cont::CellSetPermutation<CSType, AHValidCellIds>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"CS_Permutation<" + TypeString<CSType>::Get() + "," + TypeString<AHValidCellIds>::Get() + ">";
static std::string name = "CS_Permutation<" + SerializableTypeString<CSType>::Get() + "," +
SerializableTypeString<AHValidCellIds>::Get() + ">";
return name;
}
};

6
vtkm/cont/CellSetSingleType.h
View File

@ -269,12 +269,12 @@ namespace cont
{
template <typename ConnectivityST>
struct TypeString<vtkm::cont::CellSetSingleType<ConnectivityST>>
struct SerializableTypeString<vtkm::cont::CellSetSingleType<ConnectivityST>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"CS_Single<" + TypeString<vtkm::cont::ArrayHandle<vtkm::Id, ConnectivityST>>::Get() + "_ST>";
static std::string name = "CS_Single<" +
SerializableTypeString<vtkm::cont::ArrayHandle<vtkm::Id, ConnectivityST>>::Get() + "_ST>";
return name;
}

2
vtkm/cont/CellSetStructured.h
View File

@ -132,7 +132,7 @@ namespace cont
{
template <vtkm::IdComponent DIMENSION>
struct TypeString<vtkm::cont::CellSetStructured<DIMENSION>>
struct SerializableTypeString<vtkm::cont::CellSetStructured<DIMENSION>>
{
static VTKM_CONT const std::string& Get()
{

4
vtkm/cont/DynamicCellSet.h
View File

@ -375,7 +375,7 @@ struct DynamicCellSetSerializeFunctor
template <typename CellSetType>
void operator()(const CellSetType& cs, BinaryBuffer& bb) const
{
vtkmdiy::save(bb, vtkm::cont::TypeString<CellSetType>::Get());
vtkmdiy::save(bb, vtkm::cont::SerializableTypeString<CellSetType>::Get());
vtkmdiy::save(bb, cs);
}
};
@ -390,7 +390,7 @@ struct DynamicCellSetDeserializeFunctor
bool& success,
BinaryBuffer& bb) const
{
if (!success && (typeString == vtkm::cont::TypeString<CellSetType>::Get()))
if (!success && (typeString == vtkm::cont::SerializableTypeString<CellSetType>::Get()))
{
CellSetType cs;
vtkmdiy::load(bb, cs);

26
vtkm/cont/Logging.h
View File

@ -102,7 +102,7 @@
///
/// The helper functions vtkm::cont::GetHumanReadableSize and
/// vtkm::cont::GetSizeString assist in formating byte sizes to a more readable
/// format. Similarly, the vtkm::cont::TypeName template functions provide RTTI
/// format. Similarly, the vtkm::cont::TypeToString template functions provide RTTI
/// based type-name information. When logging is enabled, these use the logging
/// backend to demangle symbol names on supported platforms.
///
@ -130,7 +130,7 @@
///
/// \code
/// VTKM_LOG_S(vtkm::cont::LogLevel::Perf,
/// "Executed functor " << vtkm::cont::TypeName(functor)
/// "Executed functor " << vtkm::cont::TypeToString(functor)
/// << " on device " << deviceId.GetName());
/// \endcode
@ -143,7 +143,7 @@
/// \code
/// VTKM_LOG_F(vtkm::cont::LogLevel::Perf,
/// "Executed functor %s on device %s",
/// vtkm::cont::TypeName(functor).c_str(),
/// vtkm::cont::TypeToString(functor).c_str(),
/// deviceId.GetName().c_str());
/// \endcode
@ -161,7 +161,7 @@
/// {
/// VTKM_LOG_SCOPE(vtkm::cont::LogLevel::Perf,
/// "Executing filter %s",
/// vtkm::cont::TypeName(myFilter).c_str());
/// vtkm::cont::TypeToString(myFilter).c_str());
/// myFilter.Execute();
/// }
/// \endcode
@ -187,7 +187,7 @@
/// \brief Convenience macro for logging a TryExecute failure to the Error level.
/// If logging is disabled, a message is still printed to stderr.
/// \param errorMessage The error message detailing the failure.
/// \param functorName The name of the functor (see vtkm::cont::TypeName)
/// \param functorName The name of the functor (see vtkm::cont::TypeToString)
/// \param deviceId The device tag / id for the device on which the functor
/// failed.
@ -195,7 +195,7 @@
/// \brief Similar to VTKM_LOG_TRYEXECUTE_FAIL, but also informs the user
/// that the device has been disable for future TryExecute calls.
/// \param errorMessage The error message detailing the failure.
/// \param functorName The name of the functor (see vtkm::cont::TypeName)
/// \param functorName The name of the functor (see vtkm::cont::TypeToString)
/// \param deviceId The device tag / id for the device on which the functor
/// failed.
@ -219,18 +219,18 @@
#define VTKM_LOG_CAST_SUCC(inObj, outObj) \
VTKM_LOG_F(vtkm::cont::LogLevel::Cast, \
"Cast succeeded: %s (%p) --> %s (%p)", \
vtkm::cont::TypeName(inObj).c_str(), \
vtkm::cont::TypeToString(inObj).c_str(), \
&inObj, \
vtkm::cont::TypeName(outObj).c_str(), \
vtkm::cont::TypeToString(outObj).c_str(), \
&outObj)
// Cast failure:
#define VTKM_LOG_CAST_FAIL(inObj, outType) \
VTKM_LOG_F(vtkm::cont::LogLevel::Cast, \
"Cast failed: %s (%p) --> %s", \
vtkm::cont::TypeName(inObj).c_str(), \
vtkm::cont::TypeToString(inObj).c_str(), \
&inObj, \
vtkm::cont::TypeName<outType>().c_str())
vtkm::cont::TypeToString<outType>().c_str())
// TryExecute failure
#define VTKM_LOG_TRYEXECUTE_FAIL(errorMessage, functorName, deviceId) \
@ -427,7 +427,7 @@ std::string GetSizeString(vtkm::UInt64 bytes, int prec = 2);
* @{
*/
template <typename T>
static inline VTKM_CONT std::string TypeName()
static inline VTKM_CONT std::string TypeToString()
{
#ifdef VTKM_ENABLE_LOGGING
return loguru::demangle(typeid(T).name()).c_str();
@ -437,9 +437,9 @@ static inline VTKM_CONT std::string TypeName()
}
template <typename T>
static inline VTKM_CONT std::string TypeName(const T&)
static inline VTKM_CONT std::string TypeToString(const T&)
{
return TypeName<T>();
return TypeToString<T>();
}
/**@}*/
}

46
vtkm/cont/TypeString.h → vtkm/cont/SerializableTypeString.h
View File

@ -17,8 +17,8 @@
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_TypeString_h
#define vtk_m_cont_TypeString_h
#ifndef vtk_m_cont_SerializableTypeString_h
#define vtk_m_cont_SerializableTypeString_h
#include <vtkm/Types.h>
@ -32,7 +32,7 @@ namespace cont
/// \brief A traits class that gives a unique name for a type. This class
/// should be specialized for every type that has to be serialized by diy.
template <typename T>
struct TypeString
struct SerializableTypeString
#ifdef VTKM_DOXYGEN_ONLY
{
static VTKM_CONT const std::string& Get()
@ -48,21 +48,21 @@ namespace internal
{
template <typename T, typename... Ts>
std::string GetVariadicTypeString(const T&, const Ts&... ts)
std::string GetVariadicSerializableTypeString(const T&, const Ts&... ts)
{
return TypeString<T>::Get() + "," + GetVariadicTypeString(ts...);
return SerializableTypeString<T>::Get() + "," + GetVariadicSerializableTypeString(ts...);
}
template <typename T>
std::string GetVariadicTypeString(const T&)
std::string GetVariadicSerializableTypeString(const T&)
{
return TypeString<T>::Get();
return SerializableTypeString<T>::Get();
}
} // internal
template <>
struct TypeString<vtkm::Int8>
struct SerializableTypeString<vtkm::Int8>
{
static VTKM_CONT const std::string& Get()
{
@ -72,7 +72,7 @@ struct TypeString<vtkm::Int8>
};
template <>
struct TypeString<vtkm::UInt8>
struct SerializableTypeString<vtkm::UInt8>
{
static VTKM_CONT const std::string& Get()
{
@ -82,7 +82,7 @@ struct TypeString<vtkm::UInt8>
};
template <>
struct TypeString<vtkm::Int16>
struct SerializableTypeString<vtkm::Int16>
{
static VTKM_CONT const std::string& Get()
{
@ -92,7 +92,7 @@ struct TypeString<vtkm::Int16>
};
template <>
struct TypeString<vtkm::UInt16>
struct SerializableTypeString<vtkm::UInt16>
{
static VTKM_CONT const std::string& Get()
{
@ -102,7 +102,7 @@ struct TypeString<vtkm::UInt16>
};
template <>
struct TypeString<vtkm::Int32>
struct SerializableTypeString<vtkm::Int32>
{
static VTKM_CONT const std::string& Get()
{
@ -112,7 +112,7 @@ struct TypeString<vtkm::Int32>
};
template <>
struct TypeString<vtkm::UInt32>
struct SerializableTypeString<vtkm::UInt32>
{
static VTKM_CONT const std::string& Get()
{
@ -122,7 +122,7 @@ struct TypeString<vtkm::UInt32>
};
template <>
struct TypeString<vtkm::Int64>
struct SerializableTypeString<vtkm::Int64>
{
static VTKM_CONT const std::string& Get()
{
@ -132,7 +132,7 @@ struct TypeString<vtkm::Int64>
};
template <>
struct TypeString<vtkm::UInt64>
struct SerializableTypeString<vtkm::UInt64>
{
static VTKM_CONT const std::string& Get()
{
@ -142,7 +142,7 @@ struct TypeString<vtkm::UInt64>
};
template <>
struct TypeString<vtkm::Float32>
struct SerializableTypeString<vtkm::Float32>
{
static VTKM_CONT const std::string& Get()
{
@ -152,7 +152,7 @@ struct TypeString<vtkm::Float32>
};
template <>
struct TypeString<vtkm::Float64>
struct SerializableTypeString<vtkm::Float64>
{
static VTKM_CONT const std::string& Get()
{
@ -162,27 +162,27 @@ struct TypeString<vtkm::Float64>
};
template <typename T, vtkm::IdComponent NumComponents>
struct TypeString<vtkm::Vec<T, NumComponents>>
struct SerializableTypeString<vtkm::Vec<T, NumComponents>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"V<" + TypeString<T>::Get() + "," + std::to_string(NumComponents) + ">";
"V<" + SerializableTypeString<T>::Get() + "," + std::to_string(NumComponents) + ">";
return name;
}
};
template <typename T1, typename T2>
struct TypeString<vtkm::Pair<T1, T2>>
struct SerializableTypeString<vtkm::Pair<T1, T2>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"vtkm::Pair<" + TypeString<T1>::Get() + "," + TypeString<T2>::Get() + ">";
static std::string name = "vtkm::Pair<" + SerializableTypeString<T1>::Get() + "," +
SerializableTypeString<T2>::Get() + ">";
return name;
}
};
}
} // vtkm::cont
#endif // vtk_m_cont_TypeString_h
#endif // vtk_m_cont_SerializableTypeString_h

2
vtkm/cont/Serialization.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_cont_Serialization_h
#define vtk_m_cont_Serialization_h
#include <vtkm/cont/TypeString.h>
#include <vtkm/cont/SerializableTypeString.h>
#include <vtkm/thirdparty/diy/serialization.h>

2
vtkm/cont/StorageVirtual.h
View File

@ -120,7 +120,7 @@ public:
if (!derived)
{
VTKM_LOG_CAST_FAIL(*this, DerivedStorage);
throwFailedDynamicCast("StorageVirtual", vtkm::cont::TypeName<DerivedStorage>());
throwFailedDynamicCast("StorageVirtual", vtkm::cont::TypeToString<DerivedStorage>());
}
VTKM_LOG_CAST_SUCC(*this, derived);
return derived;

2
vtkm/cont/TryExecute.h
View File

@ -53,7 +53,7 @@ inline bool TryExecuteIfValid(std::true_type,
}
catch (...)
{
detail::HandleTryExecuteException(tag, tracker, vtkm::cont::TypeName<Functor>());
detail::HandleTryExecuteException(tag, tracker, vtkm::cont::TypeToString<Functor>());
}
}

4
vtkm/cont/VariantArrayHandle.h
View File

@ -445,7 +445,7 @@ struct VariantArrayHandleSerializeFunctor
template <typename ArrayHandleType>
void operator()(const ArrayHandleType& ah, BinaryBuffer& bb) const
{
vtkmdiy::save(bb, vtkm::cont::TypeString<ArrayHandleType>::Get());
vtkmdiy::save(bb, vtkm::cont::SerializableTypeString<ArrayHandleType>::Get());
vtkmdiy::save(bb, ah);
}
};
@ -461,7 +461,7 @@ struct VariantArrayHandleDeserializeFunctor
{
using ArrayHandleType = vtkm::cont::ArrayHandleVirtual<T>;
if (!success && (typeString == vtkm::cont::TypeString<ArrayHandleType>::Get()))
if (!success && (typeString == vtkm::cont::SerializableTypeString<ArrayHandleType>::Get()))
{
ArrayHandleType ah;
vtkmdiy::load(bb, ah);

8
vtkm/cont/internal/VariantArrayHandleContainer.h
View File

@ -164,8 +164,8 @@ struct VTKM_ALWAYS_EXPORT Caster
if (!IsValueType<T>(container))
{
VTKM_LOG_CAST_FAIL(container, ArrayHandleType);
throwFailedDynamicCast(vtkm::cont::TypeName(container),
vtkm::cont::TypeName<ArrayHandleType>());
throwFailedDynamicCast(vtkm::cont::TypeToString(container),
vtkm::cont::TypeToString<ArrayHandleType>());
}
const auto* derived = static_cast<const VariantArrayHandleContainer<T>*>(container);
@ -182,8 +182,8 @@ struct VTKM_ALWAYS_EXPORT Caster<T, vtkm::cont::StorageTagVirtual>
if (!IsValueType<T>(container))
{
VTKM_LOG_CAST_FAIL(container, vtkm::cont::ArrayHandleVirtual<T>);
throwFailedDynamicCast(vtkm::cont::TypeName(container),
vtkm::cont::TypeName<vtkm::cont::ArrayHandleVirtual<T>>());
throwFailedDynamicCast(vtkm::cont::TypeToString(container),
vtkm::cont::TypeToString<vtkm::cont::ArrayHandleVirtual<T>>());
}
// Technically, this method returns a copy of the \c ArrayHandle. But

10
vtkm/cont/tbb/internal/DeviceAdapterAlgorithmTBB.h
View File

@ -255,8 +255,9 @@ public:
template <class FunctorType>
VTKM_CONT static inline void Schedule(FunctorType functor, vtkm::Id numInstances)
{
VTKM_LOG_SCOPE(
vtkm::cont::LogLevel::Perf, "Schedule TBB 1D: '%s'", vtkm::cont::TypeName(functor).c_str());
VTKM_LOG_SCOPE(vtkm::cont::LogLevel::Perf,
"Schedule TBB 1D: '%s'",
vtkm::cont::TypeToString(functor).c_str());
vtkm::exec::tbb::internal::TaskTiling1D kernel(functor);
ScheduleTask(kernel, numInstances);
@ -265,8 +266,9 @@ public:
template <class FunctorType>
VTKM_CONT static inline void Schedule(FunctorType functor, vtkm::Id3 rangeMax)
{
VTKM_LOG_SCOPE(
vtkm::cont::LogLevel::Perf, "Schedule TBB 3D: '%s'", vtkm::cont::TypeName(functor).c_str());
VTKM_LOG_SCOPE(vtkm::cont::LogLevel::Perf,
"Schedule TBB 3D: '%s'",
vtkm::cont::TypeToString(functor).c_str());
vtkm::exec::tbb::internal::TaskTiling3D kernel(functor);
ScheduleTask(kernel, rangeMax);

8
vtkm/cont/testing/UnitTestSerializationArrayHandle.cxx
View File

@ -535,24 +535,24 @@ namespace cont
{
template <typename T>
struct TypeString<TestArrayHandleImplicit::ImplicitFunctor<T>>
struct SerializableTypeString<TestArrayHandleImplicit::ImplicitFunctor<T>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"TestArrayHandleImplicit::ImplicitFunctor<" + TypeString<T>::Get() + ">";
"TestArrayHandleImplicit::ImplicitFunctor<" + SerializableTypeString<T>::Get() + ">";
return name;
}
};
template <>
struct TypeString<TestArrayHandleTransform::TransformFunctor>
struct SerializableTypeString<TestArrayHandleTransform::TransformFunctor>
{
static VTKM_CONT const std::string Get() { return "TestArrayHandleTransform::TransformFunctor"; }
};
template <>
struct TypeString<TestArrayHandleTransform::InverseTransformFunctor>
struct SerializableTypeString<TestArrayHandleTransform::InverseTransformFunctor>
{
static VTKM_CONT const std::string Get()
{

4
vtkm/filter/Filter.hxx
View File

@ -281,7 +281,7 @@ inline VTKM_CONT vtkm::cont::DataSet Filter<Derived>::Execute(
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
VTKM_LOG_SCOPE(
vtkm::cont::LogLevel::Perf, "Filter: '%s'", vtkm::cont::TypeName<Derived>().c_str());
vtkm::cont::LogLevel::Perf, "Filter: '%s'", vtkm::cont::TypeToString<Derived>().c_str());
Derived* self = static_cast<Derived*>(this);
vtkm::cont::MultiBlock output = self->Execute(vtkm::cont::MultiBlock(input), policy);
@ -301,7 +301,7 @@ inline VTKM_CONT vtkm::cont::MultiBlock Filter<Derived>::Execute(
{
VTKM_LOG_SCOPE(vtkm::cont::LogLevel::Perf,
"Filter (MultiBlock): '%s'",
vtkm::cont::TypeName<Derived>().c_str());
vtkm::cont::TypeToString<Derived>().c_str());
Derived* self = static_cast<Derived*>(this);

2
vtkm/worklet/internal/DispatcherBase.h
View File

@ -667,7 +667,7 @@ public:
{
VTKM_LOG_SCOPE(vtkm::cont::LogLevel::Perf,
"Invoking Worklet: '%s'",
vtkm::cont::TypeName<WorkletType>().c_str());
vtkm::cont::TypeToString<WorkletType>().c_str());
this->StartInvoke(std::forward<Args>(args)...);
}