Scribd
Upload
42 views

Array Go

This document defines an Arr type in Go that represents an array in BSON. It implements String, MarshalBSONValue, UnmarshalBSONValue, and Equal methods to serialize and deserialize the array to and from BSON, and compare equality. It also imports necessary packages like bytes and errors for string formatting and errors.

Uploaded by

Andrzej Strozynski
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
42 views

Array Go

This document defines an Arr type in Go that represents an array in BSON. It implements String, MarshalBSONValue, UnmarshalBSONValue, and Equal methods to serialize and deserialize the array to and from BSON, and compare equality. It also imports necessary packages like bytes and errors for string formatting and errors.

Uploaded by

Andrzej Strozynski
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 2

// 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() {}

You might also like