models

package
v0.0.0-...-9f4acd0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 14, 2025 License: MIT Imports: 35 Imported by: 7

Documentation

Overview

Default generated models package docs (at least one file is necessary in a models package)

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

generated code - do not edit

Index

Constants

View Source 
const IdentifiersDecls = `
	{{Identifier}} := (&models.{{GeneratedStructName}}{}).Stage(stage)`
View Source 
const MetaFieldStructInitStatement = `
	{{Identifier}}.{{GeneratedFieldName}} = ` + `{{GeneratedFieldNameValue}}`
View Source 
const NumberInitStatement = `
	{{Identifier}}.{{GeneratedFieldName}} = {{GeneratedFieldNameValue}}`
View Source 
const PointerFieldInitStatement = `
	{{Identifier}}.{{GeneratedFieldName}} = {{GeneratedFieldNameValue}}`
View Source 
const ProbeFormSuffix = ":form of the probe"
View Source 
const ProbeSplitSuffix = ":probe of the probe"
View Source 
const ProbeTableSuffix = ":table of the probe"
View Source 
const ProbeTreeSidebarSuffix = ":sidebar of the probe"
View Source 
const SliceOfPointersFieldInitStatement = `
	{{Identifier}}.{{GeneratedFieldName}} = append({{Identifier}}.{{GeneratedFieldName}}, {{GeneratedFieldNameValue}})`
View Source 
const StringEnumInitStatement = `
	{{Identifier}}.{{GeneratedFieldName}} = {{GeneratedFieldNameValue}}`
View Source 
const StringInitStatement = `
	{{Identifier}}.{{GeneratedFieldName}} = ` + "`" + `{{GeneratedFieldNameValue}}` + "`"
View Source 
const TimeInitStatement = `` /* 129-byte string literal not displayed */

Variables

This section is empty.

Functions

func AfterCreateFromFront 

func AfterCreateFromFront[Type Gongstruct](stage *Stage, instance *Type)

AfterCreateFromFront is called after a create from front

func AfterDeleteFromFront 

func AfterDeleteFromFront[Type Gongstruct](stage *Stage, staged, front *Type)

AfterDeleteFromFront is called after a delete from front

func AfterReadFromFront 

func AfterReadFromFront[Type Gongstruct](stage *Stage, instance *Type)

AfterReadFromFront is called after a Read from front

func AfterUpdateFromFront 

func AfterUpdateFromFront[Type Gongstruct](stage *Stage, old, new *Type)

AfterUpdateFromFront is called after a update from front

func ApplyDiff 

func ApplyDiff(b, c string) (string, error)

ApplyDiff applies a git-style unified diff c to string b to reconstruct string a

func CompareGongstructByName 

func CompareGongstructByName[T PointerToGongstruct](a, b T) int

func ComputeDiff 

func ComputeDiff(a, b string) string

ComputeDiff generates a git-style unified diff from string a to string b

func CopyBranch 

func CopyBranch[Type Gongstruct](from *Type) (to *Type)

CopyBranch stages instance and apply CopyBranch on all gongstruct instances that are referenced by pointers or slices of pointers of the instance

the algorithm stops along the course of graph if a vertex is already staged

func GetAssociationName 

func GetAssociationName[Type Gongstruct]() *Type

GetAssociationName is a generic function that returns an instance of Type where each association is filled with an instance whose name is the name of the association

This function can be handy for generating navigation function that are refactorable

func GetFields 

func GetFields[Type Gongstruct]() (res []string)

GetFields return the array of the fields

func GetFieldsFromPointer 

func GetFieldsFromPointer[Type PointerToGongstruct]() (res []string)

GetFieldsFromPointer return the array of the fields

func GetGongstrucsSorted 

func GetGongstrucsSorted[T PointerToGongstruct](stage *Stage) (sortedSlice []T)

func GetGongstructInstancesMap 

func GetGongstructInstancesMap[Type Gongstruct](stage *Stage) *map[string]*Type

GetGongstructInstancesMap returns the map of staged GongstructType instances it is usefull because it allows refactoring of gong struct identifier

func GetGongstructInstancesSet 

func GetGongstructInstancesSet[Type Gongstruct](stage *Stage) *map[*Type]any

GetGongstructInstancesSet returns the set staged GongstructType instances it is usefull because it allows refactoring of gongstruct identifier

func GetGongstructInstancesSetFromPointerType 

func GetGongstructInstancesSetFromPointerType[Type PointerToGongstruct](stage *Stage) *map[Type]any

GetGongstructInstancesSetFromPointerType returns the set staged GongstructType instances it is usefull because it allows refactoring of gongstruct identifier

func GetGongstructName 

func GetGongstructName[Type Gongstruct]() (res string)

GetGongstructName returns the name of the Gongstruct this can be usefull if one want program robust to refactoring

func GetNamedStructInstances 

func GetNamedStructInstances[T PointerToGongstruct](set map[T]any, order map[T]uint) (res []string)

func GetOrder 

func GetOrder[Type Gongstruct](stage *Stage, instance *Type) uint

func GetOrderPointerGongstruct 

func GetOrderPointerGongstruct[Type PointerToGongstruct](stage *Stage, instance Type) uint

func GetPointerReverseMap 

func GetPointerReverseMap[Start, End Gongstruct](fieldname string, stage *Stage) map[*End][]*Start

GetPointerReverseMap allows backtrack navigation of any Start.Fieldname associations (0..1) that is a pointer from one staged Gongstruct (type Start) instances to another (type End)

The function provides a map with keys as instances of End and values to arrays of *Start the map is construed by iterating over all Start instances and populationg keys with End instances and values with slice of Start instances

func GetPointerToGongstructName 

func GetPointerToGongstructName[Type PointerToGongstruct]() (res string)

GetPointerToGongstructName returns the name of the Gongstruct this can be usefull if one want program robust to refactoring

func GetReverseFieldOwner 

func GetReverseFieldOwner[T Gongstruct](
	stage *Stage,
	instance *T,
	reverseField *ReverseField) (res any)

func GetReverseFieldOwnerName 

func GetReverseFieldOwnerName(
	stage *Stage,
	instance any,
	reverseField *ReverseField) (res string)

func GetSliceOfPointersReverseMap 

func GetSliceOfPointersReverseMap[Start, End Gongstruct](fieldname string, stage *Stage) map[*End][]*Start

GetSliceOfPointersReverseMap allows backtrack navigation of any Start.Fieldname associations (0..N) between one staged Gongstruct instances and many others

The function provides a map with keys as instances of End and values to *Start instances the map is construed by iterating over all Start instances and populating keys with End instances and values with the Start instances

func GetStructInstancesByOrder 

func GetStructInstancesByOrder[T PointerToGongstruct](set map[T]any, order map[T]uint) (res []T)

func GongGetMap 

func GongGetMap[Type GongstructMapString](stage *Stage) *Type

GongGetMap returns the map of staged GongstructType instances it is usefull because it allows refactoring of gong struct identifier

func GongGetSet 

func GongGetSet[Type GongstructSet](stage *Stage) *Type

GongGetSet returns the set staged GongstructType instances it is usefull because it allows refactoring of gong struct identifier

func IntToLetters 

func IntToLetters(number int32) (letters string)

func IsStaged 

func IsStaged[Type Gongstruct](stage *Stage, instance *Type) (ok bool)

func ParseAstEmbeddedFile 

func ParseAstEmbeddedFile(stage *Stage, directory embed.FS, pathToFile string) error

ParseAstEmbeddedFile parses the Go source code from an embedded file specified by pathToFile within the provided embed.FS directory and stages instances declared in the file using the provided Stage.

Parameters: 

stage:      The staging area to populate.
directory:  The embedded filesystem containing the file.
pathToFile: The path to the Go source file within the embedded filesystem.

Returns: 

An error if reading or parsing the file fails, or if ParseAstFileFromAst fails.

func ParseAstFile 

func ParseAstFile(stage *Stage, pathToFile string) error

ParseAstFile Parse pathToFile and stages all instances declared in the file

func ParseAstFileFromAst 

func ParseAstFileFromAst(stage *Stage, inFile *ast.File, fset *token.FileSet) error

ParseAstFile Parse pathToFile and stages all instances declared in the file

func ReplaceOldDeclarationsInFile 

func ReplaceOldDeclarationsInFile(pathToFile string) error

ReplaceOldDeclarationsInFile replaces specific text in a file at the given path.

func Serialize 

func Serialize[Type Gongstruct](stage *Stage, tab Tabulator)

func SerializeExcelize 

func SerializeExcelize[Type Gongstruct](stage *Stage, f *excelize.File)

func SerializeExcelizePointerToGongstruct 

func SerializeExcelizePointerToGongstruct[Type PointerToGongstruct](stage *Stage, f *excelize.File)

func SerializeStage 

func SerializeStage(stage *Stage, filename string)

func SetCallbackAfterCreateFromFront 

func SetCallbackAfterCreateFromFront[Type Gongstruct](stage *Stage, callback OnAfterCreateInterface[Type])

func SetCallbackAfterDeleteFromFront 

func SetCallbackAfterDeleteFromFront[Type Gongstruct](stage *Stage, callback OnAfterDeleteInterface[Type])

func SetCallbackAfterReadFromFront 

func SetCallbackAfterReadFromFront[Type Gongstruct](stage *Stage, callback OnAfterReadInterface[Type])

func SetCallbackAfterUpdateFromFront 

func SetCallbackAfterUpdateFromFront[Type Gongstruct](stage *Stage, callback OnAfterUpdateInterface[Type])

SetCallbackAfterUpdateFromFront is a function to set up callback that is robust to refactoring

func SetOrchestratorOnAfterUpdate 

func SetOrchestratorOnAfterUpdate[Type Gongstruct](stage *Stage)

func SortGongstructSetByName 

func SortGongstructSetByName[T PointerToGongstruct](set map[T]any) (sortedSlice []T)

func StageBranch 

func StageBranch[Type Gongstruct](stage *Stage, instance *Type)

StageBranch stages instance and apply StageBranch on all gongstruct instances that are referenced by pointers or slices of pointers of the instance

the algorithm stops along the course of graph if a vertex is already staged

func UnmarshallGongstructStaging 

func UnmarshallGongstructStaging(stage *Stage, cmap *ast.CommentMap, assignStmt *ast.AssignStmt, astCoordinate_ string) (
	instance any,
	identifier string,
	gongstructName string,
	fieldName string)

UnmarshallGoStaging unmarshall a go assign statement

func UnstageBranch 

func UnstageBranch[Type Gongstruct](stage *Stage, instance *Type)

UnstageBranch stages instance and apply UnstageBranch on all gongstruct instances that are referenced by pointers or slices of pointers of the insance

the algorithm stops along the course of graph if a vertex is already staged

Types

type AllModelsStructCreateInterface 

type AllModelsStructCreateInterface interface {
	CreateORMAsSplit(AsSplit *AsSplit)
	CreateORMAsSplitArea(AsSplitArea *AsSplitArea)
	CreateORMButton(Button *Button)
	CreateORMCursor(Cursor *Cursor)
	CreateORMDoc(Doc *Doc)
	CreateORMFavIcon(FavIcon *FavIcon)
	CreateORMForm(Form *Form)
	CreateORMLoad(Load *Load)
	CreateORMLogoOnTheLeft(LogoOnTheLeft *LogoOnTheLeft)
	CreateORMLogoOnTheRight(LogoOnTheRight *LogoOnTheRight)
	CreateORMSlider(Slider *Slider)
	CreateORMSplit(Split *Split)
	CreateORMSvg(Svg *Svg)
	CreateORMTable(Table *Table)
	CreateORMTitle(Title *Title)
	CreateORMTone(Tone *Tone)
	CreateORMTree(Tree *Tree)
	CreateORMView(View *View)
	CreateORMXlsx(Xlsx *Xlsx)
}

swagger:ignore

type AllModelsStructDeleteInterface 

type AllModelsStructDeleteInterface interface {
	DeleteORMAsSplit(AsSplit *AsSplit)
	DeleteORMAsSplitArea(AsSplitArea *AsSplitArea)
	DeleteORMButton(Button *Button)
	DeleteORMCursor(Cursor *Cursor)
	DeleteORMDoc(Doc *Doc)
	DeleteORMFavIcon(FavIcon *FavIcon)
	DeleteORMForm(Form *Form)
	DeleteORMLoad(Load *Load)
	DeleteORMLogoOnTheLeft(LogoOnTheLeft *LogoOnTheLeft)
	DeleteORMLogoOnTheRight(LogoOnTheRight *LogoOnTheRight)
	DeleteORMSlider(Slider *Slider)
	DeleteORMSplit(Split *Split)
	DeleteORMSvg(Svg *Svg)
	DeleteORMTable(Table *Table)
	DeleteORMTitle(Title *Title)
	DeleteORMTone(Tone *Tone)
	DeleteORMTree(Tree *Tree)
	DeleteORMView(View *View)
	DeleteORMXlsx(Xlsx *Xlsx)
}

type AsSplit 

type AsSplit struct {
	Name string

	Direction Direction

	AsSplitAreas []*AsSplitArea
}

func CopyBranchAsSplit 

func CopyBranchAsSplit(mapOrigCopy map[any]any, assplitFrom *AsSplit) (assplitTo *AsSplit)

insertion point for stage branch per struct

func (*AsSplit) Checkout 

func (assplit *AsSplit) Checkout(stage *Stage) *AsSplit

Checkout assplit to the back repo (if it is already staged)

func (*AsSplit) Commit 

func (assplit *AsSplit) Commit(stage *Stage) *AsSplit

commit assplit to the back repo (if it is already staged)

func (*AsSplit) CommitVoid 

func (assplit *AsSplit) CommitVoid(stage *Stage)

func (*AsSplit) CopyBasicFields 

func (from *AsSplit) CopyBasicFields(to *AsSplit)

func (*AsSplit) GetName 

func (assplit *AsSplit) GetName() (res string)

for satisfaction of GongStruct interface

func (*AsSplit) Stage 

func (assplit *AsSplit) Stage(stage *Stage) *AsSplit

insertion point for cumulative sub template with model space calls Stage puts assplit to the model stage

func (*AsSplit) Unstage 

func (assplit *AsSplit) Unstage(stage *Stage) *AsSplit

Unstage removes assplit off the model stage

func (*AsSplit) UnstageVoid 

func (assplit *AsSplit) UnstageVoid(stage *Stage)

UnstageVoid removes assplit off the model stage

type AsSplitArea 

type AsSplitArea struct {
	Name string

	ShowNameInHeader bool

	Size float64

	// IsAany make the split area set size to "$any(*)"
	IsAny bool

	AsSplit *AsSplit

	Button *Button
	Cursor *Cursor
	Doc    *Doc
	Form   *Form
	Load   *Load
	Slider *Slider
	Split  *Split
	Svg    *Svg
	Table  *Table
	Tone   *Tone
	Tree   *Tree
	Xlsx   *Xlsx

	HasDiv   bool
	DivStyle string // in case of div, the div style
}

func CopyBranchAsSplitArea 

func CopyBranchAsSplitArea(mapOrigCopy map[any]any, assplitareaFrom *AsSplitArea) (assplitareaTo *AsSplitArea)

func (*AsSplitArea) Checkout 

func (assplitarea *AsSplitArea) Checkout(stage *Stage) *AsSplitArea

Checkout assplitarea to the back repo (if it is already staged)

func (*AsSplitArea) Commit 

func (assplitarea *AsSplitArea) Commit(stage *Stage) *AsSplitArea

commit assplitarea to the back repo (if it is already staged)

func (*AsSplitArea) CommitVoid 

func (assplitarea *AsSplitArea) CommitVoid(stage *Stage)

func (*AsSplitArea) CopyBasicFields 

func (from *AsSplitArea) CopyBasicFields(to *AsSplitArea)

func (*AsSplitArea) GetName 

func (assplitarea *AsSplitArea) GetName() (res string)

for satisfaction of GongStruct interface

func (*AsSplitArea) Stage 

func (assplitarea *AsSplitArea) Stage(stage *Stage) *AsSplitArea

Stage puts assplitarea to the model stage

func (*AsSplitArea) Unstage 

func (assplitarea *AsSplitArea) Unstage(stage *Stage) *AsSplitArea

Unstage removes assplitarea off the model stage

func (*AsSplitArea) UnstageVoid 

func (assplitarea *AsSplitArea) UnstageVoid(stage *Stage)

UnstageVoid removes assplitarea off the model stage

type AsSplitArea_WOP 

type AsSplitArea_WOP struct {
	Name string

	ShowNameInHeader bool

	Size float64

	IsAny bool

	HasDiv bool

	DivStyle string
}

type AsSplit_WOP 

type AsSplit_WOP struct {
	Name string

	Direction Direction
}

insertion point

type BackRepoInterface 

type BackRepoInterface interface {
	Commit(stage *Stage)
	Checkout(stage *Stage)
	Backup(stage *Stage, dirPath string)
	Restore(stage *Stage, dirPath string)
	BackupXL(stage *Stage, dirPath string)
	RestoreXL(stage *Stage, dirPath string)
	// insertion point for Commit and Checkout signatures
	CommitAsSplit(assplit *AsSplit)
	CheckoutAsSplit(assplit *AsSplit)
	CommitAsSplitArea(assplitarea *AsSplitArea)
	CheckoutAsSplitArea(assplitarea *AsSplitArea)
	CommitButton(button *Button)
	CheckoutButton(button *Button)
	CommitCursor(cursor *Cursor)
	CheckoutCursor(cursor *Cursor)
	CommitDoc(doc *Doc)
	CheckoutDoc(doc *Doc)
	CommitFavIcon(favicon *FavIcon)
	CheckoutFavIcon(favicon *FavIcon)
	CommitForm(form *Form)
	CheckoutForm(form *Form)
	CommitLoad(load *Load)
	CheckoutLoad(load *Load)
	CommitLogoOnTheLeft(logoontheleft *LogoOnTheLeft)
	CheckoutLogoOnTheLeft(logoontheleft *LogoOnTheLeft)
	CommitLogoOnTheRight(logoontheright *LogoOnTheRight)
	CheckoutLogoOnTheRight(logoontheright *LogoOnTheRight)
	CommitSlider(slider *Slider)
	CheckoutSlider(slider *Slider)
	CommitSplit(split *Split)
	CheckoutSplit(split *Split)
	CommitSvg(svg *Svg)
	CheckoutSvg(svg *Svg)
	CommitTable(table *Table)
	CheckoutTable(table *Table)
	CommitTitle(title *Title)
	CheckoutTitle(title *Title)
	CommitTone(tone *Tone)
	CheckoutTone(tone *Tone)
	CommitTree(tree *Tree)
	CheckoutTree(tree *Tree)
	CommitView(view *View)
	CheckoutView(view *View)
	CommitXlsx(xlsx *Xlsx)
	CheckoutXlsx(xlsx *Xlsx)
	GetLastCommitFromBackNb() uint
	GetLastPushFromFrontNb() uint
}

type Button 

type Button struct {
	Name      string // name of the stack
	StackName string
}

func CopyBranchButton 

func CopyBranchButton(mapOrigCopy map[any]any, buttonFrom *Button) (buttonTo *Button)

func (*Button) Checkout 

func (button *Button) Checkout(stage *Stage) *Button

Checkout button to the back repo (if it is already staged)

func (*Button) Commit 

func (button *Button) Commit(stage *Stage) *Button

commit button to the back repo (if it is already staged)

func (*Button) CommitVoid 

func (button *Button) CommitVoid(stage *Stage)

func (*Button) CopyBasicFields 

func (from *Button) CopyBasicFields(to *Button)

func (*Button) GetName 

func (button *Button) GetName() (res string)

for satisfaction of GongStruct interface

func (*Button) Stage 

func (button *Button) Stage(stage *Stage) *Button

Stage puts button to the model stage

func (*Button) Unstage 

func (button *Button) Unstage(stage *Stage) *Button

Unstage removes button off the model stage

func (*Button) UnstageVoid 

func (button *Button) UnstageVoid(stage *Stage)

UnstageVoid removes button off the model stage

type Button_WOP 

type Button_WOP struct {
	Name string

	StackName string
}

type Cursor 

type Cursor struct {
	Name      string // name of the stack
	StackName string
	Style     string
}

func CopyBranchCursor 

func CopyBranchCursor(mapOrigCopy map[any]any, cursorFrom *Cursor) (cursorTo *Cursor)

func (*Cursor) Checkout 

func (cursor *Cursor) Checkout(stage *Stage) *Cursor

Checkout cursor to the back repo (if it is already staged)

func (*Cursor) Commit 

func (cursor *Cursor) Commit(stage *Stage) *Cursor

commit cursor to the back repo (if it is already staged)

func (*Cursor) CommitVoid 

func (cursor *Cursor) CommitVoid(stage *Stage)

func (*Cursor) CopyBasicFields 

func (from *Cursor) CopyBasicFields(to *Cursor)

func (*Cursor) GetName 

func (cursor *Cursor) GetName() (res string)

for satisfaction of GongStruct interface

func (*Cursor) Stage 

func (cursor *Cursor) Stage(stage *Stage) *Cursor

Stage puts cursor to the model stage

func (*Cursor) Unstage 

func (cursor *Cursor) Unstage(stage *Stage) *Cursor

Unstage removes cursor off the model stage

func (*Cursor) UnstageVoid 

func (cursor *Cursor) UnstageVoid(stage *Stage)

UnstageVoid removes cursor off the model stage

type Cursor_WOP 

type Cursor_WOP struct {
	Name string

	StackName string

	Style string
}

type DiffHunk 

type DiffHunk struct {
	OldStart int
	OldLines int
	NewStart int
	NewLines int
	Lines    []string
}

DiffHunk represents a single hunk in a unified diff

type DiffOp 

type DiffOp struct {
	Type string // "context", "delete", "add"
	Text string
}

DiffLine represents a line in a diff with its operation

type Direction 

type Direction string
const (
	Vertical   Direction = "vertical"
	Horizontal Direction = "horizontal"
)

func (Direction) CodeValues 

func (direction Direction) CodeValues() (res []string)

func (Direction) Codes 

func (direction Direction) Codes() (res []string)

func (*Direction) FromCodeString 

func (direction *Direction) FromCodeString(input string) (err error)

func (*Direction) FromString 

func (direction *Direction) FromString(input string) (err error)

func (*Direction) ToCodeString 

func (direction *Direction) ToCodeString() (res string)

func (Direction) ToString 

func (direction Direction) ToString() (res string)

insertion point of enum utility functions Utility function for Direction if enum values are string, it is stored with the value if enum values are int, they are stored with the code of the value

type Doc 

type Doc struct {
	Name      string // name of the stack
	StackName string
}

func CopyBranchDoc 

func CopyBranchDoc(mapOrigCopy map[any]any, docFrom *Doc) (docTo *Doc)

func (*Doc) Checkout 

func (doc *Doc) Checkout(stage *Stage) *Doc

Checkout doc to the back repo (if it is already staged)

func (*Doc) Commit 

func (doc *Doc) Commit(stage *Stage) *Doc

commit doc to the back repo (if it is already staged)

func (*Doc) CommitVoid 

func (doc *Doc) CommitVoid(stage *Stage)

func (*Doc) CopyBasicFields 

func (from *Doc) CopyBasicFields(to *Doc)

func (*Doc) GetName 

func (doc *Doc) GetName() (res string)

for satisfaction of GongStruct interface

func (*Doc) Stage 

func (doc *Doc) Stage(stage *Stage) *Doc

Stage puts doc to the model stage

func (*Doc) Unstage 

func (doc *Doc) Unstage(stage *Stage) *Doc

Unstage removes doc off the model stage

func (*Doc) UnstageVoid 

func (doc *Doc) UnstageVoid(stage *Stage)

UnstageVoid removes doc off the model stage

type Doc_WOP 

type Doc_WOP struct {
	Name string

	StackName string
}

type ExcelizeTabulator 

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

func (*ExcelizeTabulator) AddCell 

func (tab *ExcelizeTabulator) AddCell(sheetName string, rowId, columnIndex int, value string)

func (*ExcelizeTabulator) AddRow 

func (tab *ExcelizeTabulator) AddRow(sheetName string) (rowId int)

func (*ExcelizeTabulator) AddSheet 

func (tab *ExcelizeTabulator) AddSheet(sheetName string)

func (*ExcelizeTabulator) SetExcelizeFile 

func (tab *ExcelizeTabulator) SetExcelizeFile(f *excelize.File)

type FavIcon 

type FavIcon struct {
	Name string

	//gong:width 600 gong:height 300
	SVG string
}

You can configure the browser tab title and favicon dynamically in Angular creates one instance and it will set the browser accordingly

func CopyBranchFavIcon 

func CopyBranchFavIcon(mapOrigCopy map[any]any, faviconFrom *FavIcon) (faviconTo *FavIcon)

func (*FavIcon) Checkout 

func (favicon *FavIcon) Checkout(stage *Stage) *FavIcon

Checkout favicon to the back repo (if it is already staged)

func (*FavIcon) Commit 

func (favicon *FavIcon) Commit(stage *Stage) *FavIcon

commit favicon to the back repo (if it is already staged)

func (*FavIcon) CommitVoid 

func (favicon *FavIcon) CommitVoid(stage *Stage)

func (*FavIcon) CopyBasicFields 

func (from *FavIcon) CopyBasicFields(to *FavIcon)

func (*FavIcon) GetName 

func (favicon *FavIcon) GetName() (res string)

for satisfaction of GongStruct interface

func (*FavIcon) Stage 

func (favicon *FavIcon) Stage(stage *Stage) *FavIcon

Stage puts favicon to the model stage

func (*FavIcon) Unstage 

func (favicon *FavIcon) Unstage(stage *Stage) *FavIcon

Unstage removes favicon off the model stage

func (*FavIcon) UnstageVoid 

func (favicon *FavIcon) UnstageVoid(stage *Stage)

UnstageVoid removes favicon off the model stage

type FavIcon_WOP 

type FavIcon_WOP struct {
	Name string

	SVG string
}

type Form 

type Form struct {
	Name      string // name of the stack
	StackName string
	FormName  string
}

func CopyBranchForm 

func CopyBranchForm(mapOrigCopy map[any]any, formFrom *Form) (formTo *Form)

func (*Form) Checkout 

func (form *Form) Checkout(stage *Stage) *Form

Checkout form to the back repo (if it is already staged)

func (*Form) Commit 

func (form *Form) Commit(stage *Stage) *Form

commit form to the back repo (if it is already staged)

func (*Form) CommitVoid 

func (form *Form) CommitVoid(stage *Stage)

func (*Form) CopyBasicFields 

func (from *Form) CopyBasicFields(to *Form)

func (*Form) GetName 

func (form *Form) GetName() (res string)

for satisfaction of GongStruct interface

func (*Form) Stage 

func (form *Form) Stage(stage *Stage) *Form

Stage puts form to the model stage

func (*Form) Unstage 

func (form *Form) Unstage(stage *Stage) *Form

Unstage removes form off the model stage

func (*Form) UnstageVoid 

func (form *Form) UnstageVoid(stage *Stage)

UnstageVoid removes form off the model stage

type Form_WOP 

type Form_WOP struct {
	Name string

	StackName string

	FormName string
}

type GONG__ExpressionType 

type GONG__ExpressionType string

swagger:ignore 

const (
	GONG__STRUCT_INSTANCE      GONG__ExpressionType = "STRUCT_INSTANCE"
	GONG__FIELD_OR_CONST_VALUE GONG__ExpressionType = "FIELD_OR_CONST_VALUE"
	GONG__FIELD_VALUE          GONG__ExpressionType = "FIELD_VALUE"
	GONG__ENUM_CAST_INT        GONG__ExpressionType = "ENUM_CAST_INT"
	GONG__ENUM_CAST_STRING     GONG__ExpressionType = "ENUM_CAST_STRING"
	GONG__IDENTIFIER_CONST     GONG__ExpressionType = "IDENTIFIER_CONST"
)

type GONG__Identifier 

type GONG__Identifier struct {
	Ident string
	Type  GONG__ExpressionType
}

type GongFieldValue 

type GongFieldValue struct {
	GongFieldValueType
	// contains filtered or unexported fields
}

func GetFieldStringValue 

func GetFieldStringValue(instance any, fieldName string) (res GongFieldValue)

func GetFieldStringValueFromPointer 

func GetFieldStringValueFromPointer(instance any, fieldName string) (res GongFieldValue)

func (*GongFieldValue) GetValueBool 

func (gongValueField *GongFieldValue) GetValueBool() bool

func (*GongFieldValue) GetValueFloat 

func (gongValueField *GongFieldValue) GetValueFloat() float64

func (*GongFieldValue) GetValueInt 

func (gongValueField *GongFieldValue) GetValueInt() int

func (*GongFieldValue) GetValueString 

func (gongValueField *GongFieldValue) GetValueString() string

type GongFieldValueType 

type GongFieldValueType string
const (
	GongFieldValueTypeInt    GongFieldValueType = "GongFieldValueTypeInt"
	GongFieldValueTypeFloat  GongFieldValueType = "GongFieldValueTypeFloat"
	GongFieldValueTypeBool   GongFieldValueType = "GongFieldValueTypeBool"
	GongFieldValueTypeOthers GongFieldValueType = "GongFieldValueTypeOthers"
)

type GongStructInterface 

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

GongStructInterface is the interface met by GongStructs It allows runtime reflexion of instances (without the hassle of the "reflect" package)

type Gongstruct 

type Gongstruct interface {
}

Gongstruct is the type parameter for generated generic function that allows - access to staged instances - navigation between staged instances by going backward association links between gongstruct - full refactoring of Gongstruct identifiers / fields

type GongstructEnumIntField 

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

type GongstructEnumStringField 

type GongstructEnumStringField interface {
	Codes() []string
	CodeValues() []string
	ToString() string
}

type GongstructMapString 

type GongstructMapString interface {
	map[any]any
}

type GongstructSet 

type GongstructSet interface {
	map[any]any
}

type GongtructBasicField 

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

type Load 

type Load struct {
	Name      string // name of the stack
	StackName string
}

func CopyBranchLoad 

func CopyBranchLoad(mapOrigCopy map[any]any, loadFrom *Load) (loadTo *Load)

func (*Load) Checkout 

func (load *Load) Checkout(stage *Stage) *Load

Checkout load to the back repo (if it is already staged)

func (*Load) Commit 

func (load *Load) Commit(stage *Stage) *Load

commit load to the back repo (if it is already staged)

func (*Load) CommitVoid 

func (load *Load) CommitVoid(stage *Stage)

func (*Load) CopyBasicFields 

func (from *Load) CopyBasicFields(to *Load)

func (*Load) GetName 

func (load *Load) GetName() (res string)

for satisfaction of GongStruct interface

func (*Load) Stage 

func (load *Load) Stage(stage *Stage) *Load

Stage puts load to the model stage

func (*Load) Unstage 

func (load *Load) Unstage(stage *Stage) *Load

Unstage removes load off the model stage

func (*Load) UnstageVoid 

func (load *Load) UnstageVoid(stage *Stage)

UnstageVoid removes load off the model stage

type Load_WOP 

type Load_WOP struct {
	Name string

	StackName string
}

type LogoOnTheLeft 

type LogoOnTheLeft struct {
	Name string

	Width  int
	Height int

	//gong:width 600 gong:height 300
	SVG string
}

LogoOnTheLeft displayed in the banner

func CopyBranchLogoOnTheLeft 

func CopyBranchLogoOnTheLeft(mapOrigCopy map[any]any, logoontheleftFrom *LogoOnTheLeft) (logoontheleftTo *LogoOnTheLeft)

func (*LogoOnTheLeft) Checkout 

func (logoontheleft *LogoOnTheLeft) Checkout(stage *Stage) *LogoOnTheLeft

Checkout logoontheleft to the back repo (if it is already staged)

func (*LogoOnTheLeft) Commit 

func (logoontheleft *LogoOnTheLeft) Commit(stage *Stage) *LogoOnTheLeft

commit logoontheleft to the back repo (if it is already staged)

func (*LogoOnTheLeft) CommitVoid 

func (logoontheleft *LogoOnTheLeft) CommitVoid(stage *Stage)

func (*LogoOnTheLeft) CopyBasicFields 

func (from *LogoOnTheLeft) CopyBasicFields(to *LogoOnTheLeft)

func (*LogoOnTheLeft) GetName 

func (logoontheleft *LogoOnTheLeft) GetName() (res string)

for satisfaction of GongStruct interface

func (*LogoOnTheLeft) Stage 

func (logoontheleft *LogoOnTheLeft) Stage(stage *Stage) *LogoOnTheLeft

Stage puts logoontheleft to the model stage

func (*LogoOnTheLeft) Unstage 

func (logoontheleft *LogoOnTheLeft) Unstage(stage *Stage) *LogoOnTheLeft

Unstage removes logoontheleft off the model stage

func (*LogoOnTheLeft) UnstageVoid 

func (logoontheleft *LogoOnTheLeft) UnstageVoid(stage *Stage)

UnstageVoid removes logoontheleft off the model stage

type LogoOnTheLeft_WOP 

type LogoOnTheLeft_WOP struct {
	Name string

	Width int

	Height int

	SVG string
}

type LogoOnTheRight 

type LogoOnTheRight struct {
	Name string

	Width  int
	Height int

	//gong:width 600 gong:height 300
	SVG string
}

LogoOnTheLeft displayed in the banner

func CopyBranchLogoOnTheRight 

func CopyBranchLogoOnTheRight(mapOrigCopy map[any]any, logoontherightFrom *LogoOnTheRight) (logoontherightTo *LogoOnTheRight)

func (*LogoOnTheRight) Checkout 

func (logoontheright *LogoOnTheRight) Checkout(stage *Stage) *LogoOnTheRight

Checkout logoontheright to the back repo (if it is already staged)

func (*LogoOnTheRight) Commit 

func (logoontheright *LogoOnTheRight) Commit(stage *Stage) *LogoOnTheRight

commit logoontheright to the back repo (if it is already staged)

func (*LogoOnTheRight) CommitVoid 

func (logoontheright *LogoOnTheRight) CommitVoid(stage *Stage)

func (*LogoOnTheRight) CopyBasicFields 

func (from *LogoOnTheRight) CopyBasicFields(to *LogoOnTheRight)

func (*LogoOnTheRight) GetName 

func (logoontheright *LogoOnTheRight) GetName() (res string)

for satisfaction of GongStruct interface

func (*LogoOnTheRight) Stage 

func (logoontheright *LogoOnTheRight) Stage(stage *Stage) *LogoOnTheRight

Stage puts logoontheright to the model stage

func (*LogoOnTheRight) Unstage 

func (logoontheright *LogoOnTheRight) Unstage(stage *Stage) *LogoOnTheRight

Unstage removes logoontheright off the model stage

func (*LogoOnTheRight) UnstageVoid 

func (logoontheright *LogoOnTheRight) UnstageVoid(stage *Stage)

UnstageVoid removes logoontheright off the model stage

type LogoOnTheRight_WOP 

type LogoOnTheRight_WOP struct {
	Name string

	Width int

	Height int

	SVG string
}

type NamedStruct 

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

func (*NamedStruct) GetName 

func (namedStruct *NamedStruct) GetName() string

type OnAfterCreateInterface 

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

OnAfterCreateInterface callback when an instance is updated from the front

type OnAfterDeleteInterface 

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

OnAfterDeleteInterface callback when an instance is updated from the front

type OnAfterReadInterface 

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

OnAfterReadInterface callback when an instance is updated from the front

type OnAfterUpdateInterface 

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

OnAfterUpdateInterface callback when an instance is updated from the front

type OnInitCommitInterface 

type OnInitCommitInterface interface {
	BeforeCommit(stage *Stage)
}

type PointerToGongstruct 

type PointerToGongstruct interface {
	GetName() string
	CommitVoid(*Stage)
	UnstageVoid(stage *Stage)
	comparable
}

Gongstruct is the type parameter for generated generic function that allows - access to staged instances - navigation between staged instances by going backward association links between gongstruct - full refactoring of Gongstruct identifiers / fields

type PointerToGongstructEnumIntField 

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

type PointerToGongstructEnumStringField 

type PointerToGongstructEnumStringField interface {
	FromCodeString(input string) (err error)
}

type ReverseField 

type ReverseField struct {
	GongstructName string
	Fieldname      string
}

func GetReverseFields 

func GetReverseFields[Type Gongstruct]() (res []ReverseField)

type Slider 

type Slider struct {
	Name      string // name of the stack
	StackName string
}

func CopyBranchSlider 

func CopyBranchSlider(mapOrigCopy map[any]any, sliderFrom *Slider) (sliderTo *Slider)

func (*Slider) Checkout 

func (slider *Slider) Checkout(stage *Stage) *Slider

Checkout slider to the back repo (if it is already staged)

func (*Slider) Commit 

func (slider *Slider) Commit(stage *Stage) *Slider

commit slider to the back repo (if it is already staged)

func (*Slider) CommitVoid 

func (slider *Slider) CommitVoid(stage *Stage)

func (*Slider) CopyBasicFields 

func (from *Slider) CopyBasicFields(to *Slider)

func (*Slider) GetName 

func (slider *Slider) GetName() (res string)

for satisfaction of GongStruct interface

func (*Slider) Stage 

func (slider *Slider) Stage(stage *Stage) *Slider

Stage puts slider to the model stage

func (*Slider) Unstage 

func (slider *Slider) Unstage(stage *Stage) *Slider

Unstage removes slider off the model stage

func (*Slider) UnstageVoid 

func (slider *Slider) UnstageVoid(stage *Stage)

UnstageVoid removes slider off the model stage

type Slider_WOP 

type Slider_WOP struct {
	Name string

	StackName string
}

type Split 

type Split struct {
	Name      string // name of the stack
	StackName string
}

func CopyBranchSplit 

func CopyBranchSplit(mapOrigCopy map[any]any, splitFrom *Split) (splitTo *Split)

func (*Split) Checkout 

func (split *Split) Checkout(stage *Stage) *Split

Checkout split to the back repo (if it is already staged)

func (*Split) Commit 

func (split *Split) Commit(stage *Stage) *Split

commit split to the back repo (if it is already staged)

func (*Split) CommitVoid 

func (split *Split) CommitVoid(stage *Stage)

func (*Split) CopyBasicFields 

func (from *Split) CopyBasicFields(to *Split)

func (*Split) GetName 

func (split *Split) GetName() (res string)

for satisfaction of GongStruct interface

func (*Split) Stage 

func (split *Split) Stage(stage *Stage) *Split

Stage puts split to the model stage

func (*Split) Unstage 

func (split *Split) Unstage(stage *Stage) *Split

Unstage removes split off the model stage

func (*Split) UnstageVoid 

func (split *Split) UnstageVoid(stage *Stage)

UnstageVoid removes split off the model stage

type Split_WOP 

type Split_WOP struct {
	Name string

	StackName string
}

type Stage 

type Stage struct {

	// insertion point for definition of arrays registering instances
	AsSplits           map[*AsSplit]any
	AsSplits_mapString map[string]*AsSplit

	// insertion point for slice of pointers maps
	AsSplit_AsSplitAreas_reverseMap map[*AsSplitArea]*AsSplit

	OnAfterAsSplitCreateCallback OnAfterCreateInterface[AsSplit]
	OnAfterAsSplitUpdateCallback OnAfterUpdateInterface[AsSplit]
	OnAfterAsSplitDeleteCallback OnAfterDeleteInterface[AsSplit]
	OnAfterAsSplitReadCallback   OnAfterReadInterface[AsSplit]

	AsSplitAreas           map[*AsSplitArea]any
	AsSplitAreas_mapString map[string]*AsSplitArea

	// insertion point for slice of pointers maps
	OnAfterAsSplitAreaCreateCallback OnAfterCreateInterface[AsSplitArea]
	OnAfterAsSplitAreaUpdateCallback OnAfterUpdateInterface[AsSplitArea]
	OnAfterAsSplitAreaDeleteCallback OnAfterDeleteInterface[AsSplitArea]
	OnAfterAsSplitAreaReadCallback   OnAfterReadInterface[AsSplitArea]

	Buttons           map[*Button]any
	Buttons_mapString map[string]*Button

	// insertion point for slice of pointers maps
	OnAfterButtonCreateCallback OnAfterCreateInterface[Button]
	OnAfterButtonUpdateCallback OnAfterUpdateInterface[Button]
	OnAfterButtonDeleteCallback OnAfterDeleteInterface[Button]
	OnAfterButtonReadCallback   OnAfterReadInterface[Button]

	Cursors           map[*Cursor]any
	Cursors_mapString map[string]*Cursor

	// insertion point for slice of pointers maps
	OnAfterCursorCreateCallback OnAfterCreateInterface[Cursor]
	OnAfterCursorUpdateCallback OnAfterUpdateInterface[Cursor]
	OnAfterCursorDeleteCallback OnAfterDeleteInterface[Cursor]
	OnAfterCursorReadCallback   OnAfterReadInterface[Cursor]

	Docs           map[*Doc]any
	Docs_mapString map[string]*Doc

	// insertion point for slice of pointers maps
	OnAfterDocCreateCallback OnAfterCreateInterface[Doc]
	OnAfterDocUpdateCallback OnAfterUpdateInterface[Doc]
	OnAfterDocDeleteCallback OnAfterDeleteInterface[Doc]
	OnAfterDocReadCallback   OnAfterReadInterface[Doc]

	FavIcons           map[*FavIcon]any
	FavIcons_mapString map[string]*FavIcon

	// insertion point for slice of pointers maps
	OnAfterFavIconCreateCallback OnAfterCreateInterface[FavIcon]
	OnAfterFavIconUpdateCallback OnAfterUpdateInterface[FavIcon]
	OnAfterFavIconDeleteCallback OnAfterDeleteInterface[FavIcon]
	OnAfterFavIconReadCallback   OnAfterReadInterface[FavIcon]

	Forms           map[*Form]any
	Forms_mapString map[string]*Form

	// insertion point for slice of pointers maps
	OnAfterFormCreateCallback OnAfterCreateInterface[Form]
	OnAfterFormUpdateCallback OnAfterUpdateInterface[Form]
	OnAfterFormDeleteCallback OnAfterDeleteInterface[Form]
	OnAfterFormReadCallback   OnAfterReadInterface[Form]

	Loads           map[*Load]any
	Loads_mapString map[string]*Load

	// insertion point for slice of pointers maps
	OnAfterLoadCreateCallback OnAfterCreateInterface[Load]
	OnAfterLoadUpdateCallback OnAfterUpdateInterface[Load]
	OnAfterLoadDeleteCallback OnAfterDeleteInterface[Load]
	OnAfterLoadReadCallback   OnAfterReadInterface[Load]

	LogoOnTheLefts           map[*LogoOnTheLeft]any
	LogoOnTheLefts_mapString map[string]*LogoOnTheLeft

	// insertion point for slice of pointers maps
	OnAfterLogoOnTheLeftCreateCallback OnAfterCreateInterface[LogoOnTheLeft]
	OnAfterLogoOnTheLeftUpdateCallback OnAfterUpdateInterface[LogoOnTheLeft]
	OnAfterLogoOnTheLeftDeleteCallback OnAfterDeleteInterface[LogoOnTheLeft]
	OnAfterLogoOnTheLeftReadCallback   OnAfterReadInterface[LogoOnTheLeft]

	LogoOnTheRights           map[*LogoOnTheRight]any
	LogoOnTheRights_mapString map[string]*LogoOnTheRight

	// insertion point for slice of pointers maps
	OnAfterLogoOnTheRightCreateCallback OnAfterCreateInterface[LogoOnTheRight]
	OnAfterLogoOnTheRightUpdateCallback OnAfterUpdateInterface[LogoOnTheRight]
	OnAfterLogoOnTheRightDeleteCallback OnAfterDeleteInterface[LogoOnTheRight]
	OnAfterLogoOnTheRightReadCallback   OnAfterReadInterface[LogoOnTheRight]

	Sliders           map[*Slider]any
	Sliders_mapString map[string]*Slider

	// insertion point for slice of pointers maps
	OnAfterSliderCreateCallback OnAfterCreateInterface[Slider]
	OnAfterSliderUpdateCallback OnAfterUpdateInterface[Slider]
	OnAfterSliderDeleteCallback OnAfterDeleteInterface[Slider]
	OnAfterSliderReadCallback   OnAfterReadInterface[Slider]

	Splits           map[*Split]any
	Splits_mapString map[string]*Split

	// insertion point for slice of pointers maps
	OnAfterSplitCreateCallback OnAfterCreateInterface[Split]
	OnAfterSplitUpdateCallback OnAfterUpdateInterface[Split]
	OnAfterSplitDeleteCallback OnAfterDeleteInterface[Split]
	OnAfterSplitReadCallback   OnAfterReadInterface[Split]

	Svgs           map[*Svg]any
	Svgs_mapString map[string]*Svg

	// insertion point for slice of pointers maps
	OnAfterSvgCreateCallback OnAfterCreateInterface[Svg]
	OnAfterSvgUpdateCallback OnAfterUpdateInterface[Svg]
	OnAfterSvgDeleteCallback OnAfterDeleteInterface[Svg]
	OnAfterSvgReadCallback   OnAfterReadInterface[Svg]

	Tables           map[*Table]any
	Tables_mapString map[string]*Table

	// insertion point for slice of pointers maps
	OnAfterTableCreateCallback OnAfterCreateInterface[Table]
	OnAfterTableUpdateCallback OnAfterUpdateInterface[Table]
	OnAfterTableDeleteCallback OnAfterDeleteInterface[Table]
	OnAfterTableReadCallback   OnAfterReadInterface[Table]

	Titles           map[*Title]any
	Titles_mapString map[string]*Title

	// insertion point for slice of pointers maps
	OnAfterTitleCreateCallback OnAfterCreateInterface[Title]
	OnAfterTitleUpdateCallback OnAfterUpdateInterface[Title]
	OnAfterTitleDeleteCallback OnAfterDeleteInterface[Title]
	OnAfterTitleReadCallback   OnAfterReadInterface[Title]

	Tones           map[*Tone]any
	Tones_mapString map[string]*Tone

	// insertion point for slice of pointers maps
	OnAfterToneCreateCallback OnAfterCreateInterface[Tone]
	OnAfterToneUpdateCallback OnAfterUpdateInterface[Tone]
	OnAfterToneDeleteCallback OnAfterDeleteInterface[Tone]
	OnAfterToneReadCallback   OnAfterReadInterface[Tone]

	Trees           map[*Tree]any
	Trees_mapString map[string]*Tree

	// insertion point for slice of pointers maps
	OnAfterTreeCreateCallback OnAfterCreateInterface[Tree]
	OnAfterTreeUpdateCallback OnAfterUpdateInterface[Tree]
	OnAfterTreeDeleteCallback OnAfterDeleteInterface[Tree]
	OnAfterTreeReadCallback   OnAfterReadInterface[Tree]

	Views           map[*View]any
	Views_mapString map[string]*View

	// insertion point for slice of pointers maps
	View_RootAsSplitAreas_reverseMap map[*AsSplitArea]*View

	OnAfterViewCreateCallback OnAfterCreateInterface[View]
	OnAfterViewUpdateCallback OnAfterUpdateInterface[View]
	OnAfterViewDeleteCallback OnAfterDeleteInterface[View]
	OnAfterViewReadCallback   OnAfterReadInterface[View]

	Xlsxs           map[*Xlsx]any
	Xlsxs_mapString map[string]*Xlsx

	// insertion point for slice of pointers maps
	OnAfterXlsxCreateCallback OnAfterCreateInterface[Xlsx]
	OnAfterXlsxUpdateCallback OnAfterUpdateInterface[Xlsx]
	OnAfterXlsxDeleteCallback OnAfterDeleteInterface[Xlsx]
	OnAfterXlsxReadCallback   OnAfterReadInterface[Xlsx]

	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

	// store the stage order of each instance in order to
	// preserve this order when serializing them
	// insertion point for order fields declaration
	AsSplitOrder            uint
	AsSplitMap_Staged_Order map[*AsSplit]uint

	AsSplitAreaOrder            uint
	AsSplitAreaMap_Staged_Order map[*AsSplitArea]uint

	ButtonOrder            uint
	ButtonMap_Staged_Order map[*Button]uint

	CursorOrder            uint
	CursorMap_Staged_Order map[*Cursor]uint

	DocOrder            uint
	DocMap_Staged_Order map[*Doc]uint

	FavIconOrder            uint
	FavIconMap_Staged_Order map[*FavIcon]uint

	FormOrder            uint
	FormMap_Staged_Order map[*Form]uint

	LoadOrder            uint
	LoadMap_Staged_Order map[*Load]uint

	LogoOnTheLeftOrder            uint
	LogoOnTheLeftMap_Staged_Order map[*LogoOnTheLeft]uint

	LogoOnTheRightOrder            uint
	LogoOnTheRightMap_Staged_Order map[*LogoOnTheRight]uint

	SliderOrder            uint
	SliderMap_Staged_Order map[*Slider]uint

	SplitOrder            uint
	SplitMap_Staged_Order map[*Split]uint

	SvgOrder            uint
	SvgMap_Staged_Order map[*Svg]uint

	TableOrder            uint
	TableMap_Staged_Order map[*Table]uint

	TitleOrder            uint
	TitleMap_Staged_Order map[*Title]uint

	ToneOrder            uint
	ToneMap_Staged_Order map[*Tone]uint

	TreeOrder            uint
	TreeMap_Staged_Order map[*Tree]uint

	ViewOrder            uint
	ViewMap_Staged_Order map[*View]uint

	XlsxOrder            uint
	XlsxMap_Staged_Order map[*Xlsx]uint

	NamedStructs []*NamedStruct
	// contains filtered or unexported fields
}

Stage enables storage of staged instances swagger:ignore

func NewStage 

func NewStage(name string) (stage *Stage)

func (*Stage) Backup 

func (stage *Stage) Backup(dirPath string)

backup generates backup files in the dirPath

func (*Stage) BackupXL 

func (stage *Stage) BackupXL(dirPath string)

backup generates backup files in the dirPath

func (*Stage) Checkout 

func (stage *Stage) Checkout()

func (*Stage) Commit 

func (stage *Stage) Commit()

func (*Stage) CommitWithSuspendedCallbacks 

func (stage *Stage) CommitWithSuspendedCallbacks()

func (*Stage) ComputeReverseMaps 

func (stage *Stage) ComputeReverseMaps()

ComputeReverseMaps computes the reverse map, for all intances, for all slice to pointers field Its complexity is in O(n)O(p) where p is the number of pointers

func (*Stage) GetDigramsEmbededDir 

func (stage *Stage) GetDigramsEmbededDir() embed.FS

func (*Stage) GetMap_GongStructName_InstancesNb 

func (stage *Stage) GetMap_GongStructName_InstancesNb() map[string]int

func (*Stage) GetModelsEmbededDir 

func (stage *Stage) GetModelsEmbededDir() embed.FS

func (*Stage) GetName 

func (stage *Stage) GetName() string

func (*Stage) GetNamedStructNamesByOrder 

func (stage *Stage) GetNamedStructNamesByOrder(namedStructName string) (res []string)

func (*Stage) GetNamedStructsNames 

func (stage *Stage) GetNamedStructsNames() (res []string)

GetNamedStructs implements models.ProbebStage.

func (*Stage) GetProbeFormStageName 

func (stage *Stage) GetProbeFormStageName() string

func (*Stage) GetProbeSplitStageName 

func (stage *Stage) GetProbeSplitStageName() string

func (*Stage) GetProbeTableStageName 

func (stage *Stage) GetProbeTableStageName() string

func (*Stage) GetProbeTreeSidebarStageName 

func (stage *Stage) GetProbeTreeSidebarStageName() string

func (*Stage) GetType 

func (stage *Stage) GetType() string

func (*Stage) IsStagedAsSplit 

func (stage *Stage) IsStagedAsSplit(assplit *AsSplit) (ok bool)

insertion point for stage per struct

func (*Stage) IsStagedAsSplitArea 

func (stage *Stage) IsStagedAsSplitArea(assplitarea *AsSplitArea) (ok bool)

func (*Stage) IsStagedButton 

func (stage *Stage) IsStagedButton(button *Button) (ok bool)

func (*Stage) IsStagedCursor 

func (stage *Stage) IsStagedCursor(cursor *Cursor) (ok bool)

func (*Stage) IsStagedDoc 

func (stage *Stage) IsStagedDoc(doc *Doc) (ok bool)

func (*Stage) IsStagedFavIcon 

func (stage *Stage) IsStagedFavIcon(favicon *FavIcon) (ok bool)

func (*Stage) IsStagedForm 

func (stage *Stage) IsStagedForm(form *Form) (ok bool)

func (*Stage) IsStagedLoad 

func (stage *Stage) IsStagedLoad(load *Load) (ok bool)

func (*Stage) IsStagedLogoOnTheLeft 

func (stage *Stage) IsStagedLogoOnTheLeft(logoontheleft *LogoOnTheLeft) (ok bool)

func (*Stage) IsStagedLogoOnTheRight 

func (stage *Stage) IsStagedLogoOnTheRight(logoontheright *LogoOnTheRight) (ok bool)

func (*Stage) IsStagedSlider 

func (stage *Stage) IsStagedSlider(slider *Slider) (ok bool)

func (*Stage) IsStagedSplit 

func (stage *Stage) IsStagedSplit(split *Split) (ok bool)

func (*Stage) IsStagedSvg 

func (stage *Stage) IsStagedSvg(svg *Svg) (ok bool)

func (*Stage) IsStagedTable 

func (stage *Stage) IsStagedTable(table *Table) (ok bool)

func (*Stage) IsStagedTitle 

func (stage *Stage) IsStagedTitle(title *Title) (ok bool)

func (*Stage) IsStagedTone 

func (stage *Stage) IsStagedTone(tone *Tone) (ok bool)

func (*Stage) IsStagedTree 

func (stage *Stage) IsStagedTree(tree *Tree) (ok bool)

func (*Stage) IsStagedView 

func (stage *Stage) IsStagedView(view *View) (ok bool)

func (*Stage) IsStagedXlsx 

func (stage *Stage) IsStagedXlsx(xlsx *Xlsx) (ok bool)

func (*Stage) Marshall 

func (stage *Stage) Marshall(file *os.File, modelsPackageName, packageName string)

Marshall marshall the stage content into the file as an instanciation into a stage

func (*Stage) Nil 

func (stage *Stage) Nil()

func (*Stage) Reset 

func (stage *Stage) Reset()

func (*Stage) Restore 

func (stage *Stage) Restore(dirPath string)

Restore resets Stage & BackRepo and restores their content from the restore files in dirPath

func (*Stage) RestoreXL 

func (stage *Stage) RestoreXL(dirPath string)

Restore resets Stage & BackRepo and restores their content from the restore files in dirPath

func (*Stage) SetGeneratesDiff 

func (stage *Stage) SetGeneratesDiff(generatesDiff bool)

func (*Stage) StageBranchAsSplit 

func (stage *Stage) StageBranchAsSplit(assplit *AsSplit)

insertion point for stage branch per struct

func (*Stage) StageBranchAsSplitArea 

func (stage *Stage) StageBranchAsSplitArea(assplitarea *AsSplitArea)

func (*Stage) StageBranchButton 

func (stage *Stage) StageBranchButton(button *Button)

func (*Stage) StageBranchCursor 

func (stage *Stage) StageBranchCursor(cursor *Cursor)

func (*Stage) StageBranchDoc 

func (stage *Stage) StageBranchDoc(doc *Doc)

func (*Stage) StageBranchFavIcon 

func (stage *Stage) StageBranchFavIcon(favicon *FavIcon)

func (*Stage) StageBranchForm 

func (stage *Stage) StageBranchForm(form *Form)

func (*Stage) StageBranchLoad 

func (stage *Stage) StageBranchLoad(load *Load)

func (*Stage) StageBranchLogoOnTheLeft 

func (stage *Stage) StageBranchLogoOnTheLeft(logoontheleft *LogoOnTheLeft)

func (*Stage) StageBranchLogoOnTheRight 

func (stage *Stage) StageBranchLogoOnTheRight(logoontheright *LogoOnTheRight)

func (*Stage) StageBranchSlider 

func (stage *Stage) StageBranchSlider(slider *Slider)

func (*Stage) StageBranchSplit 

func (stage *Stage) StageBranchSplit(split *Split)

func (*Stage) StageBranchSvg 

func (stage *Stage) StageBranchSvg(svg *Svg)

func (*Stage) StageBranchTable 

func (stage *Stage) StageBranchTable(table *Table)

func (*Stage) StageBranchTitle 

func (stage *Stage) StageBranchTitle(title *Title)

func (*Stage) StageBranchTone 

func (stage *Stage) StageBranchTone(tone *Tone)

func (*Stage) StageBranchTree 

func (stage *Stage) StageBranchTree(tree *Tree)

func (*Stage) StageBranchView 

func (stage *Stage) StageBranchView(view *View)

func (*Stage) StageBranchXlsx 

func (stage *Stage) StageBranchXlsx(xlsx *Xlsx)

func (*Stage) Unstage 

func (stage *Stage) Unstage()

func (*Stage) UnstageBranchAsSplit 

func (stage *Stage) UnstageBranchAsSplit(assplit *AsSplit)

insertion point for unstage branch per struct

func (*Stage) UnstageBranchAsSplitArea 

func (stage *Stage) UnstageBranchAsSplitArea(assplitarea *AsSplitArea)

func (*Stage) UnstageBranchButton 

func (stage *Stage) UnstageBranchButton(button *Button)

func (*Stage) UnstageBranchCursor 

func (stage *Stage) UnstageBranchCursor(cursor *Cursor)

func (*Stage) UnstageBranchDoc 

func (stage *Stage) UnstageBranchDoc(doc *Doc)

func (*Stage) UnstageBranchFavIcon 

func (stage *Stage) UnstageBranchFavIcon(favicon *FavIcon)

func (*Stage) UnstageBranchForm 

func (stage *Stage) UnstageBranchForm(form *Form)

func (*Stage) UnstageBranchLoad 

func (stage *Stage) UnstageBranchLoad(load *Load)

func (*Stage) UnstageBranchLogoOnTheLeft 

func (stage *Stage) UnstageBranchLogoOnTheLeft(logoontheleft *LogoOnTheLeft)

func (*Stage) UnstageBranchLogoOnTheRight 

func (stage *Stage) UnstageBranchLogoOnTheRight(logoontheright *LogoOnTheRight)

func (*Stage) UnstageBranchSlider 

func (stage *Stage) UnstageBranchSlider(slider *Slider)

func (*Stage) UnstageBranchSplit 

func (stage *Stage) UnstageBranchSplit(split *Split)

func (*Stage) UnstageBranchSvg 

func (stage *Stage) UnstageBranchSvg(svg *Svg)

func (*Stage) UnstageBranchTable 

func (stage *Stage) UnstageBranchTable(table *Table)

func (*Stage) UnstageBranchTitle 

func (stage *Stage) UnstageBranchTitle(title *Title)

func (*Stage) UnstageBranchTone 

func (stage *Stage) UnstageBranchTone(tone *Tone)

func (*Stage) UnstageBranchTree 

func (stage *Stage) UnstageBranchTree(tree *Tree)

func (*Stage) UnstageBranchView 

func (stage *Stage) UnstageBranchView(view *View)

func (*Stage) UnstageBranchXlsx 

func (stage *Stage) UnstageBranchXlsx(xlsx *Xlsx)

type Svg 

type Svg struct {
	Name      string // name of the stack
	StackName string
	Style     string
}

func CopyBranchSvg 

func CopyBranchSvg(mapOrigCopy map[any]any, svgFrom *Svg) (svgTo *Svg)

func (*Svg) Checkout 

func (svg *Svg) Checkout(stage *Stage) *Svg

Checkout svg to the back repo (if it is already staged)

func (*Svg) Commit 

func (svg *Svg) Commit(stage *Stage) *Svg

commit svg to the back repo (if it is already staged)

func (*Svg) CommitVoid 

func (svg *Svg) CommitVoid(stage *Stage)

func (*Svg) CopyBasicFields 

func (from *Svg) CopyBasicFields(to *Svg)

func (*Svg) GetName 

func (svg *Svg) GetName() (res string)

for satisfaction of GongStruct interface

func (*Svg) Stage 

func (svg *Svg) Stage(stage *Stage) *Svg

Stage puts svg to the model stage

func (*Svg) Unstage 

func (svg *Svg) Unstage(stage *Stage) *Svg

Unstage removes svg off the model stage

func (*Svg) UnstageVoid 

func (svg *Svg) UnstageVoid(stage *Stage)

UnstageVoid removes svg off the model stage

type Svg_WOP 

type Svg_WOP struct {
	Name string

	StackName string

	Style string
}

type Table 

type Table struct {
	Name      string // name of the stack
	StackName string
	TableName string
}

func CopyBranchTable 

func CopyBranchTable(mapOrigCopy map[any]any, tableFrom *Table) (tableTo *Table)

func (*Table) Checkout 

func (table *Table) Checkout(stage *Stage) *Table

Checkout table to the back repo (if it is already staged)

func (*Table) Commit 

func (table *Table) Commit(stage *Stage) *Table

commit table to the back repo (if it is already staged)

func (*Table) CommitVoid 

func (table *Table) CommitVoid(stage *Stage)

func (*Table) CopyBasicFields 

func (from *Table) CopyBasicFields(to *Table)

func (*Table) GetName 

func (table *Table) GetName() (res string)

for satisfaction of GongStruct interface

func (*Table) Stage 

func (table *Table) Stage(stage *Stage) *Table

Stage puts table to the model stage

func (*Table) Unstage 

func (table *Table) Unstage(stage *Stage) *Table

Unstage removes table off the model stage

func (*Table) UnstageVoid 

func (table *Table) UnstageVoid(stage *Stage)

UnstageVoid removes table off the model stage

type Table_WOP 

type Table_WOP struct {
	Name string

	StackName string

	TableName string
}

type Tabulator 

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

Tabulator is an interface for writing to a table strings

type Title 

type Title struct {
	Name string
}

You can configure the browser tab title and favicon dynamically in Angular

func CopyBranchTitle 

func CopyBranchTitle(mapOrigCopy map[any]any, titleFrom *Title) (titleTo *Title)

func (*Title) Checkout 

func (title *Title) Checkout(stage *Stage) *Title

Checkout title to the back repo (if it is already staged)

func (*Title) Commit 

func (title *Title) Commit(stage *Stage) *Title

commit title to the back repo (if it is already staged)

func (*Title) CommitVoid 

func (title *Title) CommitVoid(stage *Stage)

func (*Title) CopyBasicFields 

func (from *Title) CopyBasicFields(to *Title)

func (*Title) GetName 

func (title *Title) GetName() (res string)

for satisfaction of GongStruct interface

func (*Title) Stage 

func (title *Title) Stage(stage *Stage) *Title

Stage puts title to the model stage

func (*Title) Unstage 

func (title *Title) Unstage(stage *Stage) *Title

Unstage removes title off the model stage

func (*Title) UnstageVoid 

func (title *Title) UnstageVoid(stage *Stage)

UnstageVoid removes title off the model stage

type Title_WOP 

type Title_WOP struct {
	Name string
}

type Tone 

type Tone struct {
	Name      string // name of the stack
	StackName string
}

func CopyBranchTone 

func CopyBranchTone(mapOrigCopy map[any]any, toneFrom *Tone) (toneTo *Tone)

func (*Tone) Checkout 

func (tone *Tone) Checkout(stage *Stage) *Tone

Checkout tone to the back repo (if it is already staged)

func (*Tone) Commit 

func (tone *Tone) Commit(stage *Stage) *Tone

commit tone to the back repo (if it is already staged)

func (*Tone) CommitVoid 

func (tone *Tone) CommitVoid(stage *Stage)

func (*Tone) CopyBasicFields 

func (from *Tone) CopyBasicFields(to *Tone)

func (*Tone) GetName 

func (tone *Tone) GetName() (res string)

for satisfaction of GongStruct interface

func (*Tone) Stage 

func (tone *Tone) Stage(stage *Stage) *Tone

Stage puts tone to the model stage

func (*Tone) Unstage 

func (tone *Tone) Unstage(stage *Stage) *Tone

Unstage removes tone off the model stage

func (*Tone) UnstageVoid 

func (tone *Tone) UnstageVoid(stage *Stage)

UnstageVoid removes tone off the model stage

type Tone_WOP 

type Tone_WOP struct {
	Name string

	StackName string
}

type Tree 

type Tree struct {
	Name      string // name of the stack
	StackName string
	TreeName  string
}

func CopyBranchTree 

func CopyBranchTree(mapOrigCopy map[any]any, treeFrom *Tree) (treeTo *Tree)

func (*Tree) Checkout 

func (tree *Tree) Checkout(stage *Stage) *Tree

Checkout tree to the back repo (if it is already staged)

func (*Tree) Commit 

func (tree *Tree) Commit(stage *Stage) *Tree

commit tree to the back repo (if it is already staged)

func (*Tree) CommitVoid 

func (tree *Tree) CommitVoid(stage *Stage)

func (*Tree) CopyBasicFields 

func (from *Tree) CopyBasicFields(to *Tree)

func (*Tree) GetName 

func (tree *Tree) GetName() (res string)

for satisfaction of GongStruct interface

func (*Tree) Stage 

func (tree *Tree) Stage(stage *Stage) *Tree

Stage puts tree to the model stage

func (*Tree) Unstage 

func (tree *Tree) Unstage(stage *Stage) *Tree

Unstage removes tree off the model stage

func (*Tree) UnstageVoid 

func (tree *Tree) UnstageVoid(stage *Stage)

UnstageVoid removes tree off the model stage

type Tree_WOP 

type Tree_WOP struct {
	Name string

	StackName string

	TreeName string
}

type View 

type View struct {
	Name             string
	ShowViewName     bool // by default, a standalone views wont display the
	RootAsSplitAreas []*AsSplitArea
}

func CopyBranchView 

func CopyBranchView(mapOrigCopy map[any]any, viewFrom *View) (viewTo *View)

func (*View) Checkout 

func (view *View) Checkout(stage *Stage) *View

Checkout view to the back repo (if it is already staged)

func (*View) Commit 

func (view *View) Commit(stage *Stage) *View

commit view to the back repo (if it is already staged)

func (*View) CommitVoid 

func (view *View) CommitVoid(stage *Stage)

func (*View) CopyBasicFields 

func (from *View) CopyBasicFields(to *View)

func (*View) GetName 

func (view *View) GetName() (res string)

for satisfaction of GongStruct interface

func (*View) Stage 

func (view *View) Stage(stage *Stage) *View

Stage puts view to the model stage

func (*View) Unstage 

func (view *View) Unstage(stage *Stage) *View

Unstage removes view off the model stage

func (*View) UnstageVoid 

func (view *View) UnstageVoid(stage *Stage)

UnstageVoid removes view off the model stage

type View_WOP 

type View_WOP struct {
	Name string

	ShowViewName bool
}

type Xlsx 

type Xlsx struct {
	Name      string // name of the stack
	StackName string
}

func CopyBranchXlsx 

func CopyBranchXlsx(mapOrigCopy map[any]any, xlsxFrom *Xlsx) (xlsxTo *Xlsx)

func (*Xlsx) Checkout 

func (xlsx *Xlsx) Checkout(stage *Stage) *Xlsx

Checkout xlsx to the back repo (if it is already staged)

func (*Xlsx) Commit 

func (xlsx *Xlsx) Commit(stage *Stage) *Xlsx

commit xlsx to the back repo (if it is already staged)

func (*Xlsx) CommitVoid 

func (xlsx *Xlsx) CommitVoid(stage *Stage)

func (*Xlsx) CopyBasicFields 

func (from *Xlsx) CopyBasicFields(to *Xlsx)

func (*Xlsx) GetName 

func (xlsx *Xlsx) GetName() (res string)

for satisfaction of GongStruct interface

func (*Xlsx) Stage 

func (xlsx *Xlsx) Stage(stage *Stage) *Xlsx

Stage puts xlsx to the model stage

func (*Xlsx) Unstage 

func (xlsx *Xlsx) Unstage(stage *Stage) *Xlsx

Unstage removes xlsx off the model stage

func (*Xlsx) UnstageVoid 

func (xlsx *Xlsx) UnstageVoid(stage *Stage)

UnstageVoid removes xlsx off the model stage

type Xlsx_WOP 

type Xlsx_WOP struct {
	Name string

	StackName string
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.