Writer-side cleanup: unify AppendingStringWriter, qualify ::arrow namespace

Merge StringLikeWriter and EnumWriter into a single AppendingStringWriter
template. Qualify arrow:: as ::arrow:: consistently across writer headers
and sources. Standardize include guards.

Signed-off-by: Arham Chopra <arham.chopra@cubistsystematic.com>

Author: arhamchopra

cpp/csp/adapters/arrow/ArrowFieldWriter.cpp

@@ -18,7 +18,6 @@ namespace csp::adapters::arrow
 #define ARROW_OK_OR_THROW( expr, msg ) \
     do { auto _st = ( expr ); if( !_st.ok() ) CSP_THROW( RuntimeException, msg << ": " << _st.ToString() ); } while(0)
 
-// --- Base class default implementations ---
 
 void FieldWriter::reserve( int64_t numRows )
 {
@@ -54,7 +53,6 @@ std::vector<std::shared_ptr<::arrow::Array>> FieldWriter::finish()
 namespace
 {
 
-// --- Generic lambda-based writer for fixed-length types ---
 // ValueFn signature: auto(const Struct *) — returns the value to UnsafeAppend/Append.
 // Covers: all numeric primitives, bool, DateTime, TimeDelta, Time, Date.
 
@@ -123,16 +121,17 @@ CreatedFieldWriter makeNanosWriter( const std::string & name, const StructFieldP
     } );
 }
 
-// --- String / Bytes writer (variable-length: needs safe Append) ---
 
-template<typename ArrowBuilderT>
-class StringLikeWriter final : public FieldWriter
+// Appending string writer: covers both StringLikeWriter and EnumWriter via ExtractFn.
+// ExtractFn signature: const char* (const Struct*, size_t& len)
+template<typename ArrowBuilderT, typename ExtractFn>
+class AppendingStringWriter final : public FieldWriter
 {
 public:
-    StringLikeWriter( const std::string & columnName, const StructFieldPtr & field,
-                      std::shared_ptr<::arrow::DataType> dataType )
+    AppendingStringWriter( const std::string & columnName, const StructFieldPtr & field,
+                           std::shared_ptr<::arrow::DataType> dataType, ExtractFn fn )
         : FieldWriter( columnName, field, std::make_shared<ArrowBuilderT>(), std::move( dataType ) ),
-          m_typedBuilder( static_cast<ArrowBuilderT *>( m_builder.get() ) ) {}
+          m_typedBuilder( static_cast<ArrowBuilderT *>( m_builder.get() ) ), m_fn( std::move( fn ) ) {}
 
     void writeAll( const std::vector<StructPtr> & structs, int64_t offset, int64_t count ) override
     {
@@ -141,8 +140,9 @@ class StringLikeWriter final : public FieldWriter
             const Struct * s = structs[i].get();
             if( m_field -> isSet( s ) )
             {
-                auto & val = m_field -> value<std::string>( s );
-                ARROW_OK_OR_THROW( m_typedBuilder -> Append( val.c_str(), val.length() ), "Failed to append string/bytes" );
+                size_t len;
+                auto * data = m_fn( s, len );
+                ARROW_OK_OR_THROW( m_typedBuilder -> Append( data, len ), "Failed to append value" );
             }
             else
                 ARROW_OK_OR_THROW( m_typedBuilder -> AppendNull(), "Failed to append null" );
@@ -152,50 +152,16 @@ class StringLikeWriter final : public FieldWriter
 protected:
     void doWrite( const Struct * s ) override
     {
-        auto & val = m_field -> value<std::string>( s );
-        ARROW_OK_OR_THROW( m_typedBuilder -> Append( val.c_str(), val.length() ), "Failed to append string/bytes" );
+        size_t len;
+        auto * data = m_fn( s, len );
+        ARROW_OK_OR_THROW( m_typedBuilder -> Append( data, len ), "Failed to append value" );
     }
 
 private:
     ArrowBuilderT * m_typedBuilder;
+    ExtractFn       m_fn;
 };
 
-// --- Enum writer (variable-length string: CspEnum → name()) ---
-
-class EnumWriter final : public FieldWriter
-{
-public:
-    EnumWriter( const std::string & columnName, const StructFieldPtr & field )
-        : FieldWriter( columnName, field, std::make_shared<::arrow::StringBuilder>(), ::arrow::utf8() ),
-          m_typedBuilder( static_cast<::arrow::StringBuilder *>( m_builder.get() ) ) {}
-
-    void writeAll( const std::vector<StructPtr> & structs, int64_t offset, int64_t count ) override
-    {
-        for( int64_t i = offset; i < offset + count; ++i )
-        {
-            const Struct * s = structs[i].get();
-            if( m_field -> isSet( s ) )
-            {
-                auto & n = m_field -> value<CspEnum>( s ).name();
-                ARROW_OK_OR_THROW( m_typedBuilder -> Append( n.c_str(), n.length() ), "Failed to append enum" );
-            }
-            else
-                ARROW_OK_OR_THROW( m_typedBuilder -> AppendNull(), "Failed to append null" );
-        }
-    }
-
-protected:
-    void doWrite( const Struct * s ) override
-    {
-        auto & n = m_field -> value<CspEnum>( s ).name();
-        ARROW_OK_OR_THROW( m_typedBuilder -> Append( n.c_str(), n.length() ), "Failed to append enum" );
-    }
-
-private:
-    ::arrow::StringBuilder * m_typedBuilder;
-};
-
-// --- Nested struct writer (recursive) ---
 
 class NestedStructWriter final : public FieldWriter
 {
@@ -262,7 +228,6 @@ class NestedStructWriter final : public FieldWriter
     std::vector<std::unique_ptr<FieldWriter>> m_childWriters;
 };
 
-// --- Factory helpers ---
 
 bool isBytesField( const StructFieldPtr & field )
 {
@@ -290,7 +255,6 @@ CreatedFieldWriter createFieldWriter(
 
     switch( f -> type() -> type() )
     {
-        // --- Numeric ---
         case CspType::Type::BOOL:
         {
             auto b = std::make_shared<::arrow::BooleanBuilder>();
@@ -307,15 +271,28 @@ CreatedFieldWriter createFieldWriter(
         case CspType::Type::UINT64: return makePrimitiveWriter<uint64_t, ::arrow::UInt64Builder>( columnName, f );
         case CspType::Type::DOUBLE: return makePrimitiveWriter<double,   ::arrow::DoubleBuilder>( columnName, f );
 
-        // --- String / Bytes ---
         case CspType::Type::STRING:
+        {
+            auto extractor = [f]( const Struct * s, size_t & len ) -> const char * {
+                auto & val = f -> value<std::string>( s );
+                len = val.length();
+                return val.c_str();
+            };
             if( isBytesField( f ) )
-                return makeWriter<StringLikeWriter<::arrow::BinaryBuilder>>( columnName, f, ::arrow::binary() );
-            return makeWriter<StringLikeWriter<::arrow::StringBuilder>>( columnName, f, ::arrow::utf8() );
+                return makeWriter<AppendingStringWriter<::arrow::BinaryBuilder, decltype(extractor)>>( columnName, f, ::arrow::binary(), extractor );
+            return makeWriter<AppendingStringWriter<::arrow::StringBuilder, decltype(extractor)>>( columnName, f, ::arrow::utf8(), extractor );
+        }
 
-        case CspType::Type::ENUM: return makeWriter<EnumWriter>( columnName, f );
+        case CspType::Type::ENUM:
+        {
+            auto extractor = [f]( const Struct * s, size_t & len ) -> const char * {
+                auto & n = f -> value<CspEnum>( s ).name();
+                len = n.length();
+                return n.c_str();
+            };
+            return makeWriter<AppendingStringWriter<::arrow::StringBuilder, decltype(extractor)>>( columnName, f, ::arrow::utf8(), extractor );
+        }
 
-        // --- Temporal ---
         case CspType::Type::DATETIME:
             return makeNanosWriter<DateTime, ::arrow::TimestampBuilder>(
                 columnName, f, std::make_shared<::arrow::TimestampType>( ::arrow::TimeUnit::NANO, "UTC" ) );
@@ -326,7 +303,6 @@ CreatedFieldWriter createFieldWriter(
             return makeNanosWriter<Time, ::arrow::Time64Builder>(
                 columnName, f, std::make_shared<::arrow::Time64Type>( ::arrow::TimeUnit::NANO ) );
 
-        // --- Date (days since epoch) ---
         case CspType::Type::DATE:
         {
             auto b = std::make_shared<::arrow::Date32Builder>();
@@ -336,7 +312,6 @@ CreatedFieldWriter createFieldWriter(
             } );
         }
 
-        // --- Nested struct ---
         case CspType::Type::STRUCT:
         {
             auto nestedMeta = std::static_pointer_cast<const CspStructType>( f -> type() ) -> meta();
@@ -373,7 +348,6 @@ CreatedFieldWriter createFieldWriter(
 
 #undef ARROW_OK_OR_THROW
 
-// --- List field writer factory ---
 
 static ListFieldWriterFactory s_listFieldWriterFactory;
 

cpp/csp/adapters/arrow/ArrowFieldWriter.h

@@ -101,7 +101,6 @@ CreatedFieldWriter createFieldWriter(
     const StructFieldPtr & structField
 );
 
-// --- List field writer factory (dependency injection for numpy list support) ---
 
 // A function that writes a DialectGenericType (e.g. numpy array) into an arrow list builder.
 // The function handles list-start, element conversion, etc.
@@ -122,4 +121,4 @@ std::pair<std::shared_ptr<::arrow::ArrayBuilder>, ListItemsWriter> createListFie
 
 }
 
-#endif
+#endif // _IN_CSP_ADAPTERS_ARROW_ArrowFieldWriter_H

cpp/csp/adapters/arrow/RecordBatchToStruct.h

@@ -49,4 +49,4 @@ class RecordBatchToStructConverter
 
 }
 
-#endif
+#endif // _IN_CSP_ADAPTERS_ARROW_RecordBatchToStruct_H

cpp/csp/adapters/arrow/StructToRecordBatch.h

@@ -47,4 +47,4 @@ class StructToRecordBatchConverter
 
 }
 
-#endif
+#endif // _IN_CSP_ADAPTERS_ARROW_StructToRecordBatch_H

cpp/csp/adapters/parquet/ArrowIPCFileWriterWrapper.cpp

@@ -13,9 +13,9 @@ void ArrowIPCFileWriterWrapper::openImpl( const std::string &fileName, const std
 
     PARQUET_ASSIGN_OR_THROW(
             m_outputStream,
-            arrow::io::FileOutputStream::Open( fileName.c_str()));
+            ::arrow::io::FileOutputStream::Open( fileName.c_str()));
 
-    arrow::ipc::IpcWriteOptions writeOptions;
+    ::arrow::ipc::IpcWriteOptions writeOptions;
     writeOptions.codec  = resolveCompressionCodec( compression );
 
     STATUS_OK_OR_THROW_RUNTIME(

cpp/csp/adapters/parquet/ArrowIPCFileWriterWrapper.h

@@ -41,4 +41,4 @@ class ArrowIPCFileWriterWrapper : public FileWriterWrapper
 }
 
 
-#endif
+#endif // _IN_CSP_ADAPTERS_PARQUET_ArrowIPCFileWriterWrapper_H