github.com/ipld/go-ipld-prime@v0.21.0/node/basicnode/bytes.go (about)

     1  package basicnode
     2  
     3  import (
     4  	"bytes"
     5  	"io"
     6  
     7  	"github.com/ipld/go-ipld-prime/datamodel"
     8  	"github.com/ipld/go-ipld-prime/node/mixins"
     9  )
    10  
    11  var (
    12  	_ datamodel.Node          = plainBytes(nil)
    13  	_ datamodel.NodePrototype = Prototype__Bytes{}
    14  	_ datamodel.NodeBuilder   = &plainBytes__Builder{}
    15  	_ datamodel.NodeAssembler = &plainBytes__Assembler{}
    16  )
    17  
    18  func NewBytes(value []byte) datamodel.Node {
    19  	v := plainBytes(value)
    20  	return &v
    21  }
    22  
    23  // plainBytes is a simple boxed byte slice that complies with datamodel.Node.
    24  type plainBytes []byte
    25  
    26  // -- Node interface methods -->
    27  
    28  func (plainBytes) Kind() datamodel.Kind {
    29  	return datamodel.Kind_Bytes
    30  }
    31  func (plainBytes) LookupByString(string) (datamodel.Node, error) {
    32  	return mixins.Bytes{TypeName: "bytes"}.LookupByString("")
    33  }
    34  func (plainBytes) LookupByNode(key datamodel.Node) (datamodel.Node, error) {
    35  	return mixins.Bytes{TypeName: "bytes"}.LookupByNode(nil)
    36  }
    37  func (plainBytes) LookupByIndex(idx int64) (datamodel.Node, error) {
    38  	return mixins.Bytes{TypeName: "bytes"}.LookupByIndex(0)
    39  }
    40  func (plainBytes) LookupBySegment(seg datamodel.PathSegment) (datamodel.Node, error) {
    41  	return mixins.Bytes{TypeName: "bytes"}.LookupBySegment(seg)
    42  }
    43  func (plainBytes) MapIterator() datamodel.MapIterator {
    44  	return nil
    45  }
    46  func (plainBytes) ListIterator() datamodel.ListIterator {
    47  	return nil
    48  }
    49  func (plainBytes) Length() int64 {
    50  	return -1
    51  }
    52  func (plainBytes) IsAbsent() bool {
    53  	return false
    54  }
    55  func (plainBytes) IsNull() bool {
    56  	return false
    57  }
    58  func (plainBytes) AsBool() (bool, error) {
    59  	return mixins.Bytes{TypeName: "bytes"}.AsBool()
    60  }
    61  func (plainBytes) AsInt() (int64, error) {
    62  	return mixins.Bytes{TypeName: "bytes"}.AsInt()
    63  }
    64  func (plainBytes) AsFloat() (float64, error) {
    65  	return mixins.Bytes{TypeName: "bytes"}.AsFloat()
    66  }
    67  func (plainBytes) AsString() (string, error) {
    68  	return mixins.Bytes{TypeName: "bytes"}.AsString()
    69  }
    70  func (n plainBytes) AsBytes() ([]byte, error) {
    71  	return []byte(n), nil
    72  }
    73  func (plainBytes) AsLink() (datamodel.Link, error) {
    74  	return mixins.Bytes{TypeName: "bytes"}.AsLink()
    75  }
    76  func (plainBytes) Prototype() datamodel.NodePrototype {
    77  	return Prototype__Bytes{}
    78  }
    79  func (n plainBytes) AsLargeBytes() (io.ReadSeeker, error) {
    80  	return bytes.NewReader(n), nil
    81  }
    82  
    83  // -- NodePrototype -->
    84  
    85  type Prototype__Bytes struct{}
    86  
    87  func (Prototype__Bytes) NewBuilder() datamodel.NodeBuilder {
    88  	var w plainBytes
    89  	return &plainBytes__Builder{plainBytes__Assembler{w: &w}}
    90  }
    91  
    92  // -- NodeBuilder -->
    93  
    94  type plainBytes__Builder struct {
    95  	plainBytes__Assembler
    96  }
    97  
    98  func (nb *plainBytes__Builder) Build() datamodel.Node {
    99  	return nb.w
   100  }
   101  func (nb *plainBytes__Builder) Reset() {
   102  	var w plainBytes
   103  	*nb = plainBytes__Builder{plainBytes__Assembler{w: &w}}
   104  }
   105  
   106  // -- NodeAssembler -->
   107  
   108  type plainBytes__Assembler struct {
   109  	w datamodel.Node
   110  }
   111  
   112  func (plainBytes__Assembler) BeginMap(sizeHint int64) (datamodel.MapAssembler, error) {
   113  	return mixins.BytesAssembler{TypeName: "bytes"}.BeginMap(0)
   114  }
   115  func (plainBytes__Assembler) BeginList(sizeHint int64) (datamodel.ListAssembler, error) {
   116  	return mixins.BytesAssembler{TypeName: "bytes"}.BeginList(0)
   117  }
   118  func (plainBytes__Assembler) AssignNull() error {
   119  	return mixins.BytesAssembler{TypeName: "bytes"}.AssignNull()
   120  }
   121  func (plainBytes__Assembler) AssignBool(bool) error {
   122  	return mixins.BytesAssembler{TypeName: "bytes"}.AssignBool(false)
   123  }
   124  func (plainBytes__Assembler) AssignInt(int64) error {
   125  	return mixins.BytesAssembler{TypeName: "bytes"}.AssignInt(0)
   126  }
   127  func (plainBytes__Assembler) AssignFloat(float64) error {
   128  	return mixins.BytesAssembler{TypeName: "bytes"}.AssignFloat(0)
   129  }
   130  func (plainBytes__Assembler) AssignString(string) error {
   131  	return mixins.BytesAssembler{TypeName: "bytes"}.AssignString("")
   132  }
   133  func (na *plainBytes__Assembler) AssignBytes(v []byte) error {
   134  	na.w = datamodel.Node(plainBytes(v))
   135  	return nil
   136  }
   137  func (plainBytes__Assembler) AssignLink(datamodel.Link) error {
   138  	return mixins.BytesAssembler{TypeName: "bytes"}.AssignLink(nil)
   139  }
   140  func (na *plainBytes__Assembler) AssignNode(v datamodel.Node) error {
   141  	if lb, ok := v.(datamodel.LargeBytesNode); ok {
   142  		lbn, err := lb.AsLargeBytes()
   143  		if err == nil {
   144  			na.w = streamBytes{lbn}
   145  			return nil
   146  		}
   147  	}
   148  	if v2, err := v.AsBytes(); err != nil {
   149  		return err
   150  	} else {
   151  		na.w = plainBytes(v2)
   152  		return nil
   153  	}
   154  }
   155  func (plainBytes__Assembler) Prototype() datamodel.NodePrototype {
   156  	return Prototype__Bytes{}
   157  }