aiforge/vendor/go.mongodb.org/mongo-driver/x/bsonx/array.go

// Copyright (C) MongoDB, Inc. 2017-present.
//
// Licensed 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

package bsonx // import "go.mongodb.org/mongo-driver/x/bsonx"

import (
	"bytes"
	"errors"
	"fmt"
	"strconv"

	"go.mongodb.org/mongo-driver/bson/bsontype"
	"go.mongodb.org/mongo-driver/x/bsonx/bsoncore"
)

// ErrNilArray indicates that an operation was attempted on a nil *Array.
var ErrNilArray = errors.New("array is nil")

// Arr represents an array in BSON.
type Arr []Val

// String implements the fmt.Stringer interface.
func (a Arr) String() string {
	var buf bytes.Buffer
	buf.Write([]byte("bson.Array["))
	for idx, val := range a {
		if idx > 0 {
			buf.Write([]byte(", "))
		}
		fmt.Fprintf(&buf, "%s", val)
	}
	buf.WriteByte(']')

	return buf.String()
}

// MarshalBSONValue implements the bsoncodec.ValueMarshaler interface.
func (a Arr) MarshalBSONValue() (bsontype.Type, []byte, error) {
	if a == nil {
		// TODO: Should we do this?
		return bsontype.Null, nil, nil
	}

	idx, dst := bsoncore.ReserveLength(nil)
	for idx, value := range a {
		t, data, _ := value.MarshalBSONValue() // marshalBSONValue never returns an error.
		dst = append(dst, byte(t))
		dst = append(dst, strconv.Itoa(idx)...)
		dst = append(dst, 0x00)
		dst = append(dst, data...)
	}
	dst = append(dst, 0x00)
	dst = bsoncore.UpdateLength(dst, idx, int32(len(dst[idx:])))
	return bsontype.Array, dst, nil
}

// UnmarshalBSONValue implements the bsoncodec.ValueUnmarshaler interface.
func (a *Arr) UnmarshalBSONValue(t bsontype.Type, data []byte) error {
	if a == nil {
		return ErrNilArray
	}
	*a = (*a)[:0]

	elements, err := bsoncore.Document(data).Elements()
	if err != nil {
		return err
	}

	for _, elem := range elements {
		var val Val
		rawval := elem.Value()
		err = val.UnmarshalBSONValue(rawval.Type, rawval.Data)
		if err != nil {
			return err
		}
		*a = append(*a, val)
	}
	return nil
}

// Equal compares this document to another, returning true if they are equal.
func (a Arr) Equal(a2 Arr) bool {
	if len(a) != len(a2) {
		return false
	}
	for idx := range a {
		if !a[idx].Equal(a2[idx]) {
			return false
		}
	}
	return true
}

func (Arr) idoc() {}