Correct style issue found by CI

cpp/include/cudf/aggregation.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -732,4 +732,4 @@ template <typename Base>
 std::unique_ptr<Base> make_merge_tdigest_aggregation(int max_centroids = 1000);
 
 /** @} */  // end of group
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/ast/expressions.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2020-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

cpp/include/cudf/binaryop.hpp

@@ -259,7 +259,7 @@ std::pair<rmm::device_buffer, size_type> scalar_col_valid_mask_and(
 }  // namespace binops
 
 /** @} */  // end of group
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf
 
 namespace cudf::binops::compiled::detail {
 

cpp/include/cudf/column/column_device_view.cuh

@@ -1497,11 +1497,10 @@ struct mutable_value_accessor {
  * @return The device pointer to be used for the d_children member of the given column
  */
 template <typename ColumnDeviceView, typename ColumnViewIterator>
-CUDF_HIDDEN
-ColumnDeviceView* child_columns_to_device_array(ColumnViewIterator child_begin,
-                                                ColumnViewIterator child_end,
-                                                void* h_ptr,
-                                                void* d_ptr)
+CUDF_HIDDEN ColumnDeviceView* child_columns_to_device_array(ColumnViewIterator child_begin,
+                                                            ColumnViewIterator child_end,
+                                                            void* h_ptr,
+                                                            void* d_ptr)
 {
   ColumnDeviceView* d_children = detail::align_ptr_for_type<ColumnDeviceView>(d_ptr);
   auto num_children            = std::distance(child_begin, child_end);

cpp/include/cudf/column/column_view.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -283,8 +283,7 @@ class column_view_base {
                    size_type offset = 0);
 };
 
-class mutable_column_view_base : public column_view_base {
-};
+class mutable_column_view_base : public column_view_base {};
 
 }  // namespace cudf::detail
 
@@ -767,4 +766,4 @@ std::size_t shallow_hash(column_view const& input);
 bool is_shallow_equivalent(column_view const& lhs, column_view const& rhs);
 
 }  // namespace detail
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/concatenate.hpp

@@ -98,4 +98,4 @@ std::unique_ptr<table> concatenate(
   rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource());
 
 /** @} */  // end of group
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/contiguous_split.hpp

@@ -125,8 +125,14 @@ std::vector<packed_table> contiguous_split(
   rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource());
 
 namespace detail {
+
+/**
+ * @brief A helper struct containing the state of contiguous_split, whether the caller
+ * is using the single-pass contiguous_split or chunked_pack.
+ *
+ */
 struct CUDF_HIDDEN contiguous_split_state;
-};
+}  // namespace detail
 
 /**
  * @brief Perform a chunked "pack" operation of the input `table_view` using a user provided
@@ -339,4 +345,4 @@ table_view unpack(packed_columns const& input);
 table_view unpack(uint8_t const* metadata, uint8_t const* gpu_data);
 
 /** @} */
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/copying.hpp

@@ -973,4 +973,4 @@ std::unique_ptr<column> purge_nonempty_nulls(
   rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource());
 
 /** @} */
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/datetime.hpp

@@ -402,4 +402,4 @@ std::unique_ptr<cudf::column> round_datetimes(
 /** @} */  // end of group
 
 }  // namespace datetime
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/detail/copy_if.cuh

@@ -242,8 +242,8 @@ struct scatter_gather_functor {
                                            rmm::cuda_stream_view stream,
                                            rmm::device_async_resource_ref mr)
   {
-    auto output_column = cudf::allocate_like(
-      input, output_size, cudf::mask_allocation_policy::RETAIN, stream, mr);
+    auto output_column =
+      cudf::allocate_like(input, output_size, cudf::mask_allocation_policy::RETAIN, stream, mr);
     auto output = output_column->mutable_view();
 
     bool has_valid = input.nullable();

cpp/include/cudf/detail/gather.cuh

@@ -217,10 +217,9 @@ struct column_gatherer_impl<Element, std::enable_if_t<is_rep_layout_compatible<E
                                      rmm::cuda_stream_view stream,
                                      rmm::device_async_resource_ref mr)
   {
-    auto const num_rows = cudf::distance(gather_map_begin, gather_map_end);
-    auto const policy   = cudf::mask_allocation_policy::NEVER;
-    auto destination_column =
-      cudf::allocate_like(source_column, num_rows, policy, stream, mr);
+    auto const num_rows     = cudf::distance(gather_map_begin, gather_map_end);
+    auto const policy       = cudf::mask_allocation_policy::NEVER;
+    auto destination_column = cudf::allocate_like(source_column, num_rows, policy, stream, mr);
 
     gather_helper(source_column.data<Element>(),
                   source_column.size(),
@@ -413,8 +412,8 @@ struct column_gatherer_impl<dictionary32> {
     auto keys_copy = std::make_unique<column>(dictionary.keys(), stream, mr);
     // Perform gather on just the indices
     column_view indices = dictionary.get_indices_annotated();
-    auto new_indices    = cudf::allocate_like(
-      indices, output_count, cudf::mask_allocation_policy::NEVER, stream, mr);
+    auto new_indices =
+      cudf::allocate_like(indices, output_count, cudf::mask_allocation_policy::NEVER, stream, mr);
     gather_helper(
       cudf::detail::indexalator_factory::make_input_iterator(indices),
       indices.size(),

cpp/include/cudf/detail/gather.hpp

@@ -85,4 +85,4 @@ std::unique_ptr<table> gather(table_view const& source_table,
                               rmm::device_async_resource_ref mr);
 
 }  // namespace detail
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/detail/is_element_valid.hpp

@@ -45,4 +45,4 @@ bool is_element_valid_sync(column_view const& col_view,
                            rmm::cuda_stream_view stream);
 
 }  // namespace detail
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/detail/utilities/default_stream.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -35,4 +35,4 @@ extern rmm::cuda_stream_view const default_stream_value;
 
 }  // namespace detail
 
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/detail/utilities/stacktrace.hpp

@@ -48,4 +48,4 @@ std::string get_stacktrace(capture_last_stackframe capture_last_frame);
 /** @} */  // end of group
 
 }  // namespace detail
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/detail/utilities/stream_pool.hpp

@@ -125,4 +125,4 @@ cuda_stream_pool& global_cuda_stream_pool();
 void join_streams(host_span<rmm::cuda_stream_view const> streams, rmm::cuda_stream_view stream);
 
 }  // namespace detail
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/dictionary/detail/search.hpp

@@ -64,4 +64,4 @@ std::unique_ptr<scalar> get_insert_index(dictionary_column_view const& dictionar
 
 }  // namespace detail
 }  // namespace dictionary
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/dictionary/dictionary_column_view.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2022, NVIDIA CORPORATION.
+ * Copyright (c) 2020-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

cpp/include/cudf/filling.hpp

@@ -245,4 +245,4 @@ std::unique_ptr<cudf::column> calendrical_month_sequence(
   rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource());
 
 /** @} */  // end of group
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/groupby.hpp

@@ -421,4 +421,4 @@ class groupby {
 };
 /** @} */
 }  // namespace groupby
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/hashing.hpp

@@ -188,4 +188,4 @@ std::unique_ptr<column> xxhash_64(
 }  // namespace hashing
 
 /** @} */  // end of group
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/interop.hpp

@@ -561,4 +561,4 @@ unique_column_view_t from_arrow_device_column(
   rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
 /** @} */  // end of group
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/io/arrow_io_source.hpp

@@ -86,4 +86,4 @@ class arrow_io_source : public datasource {
 
 /** @} */  // end of group
 }  // namespace io
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/io/config_utils.hpp

@@ -50,4 +50,4 @@ bool is_all_enabled();
 bool is_stable_enabled();
 
 }  // namespace io::nvcomp_integration
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/io/detail/avro.hpp

@@ -46,4 +46,4 @@ table_with_metadata read_avro(std::unique_ptr<cudf::io::datasource>&& source,
 }  // namespace avro
 }  // namespace detail
 }  // namespace io
-}  // namespace CUDF_EXPORT cudf
+}  // namespace cudf

cpp/include/cudf/io/detail/csv.hpp

@@ -62,4 +62,4 @@ void write_csv(data_sink* sink,
 }  // namespace csv
 }  // namespace detail
 }  // namespace io
-}  // namespace CUDF_EXPORT cudf
+}  // namespace cudf

cpp/include/cudf/io/detail/parquet.hpp

@@ -34,7 +34,7 @@
 #include <vector>
 
 namespace cudf {
-  namespace io {
+namespace io {
 
 // Forward declaration
 class CUDF_EXPORT parquet_reader_options;

cpp/include/cudf/io/detail/tokenize_json.hpp

@@ -24,8 +24,7 @@
 #include <rmm/device_uvector.hpp>
 #include <rmm/resource_ref.hpp>
 
-namespace CUDF_EXPORT cudf {
-namespace io::json {
+namespace cudf::io::json {
 
 /// Type used to represent the atomic symbol type used within the finite-state machine
 using SymbolT = char;
@@ -119,7 +118,7 @@ enum token_t : PdaTokenT {
   NUM_TOKENS
 };
 
-namespace detail {
+namespace CUDF_EXPORT detail {
 
 /**
  * @brief Parses the given JSON string and emits a sequence of tokens that demarcate relevant
@@ -138,7 +137,6 @@ std::pair<rmm::device_uvector<PdaTokenT>, rmm::device_uvector<SymbolOffsetT>> ge
   rmm::cuda_stream_view stream,
   rmm::device_async_resource_ref mr);
 
-}  // namespace detail
+}  // namespace CUDF_EXPORT detail
 
-}  // namespace io::json
-}  // namespace cudf
+}  // namespace cudf::io::json

cpp/include/cudf/io/memory_resource.hpp

@@ -66,4 +66,4 @@ struct host_mr_options {
 bool config_default_host_memory_resource(host_mr_options const& opts);
 
 }  // namespace io
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/io/nvcomp_adapter.hpp

@@ -21,24 +21,38 @@
 #include <optional>
 #include <string>
 
-
 namespace CUDF_EXPORT cudf {
 namespace io::nvcomp {
 
 enum class compression_type { SNAPPY, ZSTD, DEFLATE, LZ4 };
 
 /**
  * @brief Set of parameters that impact whether the use nvCOMP features is enabled.
+ *
  */
 struct feature_status_parameters {
-  int lib_major_version;
-  int lib_minor_version;
-  int lib_patch_version;
-  bool are_all_integrations_enabled;
-  bool are_stable_integrations_enabled;
-  int compute_capability_major;
+  int lib_major_version;                 ///< major version
+  int lib_minor_version;                 ///< minor version
+  int lib_patch_version;                 ///< patch version
+  bool are_all_integrations_enabled;     ///< all integrations
+  bool are_stable_integrations_enabled;  ///< stable integrations
+  int compute_capability_major;          ///< cuda compute major version
 
+  /**
+   * @brief Default Constructor
+   */
   feature_status_parameters();
+
+  /**pht
+   * @brief feature_status_parameters Constructor
+   *
+   * @param major positive integer representing major value
+   * @param minor positive integer representing minor value
+   * @param patch positive integer representing patch value
+   * @param all_enabled if all integrations are enabled
+   * @param stable_enabled if stable integrations are enabled
+   * @param cc_major cuda compute capability
+   */
   feature_status_parameters(
     int major, int minor, int patch, bool all_enabled, bool stable_enabled, int cc_major)
     : lib_major_version{major},
@@ -89,4 +103,4 @@ inline bool operator==(feature_status_parameters const& lhs, feature_status_para
   compression_type compression, feature_status_parameters params = feature_status_parameters());
 
 }  // namespace io::nvcomp
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/io/orc.hpp

@@ -1461,4 +1461,4 @@ class orc_chunked_writer {
 
 /** @} */  // end of group
 }  // namespace io
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/io/orc_types.hpp

@@ -108,4 +108,4 @@ enum ProtofType : uint8_t {
 
 /** @} */  // end of group
 }  // namespace io::orc
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/io/parquet.hpp

@@ -1407,4 +1407,4 @@ class parquet_chunked_writer {
 /** @} */  // end of group
 
 }  // namespace io
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/io/text/data_chunk_source_factories.hpp

@@ -87,4 +87,4 @@ std::unique_ptr<data_chunk_source> make_source_from_bgzip_file(std::string_view
 std::unique_ptr<data_chunk_source> make_source(cudf::string_scalar& data);
 
 }  // namespace io::text
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf

cpp/include/cudf/join.hpp

@@ -44,13 +44,24 @@ enum class has_nested : bool { YES, NO };
 
 // forward declaration
 namespace hashing::detail {
+
+/**
+ * @brief Forward declaration for our Murmur Hash 3 implementation
+ */
 template <typename T>
 class CUDF_HIDDEN MurmurHash3_x86_32;
 }  // namespace hashing::detail
 namespace detail {
+
+/**
+ * @brief Forward declaration for our hash join
+ */
 template <typename T>
 class CUDF_HIDDEN hash_join;
 
+/**
+ * @brief Forward declaration for our distinct hash join
+ */
 template <cudf::has_nested HasNested>
 class CUDF_HIDDEN distinct_hash_join;
 }  // namespace detail
@@ -1179,4 +1190,4 @@ std::size_t conditional_left_anti_join_size(
   ast::expression const& binary_predicate,
   rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource());
 /** @} */  // end of group
-}  // namespace cudf
+}  // namespace CUDF_EXPORT cudf