models

type AllModelsStructCreateInterface interface {
	CreateORMClassdiagram(Classdiagram *Classdiagram)
	CreateORMDiagramPackage(DiagramPackage *DiagramPackage)
	CreateORMField(Field *Field)
	CreateORMGongEnumShape(GongEnumShape *GongEnumShape)
	CreateORMGongEnumValueEntry(GongEnumValueEntry *GongEnumValueEntry)
	CreateORMGongStructShape(GongStructShape *GongStructShape)
	CreateORMLink(Link *Link)
	CreateORMNoteShape(NoteShape *NoteShape)
	CreateORMNoteShapeLink(NoteShapeLink *NoteShapeLink)
	CreateORMPosition(Position *Position)
	CreateORMUmlState(UmlState *UmlState)
	CreateORMUmlsc(Umlsc *Umlsc)
	CreateORMVertice(Vertice *Vertice)
}

type AllModelsStructDeleteInterface interface {
	DeleteORMClassdiagram(Classdiagram *Classdiagram)
	DeleteORMDiagramPackage(DiagramPackage *DiagramPackage)
	DeleteORMField(Field *Field)
	DeleteORMGongEnumShape(GongEnumShape *GongEnumShape)
	DeleteORMGongEnumValueEntry(GongEnumValueEntry *GongEnumValueEntry)
	DeleteORMGongStructShape(GongStructShape *GongStructShape)
	DeleteORMLink(Link *Link)
	DeleteORMNoteShape(NoteShape *NoteShape)
	DeleteORMNoteShapeLink(NoteShapeLink *NoteShapeLink)
	DeleteORMPosition(Position *Position)
	DeleteORMUmlState(UmlState *UmlState)
	DeleteORMUmlsc(Umlsc *Umlsc)
	DeleteORMVertice(Vertice *Vertice)
}

type BackRepoInterface interface {
	Commit(stage *StageStruct)
	Checkout(stage *StageStruct)
	Backup(stage *StageStruct, dirPath string)
	Restore(stage *StageStruct, dirPath string)
	BackupXL(stage *StageStruct, dirPath string)
	RestoreXL(stage *StageStruct, dirPath string)
	// insertion point for Commit and Checkout signatures
	CommitClassdiagram(classdiagram *Classdiagram)
	CheckoutClassdiagram(classdiagram *Classdiagram)
	CommitDiagramPackage(diagrampackage *DiagramPackage)
	CheckoutDiagramPackage(diagrampackage *DiagramPackage)
	CommitField(field *Field)
	CheckoutField(field *Field)
	CommitGongEnumShape(gongenumshape *GongEnumShape)
	CheckoutGongEnumShape(gongenumshape *GongEnumShape)
	CommitGongEnumValueEntry(gongenumvalueentry *GongEnumValueEntry)
	CheckoutGongEnumValueEntry(gongenumvalueentry *GongEnumValueEntry)
	CommitGongStructShape(gongstructshape *GongStructShape)
	CheckoutGongStructShape(gongstructshape *GongStructShape)
	CommitLink(link *Link)
	CheckoutLink(link *Link)
	CommitNoteShape(noteshape *NoteShape)
	CheckoutNoteShape(noteshape *NoteShape)
	CommitNoteShapeLink(noteshapelink *NoteShapeLink)
	CheckoutNoteShapeLink(noteshapelink *NoteShapeLink)
	CommitPosition(position *Position)
	CheckoutPosition(position *Position)
	CommitUmlState(umlstate *UmlState)
	CheckoutUmlState(umlstate *UmlState)
	CommitUmlsc(umlsc *Umlsc)
	CheckoutUmlsc(umlsc *Umlsc)
	CommitVertice(vertice *Vertice)
	CheckoutVertice(vertice *Vertice)
	GetLastCommitFromBackNb() uint
	GetLastPushFromFrontNb() uint
}

type Classdiagram struct {
	Name string

	// list of gongstructshapes in the diagram
	GongStructShapes []*GongStructShape

	GongEnumShapes []*GongEnumShape

	// list of notes in the diagram
	NoteShapes []*NoteShape

	// IsInDrawMode indicates the the drawing can be edited (in development mode)
	// or not (in production mode)
	IsInDrawMode bool
}

type Classdiagram_WOP struct {
	// insertion point
	Name         string
	IsInDrawMode bool
}

type DiagramPackage struct {
	Name string

	// Stage_ where the DiagamPackage lives
	Stage_ *StageStruct

	// Path to the "diagrams" directory
	Path string

	// GongModelPath is the package path, e.g. "fullstack-lang/gongxlsx/go/models"
	GongModelPath string

	// Classdiagrams store UML Classdiagrams
	Classdiagrams []*Classdiagram

	// SelectedClassdiagram is the diagram of interest
	SelectedClassdiagram *Classdiagram

	// list of files in the "diagrams" directory
	Files []string
	Ast   *ast.Package
	Fset  *token.FileSet

	// Umlscs stores UML State charts diagrams
	Umlscs []*Umlsc

	// IsEditable indicates wether the end user can edit the diagram
	// When a diagram is used in production for navigation, the
	// model is not IsEditable.
	IsEditable bool

	// IsReload indicates if a reload of the go definition of the diagram is rrequested
	// from the end user.
	// on the back stage, this value is allways false
	// on the front stage, this value is set to true when the end user requests a reload
	// after the checkout from the front, the value is set back to false
	IsReloaded bool

	// pointer to the model package
	ModelPkg                     *gong_models.ModelPkg
	AbsolutePathToDiagramPackage string

	// swagger:ignore
	Map_Identifier_NbInstances map[string]int
}

type DiagramPackage_WOP struct {
	// insertion point
	Name                         string
	Path                         string
	GongModelPath                string
	IsEditable                   bool
	IsReloaded                   bool
	AbsolutePathToDiagramPackage string
}

type ExcelizeTabulator struct {
	// contains filtered or unexported fields
}

type Field struct {
	Name string

	// Identifier is the identifier of the struct field referenced
	// by the UML classshape in the modeled package
	//gong:ident
	Identifier string

	FieldTypeAsString string
	Structname        string
	Fieldtypename     string
}

type Field_WOP struct {
	// insertion point
	Name              string
	Identifier        string
	FieldTypeAsString string
	Structname        string
	Fieldtypename     string
}

type GONG__ExpressionType string

type GONG__Identifier struct {
	Ident string
	Type  GONG__ExpressionType
}

type GongEnumShape struct {
	Name string

	Position *Position

	// Identifier is the identifier of the struct referenced by the shape in the modeled package
	//gong:ident
	Identifier string

	GongEnumValueEntrys []*GongEnumValueEntry

	// with and height of the shape when they are rendered on SVG or with jointjs
	// They are optional fields. they can be computed when empty
	Width, Height float64
}

type GongEnumShapeType int

type GongEnumShape_WOP struct {
	// insertion point
	Name       string
	Identifier string
	Width      float64
	Height     float64
}

type GongEnumValueEntry struct {
	// Name of the enum value
	Name string

	// Identifier is the identifier of the enum value referenced by the shape in the modeled package
	//gong:ident
	Identifier string
}

type GongEnumValueEntry_WOP struct {
	// insertion point
	Name       string
	Identifier string
}

type GongStructInterface interface {
	GetName() (res string)
}

type GongStructShape struct {
	Name string

	Position *Position

	// Identifier is the identifier of the struct referenced by the shape in the modeled package
	//gong:ident
	Identifier string

	// gongdoc can be integrated in a runtime application
	// the application can then set up the number of instances of Struct
	ShowNbInstances bool
	NbInstances     int

	// models of the composition of Field
	Fields []*Field

	// models of the composition of Link
	Links []*Link

	// with and height of the shape when they are rendered on SVG or with jointjs
	// They are optional fields. they can be computed when empty
	Width, Height float64

	// this is always false in the backend, but it can be set to true by the front end
	// this means it is selected by the user
	IsSelected bool
}

type GongStructShape_WOP struct {
	// insertion point
	Name            string
	Identifier      string
	ShowNbInstances bool
	NbInstances     int
	Width           float64
	Height          float64
	IsSelected      bool
}

type Gongstruct interface {
	// insertion point for generic types
	Classdiagram | DiagramPackage | Field | GongEnumShape | GongEnumValueEntry | GongStructShape | Link | NoteShape | NoteShapeLink | Position | UmlState | Umlsc | Vertice
}

type GongstructEnumIntField interface {
	int | GongEnumShapeType
	Codes() []string
	CodeValues() []int
}

type GongstructEnumStringField interface {
	string | MultiplicityType | NoteShapeLinkType | OrientationType
	Codes() []string
	CodeValues() []string
}

type GongstructMapString interface {
	map[any]any |

		map[string]*Classdiagram |
		map[string]*DiagramPackage |
		map[string]*Field |
		map[string]*GongEnumShape |
		map[string]*GongEnumValueEntry |
		map[string]*GongStructShape |
		map[string]*Link |
		map[string]*NoteShape |
		map[string]*NoteShapeLink |
		map[string]*Position |
		map[string]*UmlState |
		map[string]*Umlsc |
		map[string]*Vertice |
		map[*any]any // because go does not support an extra "|" at the end of type specifications
}

type GongstructSet interface {
	map[any]any |

		map[*Classdiagram]any |
		map[*DiagramPackage]any |
		map[*Field]any |
		map[*GongEnumShape]any |
		map[*GongEnumValueEntry]any |
		map[*GongStructShape]any |
		map[*Link]any |
		map[*NoteShape]any |
		map[*NoteShapeLink]any |
		map[*Position]any |
		map[*UmlState]any |
		map[*Umlsc]any |
		map[*Vertice]any |
		map[*any]any // because go does not support an extra "|" at the end of type specifications
}

type GongtructBasicField interface {
	int | float64 | bool | string | time.Time | time.Duration
}

type Link struct {
	Name string

	// Identifier is the identifier of the struct field referenced by the
	// UML field of the classshape in the modeled package
	//gong:ident
	Identifier string

	//gong:ident
	Fieldtypename string

	// position of the field text relative to the
	// arrow end
	FieldOffsetX float64
	FieldOffsetY float64

	TargetMultiplicity MultiplicityType

	// position of the TargetMultiplicity text relative to the
	// arrow end
	TargetMultiplicityOffsetX float64
	TargetMultiplicityOffsetY float64

	SourceMultiplicity MultiplicityType

	// position of the SourceMultiplicity text relative to the
	// arrow end
	SourceMultiplicityOffsetX float64
	SourceMultiplicityOffsetY float64

	// For link with control points
	// Vertices at the middle
	Middlevertice *Vertice

	// for links with floating anchors
	// if link type is floating orthogonal ratio, from 0 to 1,
	// where the anchor starts on the edge (horizontal / vertical)
	StartOrientation OrientationType
	StartRatio       float64
	EndOrientation   OrientationType
	EndRatio         float64

	// in case StartOrientation is the same as EndOrientation,
	// there is a perpendicular line that reach the corner at
	// CornerOffsetRatio
	CornerOffsetRatio float64
}

type Link_WOP struct {
	// insertion point
	Name                      string
	Identifier                string
	Fieldtypename             string
	FieldOffsetX              float64
	FieldOffsetY              float64
	TargetMultiplicity        MultiplicityType
	TargetMultiplicityOffsetX float64
	TargetMultiplicityOffsetY float64
	SourceMultiplicity        MultiplicityType
	SourceMultiplicityOffsetX float64
	SourceMultiplicityOffsetY float64
	StartOrientation          OrientationType
	StartRatio                float64
	EndOrientation            OrientationType
	EndRatio                  float64
	CornerOffsetRatio         float64
}

type MultiplicityType string

type NoteShape struct {
	Name string

	// Identifier of the note object in the model package
	// a note is a special coment syntax https://pkg.go.dev/go/doc#Note
	// see vendor/github.com/fullstack-lang/gong/go/models/gong_note.go
	// since a note name is not an identifier, it cannot be renamed by gopls
	// unless it is understood to be the name of the identifier immediatly
	// following the comment
	//
	// Gongdoc makes this option a wrtting condition for note:
	// a comment text in gong containing a
	// 'gongnote' have to be followed by a constant identifier.
	//
	//    // GONGNOTE(ShortNodeOnModels): this is an example of a short note
	//    // It uses the DocLink convention for referencing Identifiers
	//    // In this case [Line], [Point] and [Line.Start]
	//    const ShortNodeOnModels = ""
	//
	// the following directive directs gong to manage this field as an identifier field
	//
	//gong:ident
	Identifier string

	Body string

	BodyHTML string

	X, Y          float64
	Width, Height float64
	Matched       bool // if a note with the same name has been found

	NoteShapeLinks []*NoteShapeLink
}

type NoteShapeLink struct {
	Name string

	// Identifier of the target shape / link of the note link
	//gong:ident
	Identifier string

	// Type of the target shape / link of the note link
	Type NoteShapeLinkType
}

type NoteShapeLinkType string

type NoteShapeLink_WOP struct {
	// insertion point
	Name       string
	Identifier string
	Type       NoteShapeLinkType
}

type NoteShape_WOP struct {
	// insertion point
	Name       string
	Identifier string
	Body       string
	BodyHTML   string
	X          float64
	Y          float64
	Width      float64
	Height     float64
	Matched    bool
}

type OnAfterCreateInterface[Type Gongstruct] interface {
	OnAfterCreate(stage *StageStruct,
		instance *Type)
}

type OnAfterDeleteInterface[Type Gongstruct] interface {
	OnAfterDelete(stage *StageStruct,
		staged, front *Type)
}

type OnAfterReadInterface[Type Gongstruct] interface {
	OnAfterRead(stage *StageStruct,
		instance *Type)
}

type OnAfterUpdateInterface[Type Gongstruct] interface {
	OnAfterUpdate(stage *StageStruct, old, new *Type)
}

type OnInitCommitInterface interface {
	BeforeCommit(stage *StageStruct)
}

type OrientationType string

type PointerToGongstruct interface {
	*Classdiagram | *DiagramPackage | *Field | *GongEnumShape | *GongEnumValueEntry | *GongStructShape | *Link | *NoteShape | *NoteShapeLink | *Position | *UmlState | *Umlsc | *Vertice
	GetName() string
	CommitVoid(*StageStruct)
	UnstageVoid(stage *StageStruct)
}

type PointerToGongstructEnumIntField interface {
	*GongEnumShapeType
	FromCodeString(input string) (err error)
}

type PointerToGongstructEnumStringField interface {
	*MultiplicityType | *NoteShapeLinkType | *OrientationType
	FromCodeString(input string) (err error)
}

type Position struct {
	X    float64
	Y    float64
	Name string // temporary
}

type Position_WOP struct {
	// insertion point
	X    float64
	Y    float64
	Name string
}

type ReverseField struct {
	GongstructName string
	Fieldname      string
}

type StageStruct struct {

	// insertion point for definition of arrays registering instances
	Classdiagrams           map[*Classdiagram]any
	Classdiagrams_mapString map[string]*Classdiagram

	// insertion point for slice of pointers maps
	Classdiagram_GongStructShapes_reverseMap map[*GongStructShape]*Classdiagram
	Classdiagram_GongEnumShapes_reverseMap   map[*GongEnumShape]*Classdiagram
	Classdiagram_NoteShapes_reverseMap       map[*NoteShape]*Classdiagram

	OnAfterClassdiagramCreateCallback OnAfterCreateInterface[Classdiagram]
	OnAfterClassdiagramUpdateCallback OnAfterUpdateInterface[Classdiagram]
	OnAfterClassdiagramDeleteCallback OnAfterDeleteInterface[Classdiagram]
	OnAfterClassdiagramReadCallback   OnAfterReadInterface[Classdiagram]

	DiagramPackages           map[*DiagramPackage]any
	DiagramPackages_mapString map[string]*DiagramPackage

	// insertion point for slice of pointers maps
	DiagramPackage_Classdiagrams_reverseMap map[*Classdiagram]*DiagramPackage
	DiagramPackage_Umlscs_reverseMap        map[*Umlsc]*DiagramPackage

	OnAfterDiagramPackageCreateCallback OnAfterCreateInterface[DiagramPackage]
	OnAfterDiagramPackageUpdateCallback OnAfterUpdateInterface[DiagramPackage]
	OnAfterDiagramPackageDeleteCallback OnAfterDeleteInterface[DiagramPackage]
	OnAfterDiagramPackageReadCallback   OnAfterReadInterface[DiagramPackage]

	Fields           map[*Field]any
	Fields_mapString map[string]*Field

	OnAfterFieldCreateCallback OnAfterCreateInterface[Field]
	OnAfterFieldUpdateCallback OnAfterUpdateInterface[Field]
	OnAfterFieldDeleteCallback OnAfterDeleteInterface[Field]
	OnAfterFieldReadCallback   OnAfterReadInterface[Field]

	GongEnumShapes           map[*GongEnumShape]any
	GongEnumShapes_mapString map[string]*GongEnumShape

	// insertion point for slice of pointers maps
	GongEnumShape_GongEnumValueEntrys_reverseMap map[*GongEnumValueEntry]*GongEnumShape

	OnAfterGongEnumShapeCreateCallback OnAfterCreateInterface[GongEnumShape]
	OnAfterGongEnumShapeUpdateCallback OnAfterUpdateInterface[GongEnumShape]
	OnAfterGongEnumShapeDeleteCallback OnAfterDeleteInterface[GongEnumShape]
	OnAfterGongEnumShapeReadCallback   OnAfterReadInterface[GongEnumShape]

	GongEnumValueEntrys           map[*GongEnumValueEntry]any
	GongEnumValueEntrys_mapString map[string]*GongEnumValueEntry

	OnAfterGongEnumValueEntryCreateCallback OnAfterCreateInterface[GongEnumValueEntry]
	OnAfterGongEnumValueEntryUpdateCallback OnAfterUpdateInterface[GongEnumValueEntry]
	OnAfterGongEnumValueEntryDeleteCallback OnAfterDeleteInterface[GongEnumValueEntry]
	OnAfterGongEnumValueEntryReadCallback   OnAfterReadInterface[GongEnumValueEntry]

	GongStructShapes           map[*GongStructShape]any
	GongStructShapes_mapString map[string]*GongStructShape

	// insertion point for slice of pointers maps
	GongStructShape_Fields_reverseMap map[*Field]*GongStructShape
	GongStructShape_Links_reverseMap  map[*Link]*GongStructShape

	OnAfterGongStructShapeCreateCallback OnAfterCreateInterface[GongStructShape]
	OnAfterGongStructShapeUpdateCallback OnAfterUpdateInterface[GongStructShape]
	OnAfterGongStructShapeDeleteCallback OnAfterDeleteInterface[GongStructShape]
	OnAfterGongStructShapeReadCallback   OnAfterReadInterface[GongStructShape]

	Links           map[*Link]any
	Links_mapString map[string]*Link

	OnAfterLinkCreateCallback OnAfterCreateInterface[Link]
	OnAfterLinkUpdateCallback OnAfterUpdateInterface[Link]
	OnAfterLinkDeleteCallback OnAfterDeleteInterface[Link]
	OnAfterLinkReadCallback   OnAfterReadInterface[Link]

	NoteShapes           map[*NoteShape]any
	NoteShapes_mapString map[string]*NoteShape

	// insertion point for slice of pointers maps
	NoteShape_NoteShapeLinks_reverseMap map[*NoteShapeLink]*NoteShape

	OnAfterNoteShapeCreateCallback OnAfterCreateInterface[NoteShape]
	OnAfterNoteShapeUpdateCallback OnAfterUpdateInterface[NoteShape]
	OnAfterNoteShapeDeleteCallback OnAfterDeleteInterface[NoteShape]
	OnAfterNoteShapeReadCallback   OnAfterReadInterface[NoteShape]

	NoteShapeLinks           map[*NoteShapeLink]any
	NoteShapeLinks_mapString map[string]*NoteShapeLink

	OnAfterNoteShapeLinkCreateCallback OnAfterCreateInterface[NoteShapeLink]
	OnAfterNoteShapeLinkUpdateCallback OnAfterUpdateInterface[NoteShapeLink]
	OnAfterNoteShapeLinkDeleteCallback OnAfterDeleteInterface[NoteShapeLink]
	OnAfterNoteShapeLinkReadCallback   OnAfterReadInterface[NoteShapeLink]

	Positions           map[*Position]any
	Positions_mapString map[string]*Position

	OnAfterPositionCreateCallback OnAfterCreateInterface[Position]
	OnAfterPositionUpdateCallback OnAfterUpdateInterface[Position]
	OnAfterPositionDeleteCallback OnAfterDeleteInterface[Position]
	OnAfterPositionReadCallback   OnAfterReadInterface[Position]

	UmlStates           map[*UmlState]any
	UmlStates_mapString map[string]*UmlState

	OnAfterUmlStateCreateCallback OnAfterCreateInterface[UmlState]
	OnAfterUmlStateUpdateCallback OnAfterUpdateInterface[UmlState]
	OnAfterUmlStateDeleteCallback OnAfterDeleteInterface[UmlState]
	OnAfterUmlStateReadCallback   OnAfterReadInterface[UmlState]

	Umlscs           map[*Umlsc]any
	Umlscs_mapString map[string]*Umlsc

	// insertion point for slice of pointers maps
	Umlsc_States_reverseMap map[*UmlState]*Umlsc

	OnAfterUmlscCreateCallback OnAfterCreateInterface[Umlsc]
	OnAfterUmlscUpdateCallback OnAfterUpdateInterface[Umlsc]
	OnAfterUmlscDeleteCallback OnAfterDeleteInterface[Umlsc]
	OnAfterUmlscReadCallback   OnAfterReadInterface[Umlsc]

	Vertices           map[*Vertice]any
	Vertices_mapString map[string]*Vertice

	OnAfterVerticeCreateCallback OnAfterCreateInterface[Vertice]
	OnAfterVerticeUpdateCallback OnAfterUpdateInterface[Vertice]
	OnAfterVerticeDeleteCallback OnAfterDeleteInterface[Vertice]
	OnAfterVerticeReadCallback   OnAfterReadInterface[Vertice]

	AllModelsStructCreateCallback AllModelsStructCreateInterface

	AllModelsStructDeleteCallback AllModelsStructDeleteInterface

	BackRepo BackRepoInterface

	// if set will be called before each commit to the back repo
	OnInitCommitCallback          OnInitCommitInterface
	OnInitCommitFromFrontCallback OnInitCommitInterface
	OnInitCommitFromBackCallback  OnInitCommitInterface

	// store the number of instance per gongstruct
	Map_GongStructName_InstancesNb map[string]int

	// store meta package import
	MetaPackageImportPath  string
	MetaPackageImportAlias string

	// to be removed after fix of [issue](https://github.com/golang/go/issues/57559)
	// map to enable docLink renaming when an identifier is renamed
	Map_DocLink_Renaming map[string]GONG__Identifier
	// contains filtered or unexported fields
}

type Tabulator interface {
	AddSheet(sheetName string)
	AddRow(sheetName string) int
	AddCell(sheetName string, rowId, columnIndex int, value string)
}

type UmlState struct {
	Name string

	X float64
	Y float64
}

type UmlState_WOP struct {
	// insertion point
	Name string
	X    float64
	Y    float64
}

type Umlsc struct {
	Name string

	// this is the memory model (and not the "memory motel" of the Rolling Stones)
	// it is not ignored by swagger because it is used by the angular model
	States []*UmlState

	// in this version, only one state is active mong the states
	// (with the embedded states version, that might change)
	Activestate string

	// IsInDrawMode indicates the the drawing can be edited (in development mode)
	// or not (in production mode)
	IsInDrawMode bool
}

type Umlsc_WOP struct {
	// insertion point
	Name         string
	Activestate  string
	IsInDrawMode bool
}

type Vertice struct {
	X    float64
	Y    float64
	Name string // temporary
}

type Vertice_WOP struct {
	// insertion point
	X    float64
	Y    float64
	Name string
}