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

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