Function orSparseWithSparseBitArray

bitarray/or.go:19–74

(sba *sparseBitArray,
	other *sparseBitArray)

package bitarray

func orSparseWithSparseBitArray(sba *sparseBitArray,
	other *sparseBitArray) BitArray {

	if len(other.indices) == 0 {
		return sba.copy()
	}

	if len(sba.indices) == 0 {
		return other.copy()
	}

	max := maxInt64(int64(len(sba.indices)), int64(len(other.indices)))
	indices := make(uintSlice, 0, max)
	blocks := make(blocks, 0, max)

	selfIndex := 0
	otherIndex := 0
	for {
		// last comparison was a real or, we are both exhausted now
		if selfIndex == len(sba.indices) && otherIndex == len(other.indices) {
			break
		} else if selfIndex == len(sba.indices) {
			indices = append(indices, other.indices[otherIndex:]...)
			blocks = append(blocks, other.blocks[otherIndex:]...)
			break
		} else if otherIndex == len(other.indices) {
			indices = append(indices, sba.indices[selfIndex:]...)
			blocks = append(blocks, sba.blocks[selfIndex:]...)
			break
		}

		selfValue := sba.indices[selfIndex]
		otherValue := other.indices[otherIndex]

		switch diff := int(otherValue) - int(selfValue); {
		case diff > 0:
			indices = append(indices, selfValue)
			blocks = append(blocks, sba.blocks[selfIndex])
			selfIndex++
		case diff < 0:
			indices = append(indices, otherValue)
			blocks = append(blocks, other.blocks[otherIndex])
			otherIndex++
		default:
			indices = append(indices, otherValue)
			blocks = append(blocks, sba.blocks[selfIndex].or(other.blocks[otherIndex]))
			selfIndex++
			otherIndex++
		}
	}

	return &sparseBitArray{
		indices: indices,
		blocks:  blocks,
	}
}

func orSparseWithDenseBitArray(sba *sparseBitArray, other *bitArray) BitArray {