kubernetes/vendor/k8s.io/gengo/v2/generator/snippet_writer.go

type SnippetWriter

// w is the destination; left and right are the delimiters; @ and $ are both
// reasonable choices.
//
// c is used to make a function for every naming system, to which you can pass
// a type and get the corresponding name.
func NewSnippetWriter(w io.Writer, c *Context, left, right string) *SnippetWriter {}

// Do parses format and runs args through it. You can have arbitrary logic in
// the format (see the text/template documentation), but consider running many
// short templates with ordinary go logic in between--this may be more
// readable. Do is chainable. Any error causes every other call to do to be
// ignored, and the error will be returned by Error(). So you can check it just
// once, at the end of your function.
//
// 'args' can be quite literally anything; read the text/template documentation
// for details. Maps and structs work particularly nicely. Conveniently, the
// types package is designed to have structs that are easily referencable from
// the template language.
//
// Example:
//
// sw := generator.NewSnippetWriter(outBuffer, context, "$", "$")
// sw.Do(`The public type name is: $.type|public$`, map[string]interface{}{"type": t})
// return sw.Error()
//
// Where:
//   - "$" starts a template directive
//   - "." references the entire thing passed as args
//   - "type" therefore sees a map and looks up the key "type"
//   - "|" means "pass the thing on the left to the thing on the right"
//   - "public" is the name of a naming system, so the SnippetWriter has given
//     the template a function called "public" that takes a *types.Type and
//     returns the naming system's name. E.g., if the type is "string" this might
//     return "String".
//   - the second "$" ends the template directive.
//
// The map is actually not necessary. The below does the same thing:
//
// sw.Do(`The public type name is: $.|public$`, t)
//
// You may or may not find it more readable to use the map with a descriptive
// key, but if you want to pass more than one arg, the map or a custom struct
// becomes a requirement. You can do arbitrary logic inside these templates,
// but you should consider doing the logic in go and stitching them together
// for the sake of your readers.
//
// TODO: Change Do() to optionally take a list of pairs of parameters (key, value)
// and have it construct a combined map with that and args.
func (s *SnippetWriter) Do(format string, args interface{}

type Args

// With makes a copy of a and adds the given key, value pair. If key overlaps,
// the new value wins.
func (a Args) With(key, value interface{}

// WithArgs makes a copy of a and adds the given arguments. If any keys
// overlap, the values from rhs win.
func (a Args) WithArgs(rhs Args) Args {}

func (s *SnippetWriter) Out() io.Writer {}

// Error returns any encountered error.
func (s *SnippetWriter) Error() error {}

// Dup creates an exact duplicate SnippetWriter with a different io.Writer.
func (s *SnippetWriter) Dup(w io.Writer) *SnippetWriter {}

// Append adds the contents of the io.Reader to this SnippetWriter's buffer.
func (s *SnippetWriter) Append(r io.Reader) error {}