Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-16 17:22:55 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
9b22a72d6c
vtk-m/vtkm/ListTag.h

153 lines
4.4 KiB
C
Raw Normal View History

Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt 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.
//
// Copyright 2014 Sandia Corporation.
// Copyright 2014 UT-Battelle, LLC.
The Copyright statement now has all the periods in the correct location.
2015-05-21 12:09:22 +00:00
// Copyright 2014 Los Alamos National Security.
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_ListTag_h
#define vtk_m_ListTag_h
Allow longer base lists Previously we just hand coded base lists up to 4 entries, which was fine for what we were using it for. However, now that we want to support base types of different sizes, we are going to need much longer lists.
2014-10-08 18:53:01 +00:00
#include <vtkm/internal/ListTagDetail.h>
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
#include <vtkm/internal/ExportMacros.h>
Rename pragma header guard so it makes sense for tbb and thrust. Boost is not the only thirdparty that we are supressing warnings for, so make the name more generic.
2015-08-12 19:08:45 +00:00
VTKM_THIRDPARTY_PRE_INCLUDE
Add VTKM_IS_LIST_TAG macro As part of this is a ListTagCheck class that can be used for other template magic.
2014-10-22 13:24:04 +00:00
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_base_of.hpp>
Rename pragma header guard so it makes sense for tbb and thrust. Boost is not the only thirdparty that we are supressing warnings for, so make the name more generic.
2015-08-12 19:08:45 +00:00
VTKM_THIRDPARTY_POST_INCLUDE
Add VTKM_IS_LIST_TAG macro As part of this is a ListTagCheck class that can be used for other template magic.
2014-10-22 13:24:04 +00:00
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
namespace vtkm {
Add VTKM_IS_LIST_TAG macro As part of this is a ListTagCheck class that can be used for other template magic.
2014-10-22 13:24:04 +00:00
namespace internal {
template<typename ListTag>
struct ListTagCheck
{
static const bool Valid =
boost::is_base_of<vtkm::detail::ListRoot,ListTag>::value;
};
} // namespace internal
/// Checks that the argument is a proper list tag. This is a handy concept
/// check for functions and classes to make sure that a template argument is
/// actually a device adapter tag. (You can get weird errors elsewhere in the
/// code when a mistake is made.)
///
#define VTKM_IS_LIST_TAG(tag) \
Add third party wrappers around boost macros. The boost assert macros seem to have an issue where they define an unused typedef. This is causing the XCode 7 compiler to issue a warning. Since the offending code is in a macro, the warning is identified with the VTK-m header even though the code is in boost. To get around this, wrap all uses of the boost assert that is causing the warning in the third party pre/post macros to disable the warning.
2015-09-17 05:34:49 +00:00
VTKM_THIRDPARTY_PRE_INCLUDE \
Add VTKM_IS_LIST_TAG macro As part of this is a ListTagCheck class that can be used for other template magic.
2014-10-22 13:24:04 +00:00
BOOST_STATIC_ASSERT_MSG( \
::vtkm::internal::ListTagCheck<tag>::Valid, \
Add third party wrappers around boost macros. The boost assert macros seem to have an issue where they define an unused typedef. This is causing the XCode 7 compiler to issue a warning. Since the offending code is in a macro, the warning is identified with the VTK-m header even though the code is in boost. To get around this, wrap all uses of the boost assert that is causing the warning in the third party pre/post macros to disable the warning.
2015-09-17 05:34:49 +00:00
"Provided type is not a valid VTK-m list tag.") \
VTKM_THIRDPARTY_POST_INCLUDE
Add VTKM_IS_LIST_TAG macro As part of this is a ListTagCheck class that can be used for other template magic.
2014-10-22 13:24:04 +00:00
Add a template that tests whether a type is in a list. Also reduced the maximum list size to 15 (which is the current longest single list we have). Trying to reduce the size of the generated code a bit, which is getting a little long.
2014-10-22 16:35:56 +00:00
namespace detail {
template<typename ListTag1, typename ListTag2>
struct ListJoin { };
} // namespace detail
Add classes to manage point coordinates. Each type of point coordinates has its own class with the name PointCoordinates*. Currently there is a PointCoordiantesArray that contains an ArrayHandle holding the point coordinates and a PointCoordinatesUniform that takes the standard extent, origin, and spacing for a uniform rectilinear grid and defines point coordiantes for that. Creating new PointCoordinates arrays is pretty easy, and we will almost definitely add more. For example, we should have an elevation version that takes uniform coordinates for a 2D grid and then an elevation in the third dimension. We can probably also use a basic composite point coordinates that can build them from other coordinates. There is also a DynamicPointCoordinates class that polymorphically stores an instance of a PointCoordinates class. It has a CastAndCall method that behaves like DynamicArrayHandle; it can call a functor with an array handle (possible implicit) that holds the point coordinates.
2014-05-14 21:05:38 +00:00
/// A special tag for an empty list.
///
Add VTKM_IS_LIST_TAG macro As part of this is a ListTagCheck class that can be used for other template magic.
2014-10-22 13:24:04 +00:00
struct ListTagEmpty : detail::ListRoot {
Allow longer base lists Previously we just hand coded base lists up to 4 entries, which was fine for what we were using it for. However, now that we want to support base types of different sizes, we are going to need much longer lists.
2014-10-08 18:53:01 +00:00
typedef detail::ListBase<void()> List;
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
};
/// A tag that is a construction of two other tags joined together. This struct
/// can be subclassed and still behave like a list tag.
template<typename ListTag1, typename ListTag2>
Add VTKM_IS_LIST_TAG macro As part of this is a ListTagCheck class that can be used for other template magic.
2014-10-22 13:24:04 +00:00
struct ListTagJoin : detail::ListRoot {
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
typedef detail::ListJoin<ListTag1, ListTag2> List;
};
template<typename Functor, typename ListTag>
VTKM_CONT_EXPORT
void ListForEach(Functor &f, ListTag);
template<typename Functor, typename ListTag>
VTKM_CONT_EXPORT
void ListForEach(const Functor &f, ListTag);
namespace detail {
template<typename Functor, typename ListTag1, typename ListTag2>
VTKM_CONT_EXPORT
void ListForEachImpl(Functor &f, ListJoin<ListTag1, ListTag2>)
{
vtkm::ListForEach(f, ListTag1());
vtkm::ListForEach(f, ListTag2());
}
template<typename Functor, typename ListTag1, typename ListTag2>
VTKM_CONT_EXPORT
void ListForEachImpl(const Functor &f, ListJoin<ListTag1, ListTag2>)
{
vtkm::ListForEach(f, ListTag1());
vtkm::ListForEach(f, ListTag2());
}
} // namespace detail
/// For each typename represented by the list tag, call the functor with a
/// default instance of that type.
///
template<typename Functor, typename ListTag>
VTKM_CONT_EXPORT
void ListForEach(Functor &f, ListTag)
{
Add a template that tests whether a type is in a list. Also reduced the maximum list size to 15 (which is the current longest single list we have). Trying to reduce the size of the generated code a bit, which is getting a little long.
2014-10-22 16:35:56 +00:00
VTKM_IS_LIST_TAG(ListTag);
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
detail::ListForEachImpl(f, typename ListTag::List());
}
/// For each typename represented by the list tag, call the functor with a
/// default instance of that type.
///
template<typename Functor, typename ListTag>
VTKM_CONT_EXPORT
void ListForEach(const Functor &f, ListTag)
{
Add a template that tests whether a type is in a list. Also reduced the maximum list size to 15 (which is the current longest single list we have). Trying to reduce the size of the generated code a bit, which is getting a little long.
2014-10-22 16:35:56 +00:00
VTKM_IS_LIST_TAG(ListTag);
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
detail::ListForEachImpl(f, typename ListTag::List());
}
Add a template that tests whether a type is in a list. Also reduced the maximum list size to 15 (which is the current longest single list we have). Trying to reduce the size of the generated code a bit, which is getting a little long.
2014-10-22 16:35:56 +00:00
/// Checks to see if the given \c Type is in the list pointed to by \c ListTag.
/// There is a static boolean named \c value that is set to true if the type is
/// contained in the list and false otherwise.
///
template<typename ListTag, typename Type>
struct ListContains
{
VTKM_IS_LIST_TAG(ListTag);
static const bool value =
detail::ListContainsImpl<typename ListTag::List,Type>::value;
};
namespace detail {
template<typename Type, typename ListTag1, typename ListTag2>
struct ListContainsImpl<ListJoin<ListTag1,ListTag2>, Type>
{
static const bool value = (vtkm::ListContains<ListTag1,Type>::value ||
vtkm::ListContains<ListTag2,Type>::value);
};
} // namespace detail
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
} // namespace vtkm
#endif //vtk_m_ListTag_h
Reference in New Issue Copy Permalink