1 files changed, 194 insertions, 0 deletions
diff --git a/src/arrow/csharp/src/Apache.Arrow/Arrays/BooleanArray.cs b/src/arrow/csharp/src/Apache.Arrow/Arrays/BooleanArray.cs
new file mode 100644
index 000000000..0915338fe
--- /dev/null
+++ b/src/arrow/csharp/src/Apache.Arrow/Arrays/BooleanArray.cs
@@ -0,0 +1,194 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Apache.Arrow.Memory;
+using Apache.Arrow.Types;
+using System;
+using System.Collections.Generic;
+
+namespace Apache.Arrow
+{
+    public class BooleanArray: Array
+    {
+        public class Builder : IArrowArrayBuilder<bool, BooleanArray, Builder>
+        {
+            private ArrowBuffer.BitmapBuilder ValueBuffer { get; }
+            private ArrowBuffer.BitmapBuilder ValidityBuffer { get; }
+
+            public int Length => ValueBuffer.Length;
+            public int Capacity => ValueBuffer.Capacity;
+            public int NullCount => ValidityBuffer.UnsetBitCount;
+
+            public Builder()
+            {
+                ValueBuffer = new ArrowBuffer.BitmapBuilder();
+                ValidityBuffer = new ArrowBuffer.BitmapBuilder();
+            }
+
+            public Builder Append(bool value)
+            {
+                return NullableAppend(value);
+            }
+
+            public Builder NullableAppend(bool? value)
+            {
+                // Note that we rely on the fact that null values are false in the value buffer.
+                ValueBuffer.Append(value ?? false);
+                ValidityBuffer.Append(value.HasValue);
+                return this;
+            }
+
+            public Builder Append(ReadOnlySpan<bool> span)
+            {
+                foreach (bool value in span)
+                {
+                    Append(value);
+                }
+                return this;
+            }
+
+            public Builder AppendRange(IEnumerable<bool> values)
+            {
+                foreach (bool value in values)
+                {
+                    Append(value);
+                }
+                return this;
+            }
+
+            public Builder AppendNull()
+            {
+                return NullableAppend(null);
+            }
+
+            public BooleanArray Build(MemoryAllocator allocator = default)
+            {
+                ArrowBuffer validityBuffer = NullCount > 0
+                                        ? ValidityBuffer.Build(allocator)
+                                        : ArrowBuffer.Empty;
+
+                return new BooleanArray(
+                    ValueBuffer.Build(allocator), validityBuffer,
+                    Length, NullCount, 0);
+            }
+
+            public Builder Clear()
+            {
+                ValueBuffer.Clear();
+                ValidityBuffer.Clear();
+                return this;
+            }
+
+            public Builder Reserve(int capacity)
+            {
+                if (capacity < 0)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(capacity));
+                }
+
+                ValueBuffer.Reserve(capacity);
+                ValidityBuffer.Reserve(capacity);
+                return this;
+            }
+
+            public Builder Resize(int length)
+            {
+                if (length < 0)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(length));
+                }
+
+                ValueBuffer.Resize(length);
+                ValidityBuffer.Resize(length);
+                return this;
+            }
+
+            public Builder Toggle(int index)
+            {
+                CheckIndex(index);
+
+                // If there is a null at this index, assume it was set to false in the value buffer, and so becomes
+                // true/non-null after toggling.
+                ValueBuffer.Toggle(index);
+                ValidityBuffer.Set(index);
+                return this;
+            }
+
+            public Builder Set(int index)
+            {
+                CheckIndex(index);
+                ValueBuffer.Set(index);
+                ValidityBuffer.Set(index);
+                return this;
+            }
+
+            public Builder Set(int index, bool value)
+            {
+                CheckIndex(index);
+                ValueBuffer.Set(index, value);
+                ValidityBuffer.Set(index);
+                return this;
+            }
+
+            public Builder Swap(int i, int j)
+            {
+                CheckIndex(i);
+                CheckIndex(j);
+                ValueBuffer.Swap(i, j);
+                ValidityBuffer.Swap(i, j);
+                return this;
+            }
+
+            private void CheckIndex(int index)
+            {
+                if (index < 0 || index >= Length)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(index));
+                }
+            }
+        }
+
+        public ArrowBuffer ValueBuffer => Data.Buffers[1];
+        public ReadOnlySpan<byte> Values => ValueBuffer.Span.Slice(0, (int) Math.Ceiling(Length / 8.0));
+
+        public BooleanArray(
+            ArrowBuffer valueBuffer, ArrowBuffer nullBitmapBuffer,
+            int length, int nullCount, int offset)
+            : this(new ArrayData(BooleanType.Default, length, nullCount, offset,
+                new[] { nullBitmapBuffer, valueBuffer }))
+        { }
+
+        public BooleanArray(ArrayData data)
+            : base(data)
+        {
+            data.EnsureDataType(ArrowTypeId.Boolean);
+        }
+
+        public override void Accept(IArrowArrayVisitor visitor) => Accept(this, visitor);
+
+        [Obsolete("GetBoolean does not support null values. Use GetValue instead (which this method invokes internally).")]
+        public bool GetBoolean(int index)
+        {
+            return GetValue(index).GetValueOrDefault();
+        }
+
+        public bool? GetValue(int index)
+        {
+            return IsNull(index)
+                ? (bool?)null
+                : BitUtility.GetBit(ValueBuffer.Span, index + Offset);
+        }
+    }
+}