github.com/ipld/go-ipld-prime@v0.21.0/schema/gen/go/genBytesReprBytes.go (about)

     1  package gengo
     2  
     3  import (
     4  	"io"
     5  
     6  	"github.com/ipld/go-ipld-prime/schema"
     7  	"github.com/ipld/go-ipld-prime/schema/gen/go/mixins"
     8  )
     9  
    10  var _ TypeGenerator = &bytesReprBytesGenerator{}
    11  
    12  func NewBytesReprBytesGenerator(pkgName string, typ *schema.TypeBytes, adjCfg *AdjunctCfg) TypeGenerator {
    13  	return bytesReprBytesGenerator{
    14  		bytesGenerator{
    15  			adjCfg,
    16  			mixins.BytesTraits{
    17  				PkgName:    pkgName,
    18  				TypeName:   string(typ.Name()),
    19  				TypeSymbol: adjCfg.TypeSymbol(typ),
    20  			},
    21  			pkgName,
    22  			typ,
    23  		},
    24  	}
    25  }
    26  
    27  type bytesReprBytesGenerator struct {
    28  	bytesGenerator
    29  }
    30  
    31  func (g bytesReprBytesGenerator) GetRepresentationNodeGen() NodeGenerator {
    32  	return bytesReprBytesReprGenerator{
    33  		g.AdjCfg,
    34  		g.Type,
    35  	}
    36  }
    37  
    38  type bytesReprBytesReprGenerator struct {
    39  	AdjCfg *AdjunctCfg
    40  	Type   *schema.TypeBytes
    41  }
    42  
    43  func (g bytesReprBytesReprGenerator) EmitNodeType(w io.Writer) {
    44  	// Since this is a "natural" representation... there's just a type alias here.
    45  	//  No new functions are necessary.
    46  	doTemplate(`
    47  		type _{{ .Type | TypeSymbol }}__Repr = _{{ .Type | TypeSymbol }}
    48  	`, w, g.AdjCfg, g)
    49  }
    50  func (g bytesReprBytesReprGenerator) EmitNodeTypeAssertions(w io.Writer) {
    51  	doTemplate(`
    52  		var _ datamodel.Node = &_{{ .Type | TypeSymbol }}__Repr{}
    53  	`, w, g.AdjCfg, g)
    54  }
    55  func (bytesReprBytesReprGenerator) EmitNodeMethodKind(io.Writer)            {}
    56  func (bytesReprBytesReprGenerator) EmitNodeMethodLookupByString(io.Writer)  {}
    57  func (bytesReprBytesReprGenerator) EmitNodeMethodLookupByNode(io.Writer)    {}
    58  func (bytesReprBytesReprGenerator) EmitNodeMethodLookupByIndex(io.Writer)   {}
    59  func (bytesReprBytesReprGenerator) EmitNodeMethodLookupBySegment(io.Writer) {}
    60  func (bytesReprBytesReprGenerator) EmitNodeMethodMapIterator(io.Writer)     {}
    61  func (bytesReprBytesReprGenerator) EmitNodeMethodListIterator(io.Writer)    {}
    62  func (bytesReprBytesReprGenerator) EmitNodeMethodLength(io.Writer)          {}
    63  func (bytesReprBytesReprGenerator) EmitNodeMethodIsAbsent(io.Writer)        {}
    64  func (bytesReprBytesReprGenerator) EmitNodeMethodIsNull(io.Writer)          {}
    65  func (bytesReprBytesReprGenerator) EmitNodeMethodAsBool(io.Writer)          {}
    66  func (bytesReprBytesReprGenerator) EmitNodeMethodAsInt(io.Writer)           {}
    67  func (bytesReprBytesReprGenerator) EmitNodeMethodAsFloat(io.Writer)         {}
    68  func (bytesReprBytesReprGenerator) EmitNodeMethodAsString(io.Writer)        {}
    69  func (bytesReprBytesReprGenerator) EmitNodeMethodAsBytes(io.Writer)         {}
    70  func (bytesReprBytesReprGenerator) EmitNodeMethodAsLink(io.Writer)          {}
    71  func (bytesReprBytesReprGenerator) EmitNodeMethodPrototype(io.Writer)       {}
    72  func (g bytesReprBytesReprGenerator) EmitNodePrototypeType(w io.Writer) {
    73  	// Since this is a "natural" representation... there's just a type alias here.
    74  	//  No new functions are necessary.
    75  	doTemplate(`
    76  		type _{{ .Type | TypeSymbol }}__ReprPrototype = _{{ .Type | TypeSymbol }}__Prototype
    77  	`, w, g.AdjCfg, g)
    78  }
    79  func (g bytesReprBytesReprGenerator) GetNodeBuilderGenerator() NodeBuilderGenerator {
    80  	return bytesReprBytesReprBuilderGenerator(g)
    81  }
    82  
    83  type bytesReprBytesReprBuilderGenerator struct {
    84  	AdjCfg *AdjunctCfg
    85  	Type   *schema.TypeBytes
    86  }
    87  
    88  func (bytesReprBytesReprBuilderGenerator) EmitNodeBuilderType(io.Writer)    {}
    89  func (bytesReprBytesReprBuilderGenerator) EmitNodeBuilderMethods(io.Writer) {}
    90  func (g bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerType(w io.Writer) {
    91  	// Since this is a "natural" representation... there's just a type alias here.
    92  	//  No new functions are necessary.
    93  	doTemplate(`
    94  		type _{{ .Type | TypeSymbol }}__ReprAssembler = _{{ .Type | TypeSymbol }}__Assembler
    95  	`, w, g.AdjCfg, g)
    96  }
    97  func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodBeginMap(io.Writer)     {}
    98  func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodBeginList(io.Writer)    {}
    99  func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodAssignNull(io.Writer)   {}
   100  func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodAssignBool(io.Writer)   {}
   101  func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodAssignInt(io.Writer)    {}
   102  func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodAssignFloat(io.Writer)  {}
   103  func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodAssignString(io.Writer) {}
   104  func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodAssignBytes(io.Writer)  {}
   105  func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodAssignLink(io.Writer)   {}
   106  func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodAssignNode(io.Writer)   {}
   107  func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodPrototype(io.Writer)    {}
   108  func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerOtherBits(io.Writer)          {}