Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-07-11 01:28:57 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
master
vtk-m/vtkmstd/is_trivial.h

127 lines
4.4 KiB
C
Raw Permalink Normal View History

Allow Variant to be trivial Although `vtkm::internal::Variant` respected the trivially copyable attribute of the types it contains, it was never totally trivial (i.e. `std::is_trivial<Variant<...>>` was never true). The reason was that `Variant` was initializing its `Index` parameter to signify that it was not initialized. However, the fact that `Index` was initialized meant that it was not trivially constructed. Now, `Variant` type checks its types to see if they are all trivially constructible. If so, it makes itself trivially constructible. This means that `Index` may or may not be valid if `Variant` is constructed without an argument. This in turn means that the result of `Variant::IsValid` becomes undefined. That should be OK in practice. `Index` will "point" to an uninitialized object, but that object is trivially constructed anyway. However, that could cause problems if developers used `IsValid` to determine if something is selected.
2020-09-22 22:00:26 +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.
//============================================================================
#ifndef vtk_m_std_is_trivial_h
#define vtk_m_std_is_trivial_h
#include <vtkm/StaticAssert.h>
Be more conservative about is_trivial support `std::is_trivial` is part of the C++14 specification. However, we have encountered multiple compilers that purport to implement C++14 but do not implement `std::is_trivial` and the like checks correctly. To avoid such issues, only use `std::is_trivial` on compilers that we have tested to support it.
2021-03-01 22:10:10 +00:00
#include <vtkm/internal/Configure.h>
Allow Variant to be trivial Although `vtkm::internal::Variant` respected the trivially copyable attribute of the types it contains, it was never totally trivial (i.e. `std::is_trivial<Variant<...>>` was never true). The reason was that `Variant` was initializing its `Index` parameter to signify that it was not initialized. However, the fact that `Index` was initialized meant that it was not trivially constructed. Now, `Variant` type checks its types to see if they are all trivially constructible. If so, it makes itself trivially constructible. This means that `Index` may or may not be valid if `Variant` is constructed without an argument. This in turn means that the result of `Variant::IsValid` becomes undefined. That should be OK in practice. `Index` will "point" to an uninitialized object, but that object is trivially constructed anyway. However, that could cause problems if developers used `IsValid` to determine if something is selected.
2020-09-22 22:00:26 +00:00
#include <type_traits>
Be more conservative about is_trivial support `std::is_trivial` is part of the C++14 specification. However, we have encountered multiple compilers that purport to implement C++14 but do not implement `std::is_trivial` and the like checks correctly. To avoid such issues, only use `std::is_trivial` on compilers that we have tested to support it.
2021-03-01 22:10:10 +00:00
#if defined(VTKM_GCC) && !defined(VTKM_USING_GLIBCXX_4)
#define VTKM_USE_STD_IS_TRIVIAL
#endif
#ifndef VTKM_USE_STD_IS_TRIVIAL
Allow Variant to be trivial Although `vtkm::internal::Variant` respected the trivially copyable attribute of the types it contains, it was never totally trivial (i.e. `std::is_trivial<Variant<...>>` was never true). The reason was that `Variant` was initializing its `Index` parameter to signify that it was not initialized. However, the fact that `Index` was initialized meant that it was not trivially constructed. Now, `Variant` type checks its types to see if they are all trivially constructible. If so, it makes itself trivially constructible. This means that `Index` may or may not be valid if `Variant` is constructed without an argument. This in turn means that the result of `Variant::IsValid` becomes undefined. That should be OK in practice. `Index` will "point" to an uninitialized object, but that object is trivially constructed anyway. However, that could cause problems if developers used `IsValid` to determine if something is selected.
2020-09-22 22:00:26 +00:00
namespace vtkmstd
{
// GCC 4.8 and 4.9 standard library does not support std::is_trivially_copyable.
// There is no relyable way to get this information (since it has to come special from
// the compiler). For our purposes, we will report as nothing being trivially copyable,
// which causes us to call the constructors with everything. This should be fine unless
// some other part of the compiler is trying to check for trivial copies (perhaps nvcc
// on top of GCC 4.8).
template <typename>
struct is_trivially_copyable : std::false_type
{
};
// I haven't tried the other forms of is_trivial, but let's just assume they don't
// work as expected.
template <typename...>
struct is_trivially_constructible : std::false_type
{
};
template <typename>
struct is_trivially_destructible : std::false_type
{
};
template <typename>
struct is_trivial : std::false_type
{
};
// A common exception to reporting nothing as trivially copyable is assertions that
// a class is trivially copyable. If we have code that _only_ works with trivially
// copyable classes, we don't want to report nothing as trivially copyably, because
// that will error out for everything. For this case, we define the macro
// `VTKM_IS_TRIVIALLY_COPYABLE`, which will always pass on compilers that don't
// support is_trivially_copyable, but will do the correct check on compilers that
// do support it.
Have VTKM_IS_TRIVIAL* macros show types better Changed the definition of `VTKM_IS_TRIVIAL`, `VTKM_IS_TRIVIALLY_COPYABLE` and the like to use internal structs to do the static assert rather than have them do the static assert themselves. This makes the compiler more likely to tell you the actual type being checked rather. (At least, this was the case on my clang compiler.)
2021-02-22 15:49:41 +00:00
#define VTKM_IS_TRIVIALLY_COPYABLE(...) VTKM_STATIC_ASSERT(true)
Allow Variant to be trivial Although `vtkm::internal::Variant` respected the trivially copyable attribute of the types it contains, it was never totally trivial (i.e. `std::is_trivial<Variant<...>>` was never true). The reason was that `Variant` was initializing its `Index` parameter to signify that it was not initialized. However, the fact that `Index` was initialized meant that it was not trivially constructed. Now, `Variant` type checks its types to see if they are all trivially constructible. If so, it makes itself trivially constructible. This means that `Index` may or may not be valid if `Variant` is constructed without an argument. This in turn means that the result of `Variant::IsValid` becomes undefined. That should be OK in practice. `Index` will "point" to an uninitialized object, but that object is trivially constructed anyway. However, that could cause problems if developers used `IsValid` to determine if something is selected.
2020-09-22 22:00:26 +00:00
#define VTKM_IS_TRIVIALLY_CONSTRUCTIBLE(...) VTKM_STATIC_ASSERT(true)
#define VTKM_IS_TRIVIALLY_DESTRUCTIBLE(...) VTKM_STATIC_ASSERT(true)
Have VTKM_IS_TRIVIAL* macros show types better Changed the definition of `VTKM_IS_TRIVIAL`, `VTKM_IS_TRIVIALLY_COPYABLE` and the like to use internal structs to do the static assert rather than have them do the static assert themselves. This makes the compiler more likely to tell you the actual type being checked rather. (At least, this was the case on my clang compiler.)
2021-02-22 15:49:41 +00:00
#define VTKM_IS_TRIVIAL(...) VTKM_STATIC_ASSERT(true)
Allow Variant to be trivial Although `vtkm::internal::Variant` respected the trivially copyable attribute of the types it contains, it was never totally trivial (i.e. `std::is_trivial<Variant<...>>` was never true). The reason was that `Variant` was initializing its `Index` parameter to signify that it was not initialized. However, the fact that `Index` was initialized meant that it was not trivially constructed. Now, `Variant` type checks its types to see if they are all trivially constructible. If so, it makes itself trivially constructible. This means that `Index` may or may not be valid if `Variant` is constructed without an argument. This in turn means that the result of `Variant::IsValid` becomes undefined. That should be OK in practice. `Index` will "point" to an uninitialized object, but that object is trivially constructed anyway. However, that could cause problems if developers used `IsValid` to determine if something is selected.
2020-09-22 22:00:26 +00:00
} // namespace vtkmstd
#else // NOT VTKM_USING_GLIBCXX_4
namespace vtkmstd
{
using std::is_trivial;
using std::is_trivially_constructible;
using std::is_trivially_copyable;
using std::is_trivially_destructible;
Have VTKM_IS_TRIVIAL* macros show types better Changed the definition of `VTKM_IS_TRIVIAL`, `VTKM_IS_TRIVIALLY_COPYABLE` and the like to use internal structs to do the static assert rather than have them do the static assert themselves. This makes the compiler more likely to tell you the actual type being checked rather. (At least, this was the case on my clang compiler.)
2021-02-22 15:49:41 +00:00
namespace detail
{
// Note: the reason why we redirect the trivial checks to these classes is so when the checks
// fail it is easier to read from the error messages exactly which type was being checked. If
// you just do a static assert in a macro, the error message is likely to give you either
// macro argument names or unresolved types in the error message, which is unhelpful.
template <typename T>
struct CheckTriviallyCopyable
{
VTKM_STATIC_ASSERT_MSG(vtkmstd::is_trivially_copyable<T>::value,
"Type must be trivially copyable to be used here.");
static constexpr bool value = true;
};
template <typename T>
struct CheckTriviallyConstructible
{
VTKM_STATIC_ASSERT_MSG(::vtkmstd::is_trivially_constructible<T>::value,
"Type must be trivially constructible to be used here.");
static constexpr bool value = true;
};
template <typename T>
struct CheckTriviallyDestructible
{
VTKM_STATIC_ASSERT_MSG(::vtkmstd::is_trivially_destructible<T>::value,
"Type must be trivially destructible to be used here.");
static constexpr bool value = true;
};
template <typename T>
struct CheckTrivial
{
VTKM_STATIC_ASSERT_MSG(::vtkmstd::is_trivial<T>::value, "Type must be trivial to be used here.");
static constexpr bool value = true;
};
} // namespace detail
#define VTKM_IS_TRIVIALLY_COPYABLE(...) \
VTKM_STATIC_ASSERT(::vtkmstd::detail::CheckTriviallyCopyable<__VA_ARGS__>::value)
#define VTKM_IS_TRIVIALLY_CONSTRUCTIBLE(...) \
VTKM_STATIC_ASSERT(::vtkmstd::detail::CheckTriviallyConstructible<__VA_ARGS__>::value)
#define VTKM_IS_TRIVIALLY_DESTRUCTIBLE(...) \
VTKM_STATIC_ASSERT(::vtkmstd::detail::CheckTriviallyDestructible<__VA_ARGS__>::value)
#define VTKM_IS_TRIVIAL(...) VTKM_STATIC_ASSERT(::vtkmstd::detail::CheckTrivial<__VA_ARGS__>::value)
Allow Variant to be trivial Although `vtkm::internal::Variant` respected the trivially copyable attribute of the types it contains, it was never totally trivial (i.e. `std::is_trivial<Variant<...>>` was never true). The reason was that `Variant` was initializing its `Index` parameter to signify that it was not initialized. However, the fact that `Index` was initialized meant that it was not trivially constructed. Now, `Variant` type checks its types to see if they are all trivially constructible. If so, it makes itself trivially constructible. This means that `Index` may or may not be valid if `Variant` is constructed without an argument. This in turn means that the result of `Variant::IsValid` becomes undefined. That should be OK in practice. `Index` will "point" to an uninitialized object, but that object is trivially constructed anyway. However, that could cause problems if developers used `IsValid` to determine if something is selected.
2020-09-22 22:00:26 +00:00
} // namespace vtkmstd
#endif
#endif //vtk_m_std_is_trivial_h
Reference in New Issue Copy Permalink