github.com/ipld/go-ipld-prime@v0.21.0/schema/gen/go/genBoolReprBool.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 = &boolReprBoolGenerator{}
    11  
    12  func NewBoolReprBoolGenerator(pkgName string, typ *schema.TypeBool, adjCfg *AdjunctCfg) TypeGenerator {
    13  	return boolReprBoolGenerator{
    14  		boolGenerator{
    15  			adjCfg,
    16  			mixins.BoolTraits{
    17  				PkgName:    pkgName,
    18  				TypeName:   string(typ.Name()),
    19  				TypeSymbol: adjCfg.TypeSymbol(typ),
    20  			},
    21  			pkgName,
    22  			typ,
    23  		},
    24  	}
    25  }
    26  
    27  type boolReprBoolGenerator struct {
    28  	boolGenerator
    29  }
    30  
    31  func (g boolReprBoolGenerator) GetRepresentationNodeGen() NodeGenerator {
    32  	return boolReprBoolReprGenerator{
    33  		g.AdjCfg,
    34  		g.Type,
    35  	}
    36  }
    37  
    38  type boolReprBoolReprGenerator struct {
    39  	AdjCfg *AdjunctCfg
    40  	Type   *schema.TypeBool
    41  }
    42  
    43  func (g boolReprBoolReprGenerator) 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 boolReprBoolReprGenerator) EmitNodeTypeAssertions(w io.Writer) {
    51  	doTemplate(`
    52  		var _ datamodel.Node = &_{{ .Type | TypeSymbol }}__Repr{}
    53  	`, w, g.AdjCfg, g)
    54  }
    55  func (boolReprBoolReprGenerator) EmitNodeMethodKind(io.Writer)            {}
    56  func (boolReprBoolReprGenerator) EmitNodeMethodLookupByString(io.Writer)  {}
    57  func (boolReprBoolReprGenerator) EmitNodeMethodLookupByNode(io.Writer)    {}
    58  func (boolReprBoolReprGenerator) EmitNodeMethodLookupByIndex(io.Writer)   {}
    59  func (boolReprBoolReprGenerator) EmitNodeMethodLookupBySegment(io.Writer) {}
    60  func (boolReprBoolReprGenerator) EmitNodeMethodMapIterator(io.Writer)     {}
    61  func (boolReprBoolReprGenerator) EmitNodeMethodListIterator(io.Writer)    {}
    62  func (boolReprBoolReprGenerator) EmitNodeMethodLength(io.Writer)          {}
    63  func (boolReprBoolReprGenerator) EmitNodeMethodIsAbsent(io.Writer)        {}
    64  func (boolReprBoolReprGenerator) EmitNodeMethodIsNull(io.Writer)          {}
    65  func (boolReprBoolReprGenerator) EmitNodeMethodAsBool(io.Writer)          {}
    66  func (boolReprBoolReprGenerator) EmitNodeMethodAsInt(io.Writer)           {}
    67  func (boolReprBoolReprGenerator) EmitNodeMethodAsFloat(io.Writer)         {}
    68  func (boolReprBoolReprGenerator) EmitNodeMethodAsString(io.Writer)        {}
    69  func (boolReprBoolReprGenerator) EmitNodeMethodAsBytes(io.Writer)         {}
    70  func (boolReprBoolReprGenerator) EmitNodeMethodAsLink(io.Writer)          {}
    71  func (boolReprBoolReprGenerator) EmitNodeMethodPrototype(io.Writer)       {}
    72  func (g boolReprBoolReprGenerator) 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 boolReprBoolReprGenerator) GetNodeBuilderGenerator() NodeBuilderGenerator {
    80  	return boolReprBoolReprBuilderGenerator(g)
    81  }
    82  
    83  type boolReprBoolReprBuilderGenerator struct {
    84  	AdjCfg *AdjunctCfg
    85  	Type   *schema.TypeBool
    86  }
    87  
    88  func (boolReprBoolReprBuilderGenerator) EmitNodeBuilderType(io.Writer)    {}
    89  func (boolReprBoolReprBuilderGenerator) EmitNodeBuilderMethods(io.Writer) {}
    90  func (g boolReprBoolReprBuilderGenerator) 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 (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodBeginMap(io.Writer)     {}
    98  func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodBeginList(io.Writer)    {}
    99  func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodAssignNull(io.Writer)   {}
   100  func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodAssignBool(io.Writer)   {}
   101  func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodAssignInt(io.Writer)    {}
   102  func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodAssignFloat(io.Writer)  {}
   103  func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodAssignString(io.Writer) {}
   104  func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodAssignBytes(io.Writer)  {}
   105  func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodAssignLink(io.Writer)   {}
   106  func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodAssignNode(io.Writer)   {}
   107  func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodPrototype(io.Writer)    {}
   108  func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerOtherBits(io.Writer)          {}