// 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.

package array

import (
	
	
	
	

	
	
	
	
	
)

type BooleanBuilder struct {
	builder

	data    *memory.Buffer
	rawData []byte
}

func ( memory.Allocator) *BooleanBuilder {
	 := &BooleanBuilder{builder: builder{mem: }}
	.refCount.Add(1)
	return 
}

func ( *BooleanBuilder) () arrow.DataType { return arrow.FixedWidthTypes.Boolean }

// Release decreases the reference count by 1.
// When the reference count goes to zero, the memory is freed.
// Release may be called simultaneously from multiple goroutines.
func ( *BooleanBuilder) () {
	debug.Assert(.refCount.Load() > 0, "too many releases")

	if .refCount.Add(-1) == 0 {
		if .nullBitmap != nil {
			.nullBitmap.Release()
			.nullBitmap = nil
		}
		if .data != nil {
			.data.Release()
			.data = nil
			.rawData = nil
		}
	}
}

func ( *BooleanBuilder) ( bool) {
	.Reserve(1)
	.UnsafeAppend()
}

func ( *BooleanBuilder) ( byte) {
	.Reserve(1)
	.UnsafeAppend( != 0)
}

func ( *BooleanBuilder) () {
	.Reserve(1)
	.UnsafeAppendBoolToBitmap(false)
}

func ( *BooleanBuilder) ( int) {
	for  := 0;  < ; ++ {
		.AppendNull()
	}
}

func ( *BooleanBuilder) () {
	.Reserve(1)
	.UnsafeAppend(false)
}

func ( *BooleanBuilder) ( int) {
	for  := 0;  < ; ++ {
		.AppendEmptyValue()
	}
}

func ( *BooleanBuilder) ( string) error {
	if  == NullValueStr {
		.AppendNull()
		return nil
	}
	,  := strconv.ParseBool()
	if  != nil {
		return 
	}
	.Append()
	return nil
}

func ( *BooleanBuilder) ( bool) {
	bitutil.SetBit(.nullBitmap.Bytes(), .length)
	if  {
		bitutil.SetBit(.rawData, .length)
	} else {
		bitutil.ClearBit(.rawData, .length)
	}
	.length++
}

func ( *BooleanBuilder) ( []bool,  []bool) {
	if len() != len() && len() != 0 {
		panic("len(v) != len(valid) && len(valid) != 0")
	}

	if len() == 0 {
		return
	}

	.Reserve(len())
	for ,  := range  {
		bitutil.SetBitTo(.rawData, .length+, )
	}
	.unsafeAppendBoolsToBitmap(, len())
}

func ( *BooleanBuilder) ( int) {
	.builder.init()

	.data = memory.NewResizableBuffer(.mem)
	 := arrow.BooleanTraits.BytesRequired()
	.data.Resize()
	.rawData = .data.Bytes()
}

// Reserve ensures there is enough space for appending n elements
// by checking the capacity and calling Resize if necessary.
func ( *BooleanBuilder) ( int) {
	.reserve(, .Resize)
}

// Resize adjusts the space allocated by b to n elements. If n is greater than b.Cap(),
// additional memory will be allocated. If n is smaller, the allocated memory may reduced.
func ( *BooleanBuilder) ( int) {
	if  < minBuilderCapacity {
		 = minBuilderCapacity
	}

	if .capacity == 0 {
		.init()
	} else {
		.resize(, .init)
		.data.Resize(arrow.BooleanTraits.BytesRequired())
		.rawData = .data.Bytes()
	}
}

// NewArray creates a Boolean array from the memory buffers used by the builder and resets the BooleanBuilder
// so it can be used to build a new array.
func ( *BooleanBuilder) () arrow.Array {
	return .NewBooleanArray()
}

// NewBooleanArray creates a Boolean array from the memory buffers used by the builder and resets the BooleanBuilder
// so it can be used to build a new array.
func ( *BooleanBuilder) () ( *Boolean) {
	 := .newData()
	 = NewBooleanData()
	.Release()
	return
}

func ( *BooleanBuilder) () *Data {
	 := arrow.BooleanTraits.BytesRequired(.length)
	if  > 0 &&  < .data.Len() {
		// trim buffers
		.data.Resize()
	}
	 := NewData(arrow.FixedWidthTypes.Boolean, .length, []*memory.Buffer{.nullBitmap, .data}, nil, .nulls, 0)
	.reset()

	if .data != nil {
		.data.Release()
		.data = nil
		.rawData = nil
	}

	return 
}

func ( *BooleanBuilder) ( *json.Decoder) error {
	,  := .Token()
	if  != nil {
		return 
	}

	switch v := .(type) {
	case bool:
		.Append()
	case string:
		,  := strconv.ParseBool()
		if  != nil {
			return 
		}
		.Append()
	case json.Number:
		,  := strconv.ParseBool(.String())
		if  != nil {
			return 
		}
		.Append()
	case nil:
		.AppendNull()
	default:
		return &json.UnmarshalTypeError{
			Value:  fmt.Sprint(),
			Type:   reflect.TypeOf(true),
			Offset: .InputOffset(),
		}
	}
	return nil
}

func ( *BooleanBuilder) ( *json.Decoder) error {
	for .More() {
		if  := .UnmarshalOne();  != nil {
			return 
		}
	}
	return nil
}

func ( *BooleanBuilder) ( []byte) error {
	 := json.NewDecoder(bytes.NewReader())
	.UseNumber()
	,  := .Token()
	if  != nil {
		return 
	}

	if ,  := .(json.Delim); ! ||  != '[' {
		return fmt.Errorf("boolean builder must unpack from json array, found %s", )
	}

	return .Unmarshal()
}

func ( *BooleanBuilder) ( int) bool {
	return bitutil.BitIsSet(.rawData, )
}

var _ Builder = (*BooleanBuilder)(nil)