models

Documentation

Overview

Package models defines the domain models that model field relations and manipulation.

Index

• Constants
• type Field
  • func (f *Field) AllFields(fields []*Field, cyclic map[*Field]bool) []*Field
  • func (f *Field) Deepcopy(cyclic map[*Field]bool) *Field
  • func (f *Field) FullDefinition() string
  • func (f *Field) FullDefinitionWithoutPointer() string
  • func (f *Field) FullName() string
  • func (f *Field) FullNameWithoutPointer(name string) string
  • func (f *Field) FullVariableName(name string) string
  • func (f *Field) IsAlias() bool
  • func (f *Field) IsArray() bool
  • func (f *Field) IsBasic() bool
  • func (f *Field) IsChan() bool
  • func (f *Field) IsCollection() bool
  • func (f *Field) IsComposite() bool
  • func (f *Field) IsFunc() bool
  • func (f *Field) IsInterface() bool
  • func (f *Field) IsMap() bool
  • func (f *Field) IsPointer() bool
  • func (f *Field) IsSlice() bool
  • func (f *Field) IsType() bool
  • func (f *Field) String() string
• type FieldOptions
• type Function
• type FunctionOptions
• type Generator
• type GeneratorOptions
• type Type
  • func (t Type) Name() string
  • func (t Type) String() string

Constants

const (
	CollectionPointer   = "*"
	CollectionSlice     = "[]"
	CollectionMap       = "map"
	CollectionChan      = "chan"
	CollectionFunc      = "func"
	CollectionInterface = "interface"
)

Collection refers to a category of types which indicate that a field's definition collects multiple fields (i.e `map[string]bool`).

const Pointer = '*'

Pointer represents the char representation of a pointer.

Types

type Field

type Field struct {
	// VariableName represents name that is used to assign the field.
	//
	// This value will always be unique in the context of the application.
	// TypeField variable names do not contain '.' (i.e 'tA' in 'tA.UserID').
	// Field variable names are defined by their specifier (i.e '.UserID' in 'domain.Account.UserID').
	VariableName string

	// Import represents the file that field was imported from.
	Import string

	// Package represents the package the field is defined in (i.e `log` in `log.Logger`).
	Package string

	// Name represents the name of the field (i.e `ID` in `ID int`).
	Name string

	// Definition represents the type definition of the field (i.e `int` in `ID int`, `Logger` in `log.Logger`).
	Definition string

	// The tags defined in a struct field (i.e `json:"tag,omitempty"`)
	// map[tag]map[name][]options (i.e map[json]map[tag]["omitempty"])
	Tags map[string]map[string][]string

	// The type or field that contains this field.
	Parent *Field

	// Underlying represents the underlying type field of this field (or nil).
	// The underlying field of a `type Number string` *Field is a `string` *Field.
	//
	// Underlying fields of the same type point to the same *Field object.
	Underlying *Field

	// The field that this field will be copied from (or nil).
	//
	// Set in the matcher.
	From *Field

	// The field that this field will be copied to (or nil).
	//
	// Set in the matcher.
	To *Field

	// The fields of this field.
	Fields []*Field

	// The custom options of a field.
	Options FieldOptions

	// Embedded represents whether the field is an embedded field.
	Embedded bool
}

Field represents a field to be copied to/from. A field's struct properties are set in the parser unless its stated otherwise.

func (*Field) AllFields

func (f *Field) AllFields(fields []*Field, cyclic map[*Field]bool) []*Field

AllFields gets all the fields in the scope of a field (including itself).

func (*Field) Deepcopy

func (f *Field) Deepcopy(cyclic map[*Field]bool) *Field

Deepcopy returns a new field with copied properties (excluding Parent, To, and From fields).

func (*Field) FullDefinition

func (f *Field) FullDefinition() string

FullDefinition returns the full definition of a field including its package.

func (*Field) FullDefinitionWithoutPointer

func (f *Field) FullDefinitionWithoutPointer() string

FullDefinition returns the full definition of a field including its package without its pointer(s) (i.e domain.Account).

func (*Field) FullName

func (f *Field) FullName() string

FullName returns the full name of a field including its parents (i.e *domain.Account.User.ID).

func (*Field) FullNameWithoutPointer

func (f *Field) FullNameWithoutPointer(name string) string

FullNameWithoutPointer returns the full name of a field including its parents without the pointer (i.e domain.Account.User.ID).

func (*Field) FullVariableName

func (f *Field) FullVariableName(name string) string

FullVariableName returns the full variable name of a field (i.e tA.User.UserID).

func (*Field) IsAlias

func (f *Field) IsAlias() bool

IsAlias determines whether the field is a type alias.

func (*Field) IsArray

func (f *Field) IsArray() bool

IsArray returns whether the field is an array.

func (*Field) IsBasic

func (f *Field) IsBasic() bool

IsBasic determines whether the field is a basic type.

func (*Field) IsChan

func (f *Field) IsChan() bool

IsMap returns whether the field is a chan.

func (*Field) IsCollection

func (f *Field) IsCollection() bool

IsCollection returns whether the field is a collection.

func (*Field) IsComposite

func (f *Field) IsComposite() bool

IsComposite returns whether the field is a composite type: array, slice, map, chan.

func (*Field) IsFunc

func (f *Field) IsFunc() bool

IsFunc returns whether the field is a function.

func (*Field) IsInterface

func (f *Field) IsInterface() bool

IsInterface returns whether the field is an interface.

func (*Field) IsMap

func (f *Field) IsMap() bool

IsMap returns whether the field is a map.

func (*Field) IsPointer

func (f *Field) IsPointer() bool

IsPointer returns whether the field is a pointer.

func (*Field) IsSlice

func (f *Field) IsSlice() bool

IsSlice returns whether the field is a slice.

func (*Field) IsType

func (f *Field) IsType() bool

IsType returns whether the field is a type.

func (*Field) String

func (f *Field) String() string

type FieldOptions

type FieldOptions struct {
	// The function the field is converted with (as a parameter).
	Convert string

	// The field to map this field to, if any.
	Map string

	// The tag to map this field with, if any.
	Tag string

	// The level at which sub-fields are discovered.
	Depth int

	// Whether the field should be explicitly automatched.
	Automatch bool

	// Whether the field should be deepcopied.
	Deepcopy bool
}

FieldOptions represent options for a Field.

type Function

type Function struct {
	Name    string          // The name of the function.
	Options FunctionOptions // The custom options of a function.
	From    []Type          // The types to copy fields from.
	To      []Type          // The types to copy fields to.
}

Function represents the properties of a generated function.

type FunctionOptions

type FunctionOptions struct {
	Custom map[string][]string // The custom options of a function (map[option]values).
	Manual bool                // Whether the function uses a manual matcher (as opposed to an Automatcher).
}

FunctionOptions represent options for a Function.

type Generator

type Generator struct {
	Functions []Function       // The functions to generate.
	Options   GeneratorOptions // The custom options for the generator.
	Setpath   string           // The filepath the setup file is located in.
	Outpath   string           // The filepath the generated code is output to.
	Tempath   string           // The filepath for the template used to generate code.
	Keep      []byte           // The code that is kept from the setup file.
}

Generator represents a code generator.

type GeneratorOptions

type GeneratorOptions struct {
	Custom map[string]interface{} // The custom options of a generator.
}

GeneratorOptions represent options for a Generator.

type Type

type Type struct {
	// Field represents field information for the type.
	Field *Field
}

Type represents a field that isn't contained.

func (Type) Name

func (t Type) Name() string

Name gets the name of the type field.

func (Type) String

func (t Type) String() string