Merge topic 'fix-doxygen-warnings'

4797426e1 silenced doxygen unsupported c++ syntax

Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Robert Maynard <robert.maynard@kitware.com>
Merge-request: !2000

vtkm/ListTag.h

@@ -50,16 +50,19 @@ struct UniversalTag
 //-----------------------------------------------------------------------------
 /// A basic tag for a list of typenames. This struct can be subclassed
 /// and still behave like a list tag.
+/// @cond NONE
 template <typename... ArgTypes>
 struct VTKM_DEPRECATED(1.6, "ListTagBase replace by List. Note that List cannot be subclassed.")
   ListTagBase : detail::ListRoot
 {
   using list = detail::ListBase<ArgTypes...>;
 };
+/// @endcond
 
 /// A special tag for a list that represents holding all potential values
 ///
 /// Note: Can not be used with ForEach for obvious reasons.
+/// @cond NONE
 struct VTKM_DEPRECATED(
   1.6,
   "ListTagUniversal replaced by ListUniversal. Note that ListUniversal cannot be subclassed.")
@@ -67,26 +70,31 @@ struct VTKM_DEPRECATED(
 {
   using list = vtkm::detail::ListBase<vtkm::detail::UniversalTag>;
 };
+/// @endcond
 
 namespace internal
 {
 
+/// @cond NONE
 template <typename ListTag>
 struct ListTagCheck : std::is_base_of<vtkm::detail::ListRoot, ListTag>
 {
   static constexpr bool Valid = std::is_base_of<vtkm::detail::ListRoot, ListTag>::value;
 };
+/// @endcond
 
 } // namespace internal
 
 namespace detail
 {
 
+/// @cond NONE
 template <typename ListTag>
 struct VTKM_DEPRECATED(1.6, "VTKM_IS_LIST_TAG replaced with VTKM_IS_LIST.") ListTagAssert
   : internal::IsList<ListTag>
 {
 };
+/// @endcond
 
 } // namespace detal
 
@@ -105,6 +113,7 @@ namespace internal
 namespace detail
 {
 
+/// @cond NONE
 template <typename ListTag>
 struct ListTagAsBrigandListImpl
 {
@@ -113,6 +122,7 @@ struct ListTagAsBrigandListImpl
   using type = typename ListTag::list;
   VTKM_DEPRECATED_SUPPRESS_END
 };
+/// @endcond
 
 } // namespace detail
 
@@ -181,6 +191,7 @@ using ListTagApply VTKM_DEPRECATED(1.6, "ListTagApply replaced by ListApply.") =
 
 /// A special tag for an empty list.
 ///
+/// @cond NONE
 struct VTKM_DEPRECATED(
   1.6,
   "ListTagEmpty replaced by ListEmpty. Note that ListEmpty cannot be subclassed.") ListTagEmpty
@@ -188,9 +199,11 @@ struct VTKM_DEPRECATED(
 {
   using list = vtkm::detail::ListBase<>;
 };
+/// @endcond
 
 /// A tag that is a construction of two other tags joined together. This struct
 /// can be subclassed and still behave like a list tag.
+/// @cond NONE
 template <typename... ListTags>
 struct VTKM_DEPRECATED(
   1.6,
@@ -198,9 +211,11 @@ struct VTKM_DEPRECATED(
   : vtkm::internal::ListAsListTag<vtkm::ListAppend<ListTags...>>
 {
 };
+/// @endcond
 
 
 /// A tag that is constructed by appending \c Type to \c ListTag.
+/// @cond NONE
 template <typename ListTag, typename Type>
 struct VTKM_DEPRECATED(1.6,
                        "ListTagAppend<List, Type> replaced by ListAppend<List, vtkm::List<Type>. "
@@ -208,9 +223,11 @@ struct VTKM_DEPRECATED(1.6,
   : vtkm::internal::ListAsListTag<vtkm::ListAppend<ListTag, vtkm::List<Type>>>
 {
 };
+/// @endcond
 
 /// Append \c Type to \c ListTag only if \c ListTag does not already contain \c Type.
 /// No checks are performed to see if \c ListTag itself has only unique elements.
+/// @cond NONE
 template <typename ListTag, typename Type>
 struct VTKM_DEPRECATED(1.6) ListTagAppendUnique
   : std::conditional<
@@ -219,9 +236,11 @@ struct VTKM_DEPRECATED(1.6) ListTagAppendUnique
       vtkm::internal::ListAsListTag<vtkm::ListAppend<ListTag, vtkm::List<Type>>>>::type
 {
 };
+/// @endcond
 
 /// A tag that consists of elements that are found in both tags. This struct
 /// can be subclassed and still behave like a list tag.
+/// @cond NONE
 template <typename ListTag1, typename ListTag2>
 struct VTKM_DEPRECATED(
   1.6,
@@ -229,9 +248,11 @@ struct VTKM_DEPRECATED(
   ListTagIntersect : vtkm::internal::ListAsListTag<vtkm::ListIntersect<ListTag1, ListTag2>>
 {
 };
+/// @endcond
 
 /// A list tag that consists of each item in another list tag fed into a template that takes
 /// a single parameter.
+/// @cond NONE
 template <typename ListTag, template <typename> class Transform>
 struct VTKM_DEPRECATED(
   1.6,
@@ -239,6 +260,7 @@ struct VTKM_DEPRECATED(
   ListTagTransform : vtkm::internal::ListAsListTag<vtkm::ListTransform<ListTag, Transform>>
 {
 };
+/// @endcond
 
 /// A list tag that takes an existing ListTag and a predicate template that is applied to
 /// each type in the ListTag. Any type in the ListTag that has a value element equal to true
@@ -253,6 +275,7 @@ struct VTKM_DEPRECATED(
 /// `std::is_integral<int>` and `std::is_integral<long long>` resolve to `std::true_type`
 /// whereas `std::is_integral<float>` and `std::is_integral<double>` resolve to
 /// `std::false_type`.
+/// @cond NONE
 template <typename ListTag, template <typename> class Predicate>
 struct VTKM_DEPRECATED(
   1.6,
@@ -260,6 +283,7 @@ struct VTKM_DEPRECATED(
   ListTagRemoveIf : vtkm::internal::ListAsListTag<vtkm::ListRemoveIf<ListTag, Predicate>>
 {
 };
+/// @endcond
 
 namespace detail
 {
@@ -273,6 +297,7 @@ using ListToBrigand = vtkm::ListApply<List, brigand::list>;
 /// Generate a tag that is the cross product of two other tags. The resulting
 /// tag has the form of Tag< brigand::list<A1,B1>, brigand::list<A1,B2> .... >
 ///
+/// @cond NONE
 template <typename ListTag1, typename ListTag2>
 struct VTKM_DEPRECATED(
   1.6,
@@ -282,17 +307,20 @@ struct VTKM_DEPRECATED(
       vtkm::ListTransform<vtkm::ListCross<ListTag1, ListTag2>, detail::ListToBrigand>>
 {
 };
+/// @endcond
 
 /// \brief 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.
 ///
+/// @cond NONE
 template <typename ListTag, typename Type>
 struct VTKM_DEPRECATED(1.6, "ListContains replaced by ListHas.") ListContains
   : vtkm::ListHas<ListTag, Type>
 {
 };
+/// @endcond
 
 /// \brief Finds the type at the given index.
 ///

vtkm/TypeListTag.h

@@ -58,6 +58,7 @@ VTK_M_OLD_TYPE_LIST_DEFINITION(VecUncommon);
 
 // Special definition of TypeListTagCommon to give descriptive warning when
 // VTKM_DEFAULT_TYPE_LIST_TAG is used.
+/// @cond NONE
 struct VTKM_ALWAYS_EXPORT
 VTKM_DEPRECATED(
   1.6,
@@ -66,6 +67,7 @@ VTKM_DEPRECATED(
 TypeListTagDefault : vtkm::internal::ListAsListTag<VTKM_DEFAULT_TYPE_LIST>
 {
 };
+/// @endcond
 
 } // namespace internal
 

vtkm/cont/ArrayHandle.h

@@ -381,7 +381,10 @@ public:
   VTKM_DEPRECATED(1.6,
                   "Use ArrayHandle::WritePortal() instead. "
                   "Note that the returned portal will lock the array while it is in scope.")
+
+  /// \cond NOPE
   typename StorageType::PortalType GetPortalControl();
+  /// \endcond
 
   /// Get the array portal of the control array.
   /// Since worklet invocations are asynchronous and this routine is a synchronization point,
@@ -394,7 +397,9 @@ public:
   VTKM_DEPRECATED(1.6,
                   "Use ArrayHandle::ReadPortal() instead. "
                   "Note that the returned portal will lock the array while it is in scope.")
+  /// \cond NOPE
   typename StorageType::PortalConstType GetPortalConstControl() const;
+  /// \endcond
 
   /// \brief Get an array portal that can be used in the control environment.
   ///

vtkm/cont/ArrayHandleSOA.h

@@ -677,6 +677,7 @@ struct Serialization<vtkm::cont::ArrayHandle<ValueType, vtkm::cont::StorageTagSO
 };
 
 } // namespace mangled_diy_namespace
+// @endcond SERIALIZATION
 
 //=============================================================================
 // Precompiled instances

vtkm/cont/ArrayHandleVirtual.h

@@ -270,5 +270,6 @@ VTK_M_ARRAY_HANDLE_VIRTUAL_EXPORT(vtkm::Float64);
 }
 } //namespace vtkm::cont
 
+/// @endcond SERIALIZATION
 
 #endif //vtk_m_cont_ArrayHandleVirtual_h

vtkm/cont/AtomicArray.h

@@ -25,6 +25,7 @@ namespace cont
 
 /// \brief A type list containing types that can be used with an AtomicArray.
 ///
+/// @cond NONE
 using AtomicArrayTypeList = vtkm::List<vtkm::UInt32, vtkm::Int32, vtkm::UInt64, vtkm::Int64>;
 
 struct VTKM_DEPRECATED(1.6,
@@ -33,6 +34,7 @@ struct VTKM_DEPRECATED(1.6,
   : vtkm::internal::ListAsListTag<AtomicArrayTypeList>
 {
 };
+/// @endcond
 
 
 /// A class that can be used to atomically operate on an array of values safely
@@ -88,7 +90,9 @@ public:
   }
 
 private:
+  /// @cond NONE
   vtkm::cont::ArrayHandle<T> Handle;
+  /// @endcond
 };
 }
 } // namespace vtkm::exec

vtkm/cont/CellSetListTag.h

@@ -42,6 +42,7 @@ VTK_M_OLD_CELL_LIST_DEFINITION(Common);
 VTK_M_OLD_CELL_LIST_DEFINITION(Structured);
 VTK_M_OLD_CELL_LIST_DEFINITION(Unstructured);
 
+/// @cond NONE
 template <typename ShapesStorageTag = VTKM_DEFAULT_SHAPES_STORAGE_TAG,
           typename ConnectivityStorageTag = VTKM_DEFAULT_CONNECTIVITY_STORAGE_TAG,
           typename OffsetsStorageTag = VTKM_DEFAULT_OFFSETS_STORAGE_TAG>
@@ -53,10 +54,12 @@ struct VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(
       CellSetListExplicit<ShapesStorageTag, ConnectivityStorageTag, OffsetsStorageTag>>
 {
 };
+/// @endcond
 
 namespace detail
 {
 
+/// @cond NONE
 struct VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(
   1.6,
   "VTKM_DEFAULT_CELL_SET_LIST_TAG replaced by VTKM_DEFAULT_CELL_SET_LIST. "
@@ -64,6 +67,7 @@ struct VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(
   : vtkm::internal::ListAsListTag<VTKM_DEFAULT_CELL_SET_LIST>
 {
 };
+/// @endcond
 
 } // namespace detail
 }

vtkm/cont/DeviceAdapterListTag.h

@@ -25,16 +25,19 @@ namespace vtkm
 namespace cont
 {
 
+/// @cond NONE
 struct VTKM_DEPRECATED(1.6,
                        "DeviceAdapterListTagCommon replaced by DeviceAdapterListCommon. "
                        "Note that the new DeviceAdapterListCommon cannot be subclassed.")
   DeviceAdapterListTagCommon : vtkm::internal::ListAsListTag<DeviceAdapterListCommon>
 {
 };
+/// @endcond
 
 namespace detail
 {
 
+/// @cond NONE
 struct VTKM_DEPRECATED(
   1.6,
   "VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG replaced by VTKM_DEFAULT_DEVICE_ADAPTER_LIST. "
@@ -42,6 +45,7 @@ struct VTKM_DEPRECATED(
   DeviceAdapterListTagDefault : vtkm::internal::ListAsListTag<VTKM_DEFAULT_DEVICE_ADAPTER_LIST>
 {
 };
+/// @endcond
 
 } // namespace detail
 }

vtkm/cont/StorageListTag.h

@@ -31,7 +31,9 @@ struct VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(
   "Note that the new StorageListBasic cannot be subclassed.") StorageListTagBasic
   : vtkm::internal::ListAsListTag<StorageListBasic>
 {
+  /// @cond NONE
 };
+/// @endcond
 
 struct VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(
   1.6,
@@ -39,7 +41,9 @@ struct VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(
   "Note that the new StorageListSupported cannot be subclassed.") StorageListTagSupported
   : vtkm::internal::ListAsListTag<StorageListSupported>
 {
+  /// @cond NONE
 };
+/// @endcond
 
 namespace detail
 {
@@ -50,7 +54,9 @@ struct VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(
   "Note that the new VTKM_DEFAULT_STORAGE_LIST cannot be subclassed.") StorageListTagDefault
   : vtkm::internal::ListAsListTag<VTKM_DEFAULT_STORAGE_LIST>
 {
+  /// @cond NONE
 };
+/// @endcond
 
 } // namespace detail
 }

vtkm/cont/internal/ArrayHandleBasicImpl.h

@@ -405,12 +405,16 @@ public:
   VTKM_DEPRECATED(1.6,
                   "Use ArrayHandle::WritePortal() instead. "
                   "Note that the returned portal will lock the array while it is in scope.")
+  /// @cond NONE
   typename StorageType::PortalType GetPortalControl();
+  /// @endcond
   VTKM_CONT
   VTKM_DEPRECATED(1.6,
                   "Use ArrayHandle::ReadPortal() instead. "
                   "Note that the returned portal will lock the array while it is in scope.")
+  /// @cond NONE
   typename StorageType::PortalConstType GetPortalConstControl() const;
+  /// @endcond
 
   VTKM_CONT ReadPortalType ReadPortal() const;
   VTKM_CONT WritePortalType WritePortal() const;

vtkm/cont/internal/OptionParser.h

@@ -40,7 +40,9 @@ namespace internal
 #endif
 
 // Include from third party.
+// @cond NONE
 #include <vtkmoptionparser/optionparser.h>
+// @endcond
 
 // Now restore the header guards as before so that other includes of (possibly different versions
 // of) optionparser.h work as expected.

vtkm/worklet/Keys.h

@@ -171,6 +171,7 @@ public:
   bool operator!=(const vtkm::worklet::Keys<KeyType>& other) const { return !(*this == other); }
 
 private:
+  /// @cond NONE
   KeyArrayHandleType UniqueKeys;
   vtkm::cont::ArrayHandle<vtkm::Id> SortedValuesMap;
   vtkm::cont::ArrayHandle<vtkm::Id> Offsets;
@@ -182,6 +183,7 @@ private:
   template <typename KeyArrayType>
   VTKM_CONT void BuildArraysInternalStable(const KeyArrayType& keys,
                                            vtkm::cont::DeviceAdapterId device);
+  /// @endcond
 };
 
 template <typename T>