fix windows build

Author: wgtmac

src/iceberg/avro/avro_stream_internal.h

@@ -22,9 +22,11 @@
 #include <arrow/io/interfaces.h>
 #include <avro/Stream.hh>
 
+#include "iceberg/iceberg_bundle_export.h"
+
 namespace iceberg::avro {
 
-class AvroInputStream : public ::avro::SeekableInputStream {
+class ICEBERG_BUNDLE_EXPORT AvroInputStream : public ::avro::SeekableInputStream {
  public:
   explicit AvroInputStream(std::shared_ptr<::arrow::io::RandomAccessFile> input_stream,
                            int64_t buffer_size);
@@ -62,7 +64,7 @@ class AvroInputStream : public ::avro::SeekableInputStream {
   size_t available_bytes_ = 0;  // bytes available in the buffer
 };
 
-class AvroOutputStream : public ::avro::OutputStream {
+class ICEBERG_BUNDLE_EXPORT AvroOutputStream : public ::avro::OutputStream {
  public:
   explicit AvroOutputStream(std::shared_ptr<::arrow::io::OutputStream> output_stream,
                             int64_t buffer_size);

src/iceberg/expected.h

@@ -122,7 +122,7 @@ inline constexpr bool is_error_type_valid_v = is_error_type_valid<T>::value;
 }  // namespace expected_detail
 
 template <class E>
-class ICEBERG_EXPORT [[nodiscard]] unexpected {
+class [[nodiscard]] unexpected {
  public:
   static_assert(expected_detail::is_error_type_valid_v<E>);
 
@@ -192,7 +192,7 @@ class ICEBERG_EXPORT [[nodiscard]] unexpected {
 template <class E>
 unexpected(E) -> unexpected<E>;
 
-struct ICEBERG_EXPORT unexpect_t {
+struct unexpect_t {
   explicit unexpect_t() = default;
 };
 inline constexpr unexpect_t unexpect{};
@@ -201,7 +201,7 @@ template <class E>
 class bad_expected_access;
 
 template <>
-class ICEBERG_EXPORT bad_expected_access<void> : public std::exception {
+class bad_expected_access<void> : public std::exception {
  public:
   const char* what() const noexcept override { return "Bad expected access"; }
 
@@ -214,7 +214,7 @@ class ICEBERG_EXPORT bad_expected_access<void> : public std::exception {
 };
 
 template <class E>
-class ICEBERG_EXPORT bad_expected_access : public bad_expected_access<void> {
+class bad_expected_access : public bad_expected_access<void> {
  public:
   explicit bad_expected_access(E e) noexcept(std::is_nothrow_move_constructible_v<E>)
       : m_val(std::move(e)) {}
@@ -1006,9 +1006,8 @@ struct default_ctor_base<T, E, false> {
 /// tracked by the expected object.
 
 template <class T, class E>
-class ICEBERG_EXPORT [[nodiscard]] expected
-    : private expected_detail::move_assign_base<T, E>,
-      private expected_detail::default_ctor_base<T, E> {
+class [[nodiscard]] expected : private expected_detail::move_assign_base<T, E>,
+                               private expected_detail::default_ctor_base<T, E> {
   static_assert(expected_detail::is_value_type_valid_v<T>);
   static_assert(expected_detail::is_error_type_valid_v<E>);
 
@@ -1798,7 +1797,7 @@ constexpr void swap(expected<T, E>& lhs,
 }
 
 template <class E>
-class ICEBERG_EXPORT [[nodiscard]] expected<void, E>
+class [[nodiscard]] expected<void, E>
     : private expected_detail::move_assign_base<void, E>,
       private expected_detail::default_ctor_base<void, E> {
   static_assert(expected_detail::is_error_type_valid_v<E>);
@@ -2349,8 +2348,8 @@ class ICEBERG_EXPORT [[nodiscard]] expected<void, E>
 // standalone swap for void value type
 template <class E, std::enable_if_t<std::is_move_constructible_v<E> &&
                                     std::is_swappable_v<E>>* = nullptr>
-ICEBERG_EXPORT constexpr void swap(
-    expected<void, E>& lhs, expected<void, E>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+constexpr void swap(expected<void, E>& lhs,
+                    expected<void, E>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
   lhs.swap(rhs);
 }
 

src/iceberg/schema_internal.h

@@ -24,6 +24,7 @@
 
 #include <nanoarrow/nanoarrow.h>
 
+#include "iceberg/iceberg_export.h"
 #include "iceberg/result.h"
 #include "iceberg/type_fwd.h"
 
@@ -39,22 +40,22 @@ constexpr std::string_view kFieldIdKey = "ICEBERG:field_id";
 /// \param[in] schema The Iceberg schema to convert.
 /// \param[out] out The Arrow schema to convert to.
 /// \return An error if the conversion fails.
-Status ToArrowSchema(const Schema& schema, ArrowSchema* out);
+ICEBERG_EXPORT Status ToArrowSchema(const Schema& schema, ArrowSchema* out);
 
 /// \brief Convert an Arrow schema to an Iceberg schema.
 ///
 /// \param[in] schema The Arrow schema to convert.
 /// \param[in] schema_id The schema ID of the Iceberg schema.
 /// \return The Iceberg schema or an error if the conversion fails.
-Result<std::unique_ptr<Schema>> FromArrowSchema(const ArrowSchema& schema,
-                                                std::optional<int32_t> schema_id);
+ICEBERG_EXPORT Result<std::unique_ptr<Schema>> FromArrowSchema(
+    const ArrowSchema& schema, std::optional<int32_t> schema_id);
 
 /// \brief Convert a struct type to an Iceberg schema.
 ///
 /// \param[in] struct_type The struct type to convert.
 /// \param[in] schema_id The schema ID of the Iceberg schema.
 /// \return The Iceberg schema.
-std::unique_ptr<Schema> FromStructType(StructType&& struct_type,
-                                       std::optional<int32_t> schema_id);
+ICEBERG_EXPORT std::unique_ptr<Schema> FromStructType(StructType&& struct_type,
+                                                      std::optional<int32_t> schema_id);
 
 }  // namespace iceberg