builder

type App struct {
	Module
}

type Class struct {
	// A per parent unique name, something like "MyClass". May not contain dots (.)
	Name string `json:"name"`

	// Something like "This class represents the entity ..."
	Doc string `json:"doc"`

	// The visibility of a class. True is for all, otherwise module wise only. Does not make it available to sub module.
	Exported bool `json:"exported"`

	// A class contains a bunch of fields.
	Fields []*Field `json:"fields"`

	// A class contains a bunch of methods
	Methods []*Method `json:"methods"`

	// A class should define stereotypes, so that it's role is always explicit and unambiguous.
	Stereotypes []Stereotype `json:"stereotypes"`

	Parent ModuleLike
}

type Field struct {
	Variable
	Exported bool `json:"exported"`
	Parent   *Class
}

type Generator interface {
	//invokes the generator with the app and returns a potential error
	Generate(ctx *GeneratorContext) error
}

type GeneratorContext struct {
	TargetDir string
	Model     *App
	GoFiles   []*GoFile
}

type GoFile struct {
	*jen.File
	// contains filtered or unexported fields
}

type Method struct {
	// Part of the signature. The name of the method.
	Name string `json:"name"`

	// Part of the signature. A method may have multiple parameters, which are just variables.
	Parameters []*Parameter `json:"parameters"`

	// Part of the signature. A method may return multiple result types. The actual capabilities depend on the concrete source implementation.
	// There languages which support such declarations like go and swift, but others do not even support tuples, like java.
	// In those cases the generator inserts local variables and a generated tuple holder which has to be returned.
	Returns []*Parameter `json:"returns"`

	// The concrete implementation, potentially in different languages.
	Implementations []*SourceCode `json:"implementations"`
	Parent          *Class
}

type Module struct {
	//A per parent unique name, something like "mymodule".  May not contain dots (.)
	Name string `json:"name"`
	// Something like "This module contains the logic for handling..."
	Doc string `json:"doc"`

	// A module can contain other (public) child modules.
	Modules []*Module `json:"modules"`

	// A module can contain public and private classes.
	Classes []*Class `json:"classes"`

	Parent *Module `json:"-"`
}

type ModuleLike interface {
	GetDoc() string
	GetName() string
	GetModules() []ModuleLike
	GetClasses() []*Class
	GetParent() ModuleLike
	SetParent(like ModuleLike)
}

type Parameter struct {
	Variable
	Parent *Method
}

type SourceCode struct {
	// A constant from {@link PLATFORM}
	Platform string `json:"platform"`

	// The actual source code snipped. Lines are separated by \n
	Code string `json:"code"`

	Parent *Method
}

type Stereotype string

type Type struct {
	//The id of the type which is the FullQualifiedName, like "my.module.MyType" or a base type like "void", "string", "float64" etc.
	FullQualifiedName string `json:"id"`

	//A type may have other generics, like a list or a map.
	Generics []*Type `json:"Generics"`
}

type Variable struct {
	// The unique name of the variable
	Name string `json:"name"`
	// The type of this variable. Not all types make sense, like the void type, and others may be illegal without generics (like list and maps).
	Type Type `json:"type"`

	// The documentation for this field, like "A 'fieldname' is used to represent ..."
	Doc string `json:"doc"`
}