vendor/github.com/tendermint/go-wire/gen/gen.go

   1 package gen
   2
   3 import (
   4         "fmt"
   5         "io"
   6         "strings"
   7
   8         "github.com/clipperhouse/typewriter"
   9 )
  10
  11 func init() {
  12         err := typewriter.Register(NewWrapperWriter())
  13         if err != nil {
  14                 panic(err)
  15         }
  16 }
  17
  18 type WrapperWriter struct{}
  19
  20 func NewWrapperWriter() *WrapperWriter {
  21         return &WrapperWriter{}
  22 }
  23
  24 func (sw *WrapperWriter) Name() string {
  25         return "wrapper"
  26 }
  27
  28 func (sw *WrapperWriter) Imports(t typewriter.Type) []typewriter.ImportSpec {
  29         return []typewriter.ImportSpec{{Path: "github.com/tendermint/go-wire/data"}}
  30 }
  31
  32 func (sw *WrapperWriter) Write(w io.Writer, t typewriter.Type) error {
  33         tag, found := t.FindTag(sw)
  34
  35         if !found {
  36                 // nothing to be done
  37                 return nil
  38         }
  39
  40         license := `// Auto-generated adapters for happily unmarshaling interfaces
  41 // Apache License 2.0
  42 // Copyright (c) 2017 Ethan Frey (ethan.frey@tendermint.com)
  43 `
  44
  45         if _, err := w.Write([]byte(license)); err != nil {
  46                 fmt.Println("write error")
  47                 return err
  48         }
  49
  50         // prepare parameters
  51         name := t.Name + "Wrapper"
  52         if len(tag.Values) > 0 {
  53                 name = tag.Values[0].Name
  54         }
  55         m := model{Type: t, Wrapper: name, Inner: t.Name}
  56
  57         // now, first main Wrapper
  58         v := typewriter.TagValue{Name: "Wrapper"}
  59         htmpl, err := templates.ByTagValue(t, v)
  60         if err != nil {
  61                 return err
  62         }
  63         if err := htmpl.Execute(w, m); err != nil {
  64                 return err
  65         }
  66
  67         // Now, add any implementations...
  68         v.Name = "Register"
  69         rtmpl, err := templates.ByTagValue(t, v)
  70         if err != nil {
  71                 return err
  72         }
  73
  74         for ti, t := range tag.Values {
  75                 if t.Name == "Impl" {
  76                         for i, p := range t.TypeParameters {
  77                                 m.Impl = p
  78                                 m.Count = i + 1
  79                                 ni := ti + i + 1
  80                                 if len(tag.Values) > ni {
  81                                         m.ImplType = tag.Values[ni].Name
  82                                 } else {
  83                                         m.ImplType = strings.ToLower(p.Name)
  84                                 }
  85                                 if err := rtmpl.Execute(w, m); err != nil {
  86                                         return err
  87                                 }
  88                         }
  89                 }
  90         }
  91
  92         return nil
  93 }
  94
  95 type model struct {
  96         Type     typewriter.Type
  97         Wrapper  string
  98         Inner    string
  99         Impl     typewriter.Type // fill in when adding for implementations
 100         ImplType string
 101         Count    int
 102 }