models

package
v0.0.0-...-246929d Latest Latest
Warning

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

 Go to latest Published: Apr 1, 2026 License: MIT Imports: 34 Imported by: 0

Documentation

Overview

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

generated boilerplate code edit the file for adding other stages

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

generated code - do not edit

generated code - do not edit

Index

Constants

View Source 
const (
	ProbeTreeSidebarSuffix           = ":sidebar of the probe"
	ProbeNavigationTreeSidebarSuffix = ":sidebar of the probe, navigation"
	ProbeTableSuffix                 = ":table of the probe"
	ProbeNotificationTableSuffix     = ":notification table of the probe"
	ProbeFormSuffix                  = ":form of the probe"
	ProbeSplitSuffix                 = ":probe of the probe"
)
View Source 
const (
	GongNavigationModeNormal gongStageNavigationMode = "Normal"
	// when the mode is navigating, each commit backward and forward
	// it is possible to go apply the nbCommitsBackward forward commits
	GongNavigationModeNavigating gongStageNavigationMode = "Navigating"
)
View Source 
const GongIdentifiersDecls = `
	{{Identifier}} := (&models.{{GeneratedStructName}}{Name: {{GeneratedFieldNameValue}}}).Stage(stage)`
View Source 
const GongUnstageStmt = `
	{{Identifier}}.Unstage(stage)`
View Source 
const IdentifiersDeclsWithoutNameInit = `
	{{Identifier}} := (&models.{{GeneratedStructName}}{}).Stage(stage)`

previous version does not hanldle embedded structs (https://github.com/golang/go/issues/9859) simpler version but the name of the instance cannot be human read before the fields initialization

View Source 
const MetaFieldStructInitStatement = `
	{{Identifier}}.{{GeneratedFieldName}} = ` + `{{GeneratedFieldNameValue}}`
View Source 
const NodeOnText = ""

GONGNOTE(NodeOnText) : models.Text - t: This stands for 'text'. This element is used to represent a run of text within a paragraph. The t element will contain the actual string of text as its content. - When parsing these nodes, your code should handle each type of node appropriately based on its name. For example, when you encounter a t node, you might simply extract and store the text content. - In XML, "xml:space="preserve"" instructs the XML processor to preserve whitespace in the content of the element it's applied to. This includes spaces, line breaks, and tabs. - By default, XML processors may ignore or normalize such whitespace. This attribute ensures that the whitespace is kept intact, which can be important for maintaining the correct formatting or interpretation of the data. - For example, in a WordProcessingML document, if "xml:space="preserve"" is applied to a text ("w:t") element, it means the spaces within that text should be preserved when the document is displayed or processed.

View Source 
const NoteOnColumn = ""

GONGNOTE(NoteOnColumn) The "w:tr" node represents a table row within a Word document's XML structure. It is found as a child of the "w:tbl" (table) node in the document.xml file. - This node contains child elements that represent the individual cells ("w:tc") in the row, as well as the row properties ("w:trPr"), which include attributes like height, header status, and more. - The "w:tc" node, on the other hand, represents an individual table cell. It is found as a child of the "w:tr" (table row) node. - This node contains the content of the cell, which can include text, paragraphs, or even other tables. It also contains the cell properties ("w:tcPr"), which include attributes like cell width, vertical alignment, borders, shading, and more. - When parsing "w:tr" and "w:tc" nodes, your code should correctly map the structure of the table, row, and cell, and apply the appropriate properties to each element.

View Source 
const NoteOnDocument = ""

GONGNOTE(NoteOnDocument) In the structure of a .docx file, the word/document.xml file is one of the most crucial components. It contains the main content of the document, including the text and its organization into paragraphs and other structures, as well as references to other components of the document such as images, styles, formatting instructions, etc. 

-

This XML file primarily houses the textual content and its associated XML tags denote various properties of the text such as font size, style, alignment, and more. All these pieces of information are represented using WordProcessingML, a type of XML developed by Microsoft for Word documents. - The document.xml file refers to other files in the .docx structure to help render the final document. For instance, it references styles from the styles.xml file, numbered lists from the numbering.xml file, relationships from the document.xml.rels file, and more. These references help assemble the complete, rendered document that you see when you open a .docx file in a word processor. - There could be multiple document*.xml files in some situations. This is typically seen when a Word document has been split into separate sections, perhaps for editing or collaboration purposes. Each document*.xml file would contain a different section of the overall document.

View Source 
const NoteOnParagraph = ""

GONGNOTE(NoteOnParagraph) The "w:p" node represents a models.Paragraph in a Word document's XML structure. - It is one of the primary building blocks of a document's content within the document.xml file. - Each "w:p" element contains a series of "w:r" (run) elements, which represent sections of text within the paragraph that have consistent formatting. These "w:r" elements, in turn, contain "w:t" elements that hold the actual text content. - The "w:p" element may also contain various other child elements that provide additional information about the paragraph. For example, "w:pPr" specifies paragraph properties like alignment, indentation, and spacing. - As you parse a "w:p" node, you would typically create a new paragraph object in your code, then parse the child nodes to fill in the content and properties of that paragraph.

View Source 
const NoteOnParagraphProperties = ""

GONGNOTE(NoteOnParagraphProperties) models.ParagraphProperties - The "w:pPr" node represents paragraph properties within a Word document's XML structure, and is found within a "w:p" (paragraph) node in the document.xml file. - It contains information about the formatting and layout of a paragraph. This can include properties like text alignment (left, right, centered, or justified), indentation, spacing before or after the paragraph, line spacing, and more. - The "w:pPr" node may also contain a "w:numPr" element for numbered or bulleted lists, and a "w:sectPr" element for section properties (if this paragraph marks the end of a section). - When parsing a "w:pPr" node, your code should use the information it provides to format the paragraph appropriately in your data structure or output format.

View Source 
const NoteOnParagraphStyle = ""

GONGNOTE(NoteOnParagraphStyle) models.ParagraphStyle - The "w:pStyle" element, found within the paragraph properties ("w:pPr") node in a Word document's XML structure, defines the paragraph style for a given paragraph ("w:p"). - The "w:pStyle" element includes an attribute "w:val" that references the ID of the style being applied to the paragraph. This style ID correlates with the styles defined in the styles.xml part of the .docx package. - A style in Word includes a predefined set of formatting instructions. It can control multiple aspects of the paragraph's appearance, including alignment, spacing, font, size, color, and more. - By using styles, a document can maintain a consistent look and feel, and changing the style in one place will automatically update all paragraphs that reference that style. - When parsing a "w:pStyle" node, your code should map the style ID to the corresponding style in the styles.xml file and apply the associated formatting to the paragraph.

View Source 
const NoteOnRunProperties = ""

GONGNOTE(NoteOnRunProperties) The "w:rPr" node represents run properties in a Word document's XML structure. It is found within a "w:r" (run) node in the document.xml file. - This node defines the formatting for a specific run of text within a paragraph. It can include properties like font size, font type, color, highlighting, bolding, italics, underlining, and more. - For example, a "w:rPr" node might contain a "w:sz" element for font size, a "w:color" element for text color, or "w:b" for bold formatting. The presence of elements like "w:b" (bold), "w:i" (italic), and "w:u" (underline) indicate that the formatting is applied, as they are toggled by their presence alone. - When parsing a "w:rPr" node, your code should use the information it provides to apply the appropriate formatting to the text in the run ("w:r") that contains this "w:rPr" node.

View Source 
const NoteOnRune = ""

GONGNOTE(NoteOnRune) for models.Rune - The "w:r" node, known as a run, represents a continuous run of text within a paragraph ("w:p" node) in a Word document's XML structure. It is found within the document.xml file. - Runs are segments of text within a paragraph that share the same formatting. This can include properties like bolding, italics, underlining, color, size, font, and more. The specific formatting is defined in a "w:rPr" (Run Properties) element within the "w:r" node. - A "w:r" node contains one or more "w:t" nodes, which hold the actual text content of the run. It can also contain other types of nodes like "w:br" for a line break or "w:tab" for a tab character. - When parsing a "w:r" node, your code should handle the formatting information provided in the "w:rPr" node (if present) and apply it to the text found within the "w:t" nodes.

View Source 
const NoteOnTable = ""

GONGNOTE(NoteOnTable) The "w:tbl" node represents a table within a Word document's XML structure. It is found in the document.xml file. - This node defines the structure and formatting of a table in the document. It contains child elements that represent the table's properties ("w:tblPr"), grid ("w:tblGrid"), and rows ("w:tr"). - The "w:tblPr" node defines the table's overall properties, such as its width, alignment, borders, and shading. - The "w:tblGrid" node defines the table's grid structure - specifically, the number and width of the columns. - The "w:tr" nodes represent table rows, and each row contains "w:tc" nodes that represent the individual cells within that row. - When parsing a "w:tbl" node, your code should handle the table structure and formatting information it provides to correctly represent the table in your data structure or output format.

View Source 
const NumberInitStatement = `
	{{Identifier}}.{{GeneratedFieldName}} = {{GeneratedFieldNameValue}}`
View Source 
const PointerFieldInitStatement = `
	{{Identifier}}.{{GeneratedFieldName}} = {{GeneratedFieldNameValue}}`
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 CompareGongstructByName 

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

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 Diff 

func Diff[T1, T2 PointerToGongstruct](stage *Stage, a, b T1, fieldName string, oldSlice, newSlice []T2) (ops string)

Diff returns the sequence of operations to transform oldSlice into newSlice. It requires type T to be comparable (e.g., pointers, ints, strings).

func ExtractMiddleUint 

func ExtractMiddleUint(input string) (uint, error)

ExtractMiddleUint takes a formatted string and returns the extracted integer.

func ExtractStyleText 

func ExtractStyleText(styleName string, gongdocxStage *Stage) (res []string)

func GenerateReproducibleUUIDv4 

func GenerateReproducibleUUIDv4(seedStr string, seedInt uint64) string

GenerateReproducibleUUIDv4 creates a deterministic UUIDv4 based on a string and a positive integer.

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 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 gongstruct identifier

func GetGongstructInstancesSet 

func GetGongstructInstancesSet[Type Gongstruct](stage *Stage) *map[*Type]struct{}

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]struct{}

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

func GetGongstructNameFromPointer 

func GetGongstructNameFromPointer(instance GongstructIF) (res string)

func GetNamedStructInstances 

func GetNamedStructInstances[T PointerToGongstruct](set map[T]struct{}, 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 GongstructIF]() (res string)

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

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]struct{}, order map[T]uint) (res []T)

func GetStructInstancesByOrderAuto 

func GetStructInstancesByOrderAuto[T PointerToGongstruct](stage *Stage) (res []T)

GetStructInstancesByOrderAuto returns a slice of generic pointers to gongstructs ordered by their order in the stage.

func GongCleanPointer 

func GongCleanPointer[T PointerToGongstruct](stage *Stage, element *T) (modified bool)

GongCleanPointer sets the pointer to nil if the referenced element is not staged. T must be a pointer to a struct that implements PointerToGongstruct.

func GongCleanSlice 

func GongCleanSlice[T PointerToGongstruct](stage *Stage, slice *[]T) (modified bool)

GongCleanSlice removes unstaged elements from a slice of pointers of type T. T must be a pointer to a struct that implements PointerToGongstruct.

func GongExtractBool 

func GongExtractBool(expr ast.Expr) bool

func GongExtractExpr 

func GongExtractExpr(expr ast.Expr) any

func GongExtractFloat 

func GongExtractFloat(expr ast.Expr) float64

func GongExtractInt 

func GongExtractInt(expr ast.Expr) int

func GongExtractString 

func GongExtractString(expr ast.Expr) string

func GongGetMap 

func GongGetMap[Type GongstructIF](stage *Stage) map[string]Type

GongGetMap returns the map of staged Gonstruct instance by their name Can be usefull if names are unique

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 GongParseAstString 

func GongParseAstString(stage *Stage, blob string, preserveOrder bool) error

GongParseAstString parses the Go source code from a string

func GongUnmarshallEnum 

func GongUnmarshallEnum[T interface{ FromCodeString(string) error }](
	ptr T,
	valueExpr ast.Expr)

GongUnmarshallEnum handles assignment of enum fields (via SelectorExpr or String fallback)

func GongUnmarshallPointer 

func GongUnmarshallPointer[T PointerToGongstruct](
	ptr *T,
	valueExpr ast.Expr,
	identifierMap map[string]GongstructIF)

GongUnmarshallPointer handles assignment of a single pointer field

func GongUnmarshallSliceOfPointers 

func GongUnmarshallSliceOfPointers[T PointerToGongstruct](
	slice *[]T,
	valueExpr ast.Expr,
	identifierMap map[string]GongstructIF) (err error)

GongUnmarshallSliceOfPointers handles append, slices.Delete, and slices.Insert for slice fields

func IntToLetters 

func IntToLetters(number int32) (letters string)

func IsStaged 

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

func IsStagedPointerToGongstruct 

func IsStagedPointerToGongstruct[Type PointerToGongstruct](stage *Stage, instance Type) (ok bool)

func OnAfterUpdateFromFront 

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

OnAfterUpdateFromFront is called after a update from front

func ParseAstEmbeddedFile 

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

ParseAstEmbeddedFile parses the Go source code from an embedded file

func ParseAstFile 

func ParseAstFile(stage *Stage, pathToFile string, preserveOrder bool) error

ParseAstFile Parse pathToFile and stages all instances declared in the file

func ParseAstFileFromAst 

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

ParseAstFileFromAst traverses the AST and stages instances using the Unmarshaller registry

func SerializeExcelizePointerToGongstruct 

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

func SerializeExcelizePointerToGongstruct2 

func SerializeExcelizePointerToGongstruct2[Type PointerToGongstruct](stage *Stage, f *excelize.File, addIDs bool)

func SerializeStage 

func SerializeStage(stage *Stage, filename string)

func SerializeStage2 

func SerializeStage2(stage *Stage, filename string, addIDs bool)

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 SetFieldStringValueFromPointer 

func SetFieldStringValueFromPointer(instance GongstructIF, fieldName string, value GongFieldValue, stage *Stage) error

func SetOrchestratorOnAfterUpdate 

func SetOrchestratorOnAfterUpdate[Type Gongstruct](stage *Stage)

func SortGongstructSetByName 

func SortGongstructSetByName[T PointerToGongstruct](set map[T]struct{}) (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 ToRawStringLiteral 

func ToRawStringLiteral(s string) string

ToRawStringLiteral formats a string into safe Go source code, using backticks to preserve newlines and readability.

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 {
	CreateORMBody(Body *Body)
	CreateORMDocument(Document *Document)
	CreateORMDocx(Docx *Docx)
	CreateORMFile(File *File)
	CreateORMNode(Node *Node)
	CreateORMParagraph(Paragraph *Paragraph)
	CreateORMParagraphProperties(ParagraphProperties *ParagraphProperties)
	CreateORMParagraphStyle(ParagraphStyle *ParagraphStyle)
	CreateORMRune(Rune *Rune)
	CreateORMRuneProperties(RuneProperties *RuneProperties)
	CreateORMTable(Table *Table)
	CreateORMTableColumn(TableColumn *TableColumn)
	CreateORMTableProperties(TableProperties *TableProperties)
	CreateORMTableRow(TableRow *TableRow)
	CreateORMTableStyle(TableStyle *TableStyle)
	CreateORMText(Text *Text)
}

swagger:ignore

type AllModelsStructDeleteInterface 

type AllModelsStructDeleteInterface interface {
	DeleteORMBody(Body *Body)
	DeleteORMDocument(Document *Document)
	DeleteORMDocx(Docx *Docx)
	DeleteORMFile(File *File)
	DeleteORMNode(Node *Node)
	DeleteORMParagraph(Paragraph *Paragraph)
	DeleteORMParagraphProperties(ParagraphProperties *ParagraphProperties)
	DeleteORMParagraphStyle(ParagraphStyle *ParagraphStyle)
	DeleteORMRune(Rune *Rune)
	DeleteORMRuneProperties(RuneProperties *RuneProperties)
	DeleteORMTable(Table *Table)
	DeleteORMTableColumn(TableColumn *TableColumn)
	DeleteORMTableProperties(TableProperties *TableProperties)
	DeleteORMTableRow(TableRow *TableRow)
	DeleteORMTableStyle(TableStyle *TableStyle)
	DeleteORMText(Text *Text)
}

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
	CommitBody(body *Body)
	CheckoutBody(body *Body)
	CommitDocument(document *Document)
	CheckoutDocument(document *Document)
	CommitDocx(docx *Docx)
	CheckoutDocx(docx *Docx)
	CommitFile(file *File)
	CheckoutFile(file *File)
	CommitNode(node *Node)
	CheckoutNode(node *Node)
	CommitParagraph(paragraph *Paragraph)
	CheckoutParagraph(paragraph *Paragraph)
	CommitParagraphProperties(paragraphproperties *ParagraphProperties)
	CheckoutParagraphProperties(paragraphproperties *ParagraphProperties)
	CommitParagraphStyle(paragraphstyle *ParagraphStyle)
	CheckoutParagraphStyle(paragraphstyle *ParagraphStyle)
	CommitRune(rune *Rune)
	CheckoutRune(rune *Rune)
	CommitRuneProperties(runeproperties *RuneProperties)
	CheckoutRuneProperties(runeproperties *RuneProperties)
	CommitTable(table *Table)
	CheckoutTable(table *Table)
	CommitTableColumn(tablecolumn *TableColumn)
	CheckoutTableColumn(tablecolumn *TableColumn)
	CommitTableProperties(tableproperties *TableProperties)
	CheckoutTableProperties(tableproperties *TableProperties)
	CommitTableRow(tablerow *TableRow)
	CheckoutTableRow(tablerow *TableRow)
	CommitTableStyle(tablestyle *TableStyle)
	CheckoutTableStyle(tablestyle *TableStyle)
	CommitText(text *Text)
	CheckoutText(text *Text)
	GetLastCommitFromBackNb() uint
	GetLastPushFromFrontNb() uint
}

type BeforeCommitImplementation 

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

func (*BeforeCommitImplementation) BeforeCommit 

func (c *BeforeCommitImplementation) BeforeCommit(stage *Stage)

type Body 

type Body struct {
	Name       string
	Paragraphs []*Paragraph
	Tables     []*Table

	// for enabling navigation between paragraphs
	LastParagraph *Paragraph
}

func CopyBranchBody 

func CopyBranchBody(mapOrigCopy map[any]any, bodyFrom *Body) (bodyTo *Body)

insertion point for stage branch per struct

func (*Body) Checkout 

func (body *Body) Checkout(stage *Stage) *Body

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

func (*Body) Commit 

func (body *Body) Commit(stage *Stage) *Body

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

func (*Body) CommitVoid 

func (body *Body) CommitVoid(stage *Stage)

func (*Body) CopyBasicFields 

func (from *Body) CopyBasicFields(to *Body)

func (*Body) GetName 

func (body *Body) GetName() (res string)

for satisfaction of GongStruct interface

func (*Body) GongClean 

func (body *Body) GongClean(stage *Stage) (modified bool)

insertion point per named struct Clean garbage collect unstaged instances that are referenced by Body

func (*Body) GongCopy 

func (body *Body) GongCopy() GongstructIF

insertion point per named struct

func (*Body) GongDiff 

func (body *Body) GongDiff(stage *Stage, bodyOther *Body) (diffs []string)

insertion point for diff per struct GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*Body) GongGetFieldHeaders 

func (body *Body) GongGetFieldHeaders() (res []GongFieldHeader)

insertion point for get fields header method

func (*Body) GongGetFieldValue 

func (body *Body) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

insertion point for generic get gongstruct field value

func (*Body) GongGetGongstructName 

func (body *Body) GongGetGongstructName() string

insertion point for generic get gongstruct name

func (*Body) GongGetIdentifier 

func (body *Body) GongGetIdentifier(stage *Stage) string

GongGetIdentifier returns a unique identifier of the instance in the staging area This identifier is composed of the Gongstruct name and the order of the instance in the staging area It is used to identify instances across sessions insertion point per named struct

func (*Body) GongGetOrder 

func (body *Body) GongGetOrder(stage *Stage) uint

GongGetOrder returns the order of the instance in the staging area This order is set at staging time, and reflects the order of creation of the instances in the staging area It is used when rendering slices of GongstructIF to keep a deterministic order which is important for frontends such as web frontends to avoid unnecessary re-renderings insertion point per named struct

func (*Body) GongGetReferenceIdentifier 

func (body *Body) GongGetReferenceIdentifier(stage *Stage) string

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*Body) GongGetReverseFieldOwner 

func (inst *Body) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

insertion point

func (*Body) GongGetReverseFieldOwnerName 

func (inst *Body) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

insertion point

func (*Body) GongGetUUID 

func (body *Body) GongGetUUID(stage *Stage) (uuid string)

insertion point per named struct

func (*Body) GongMarshallAllFields 

func (body *Body) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

insertion point for marshall all fields methods

func (*Body) GongMarshallField 

func (body *Body) GongMarshallField(stage *Stage, fieldName string) (res string)

insertion point for marshall field methods

func (*Body) GongMarshallIdentifier 

func (body *Body) GongMarshallIdentifier(stage *Stage) (decl string)

MarshallIdentifier returns the code to instantiate the instance in a marshalling file insertion point per named struct

func (*Body) GongMarshallUnstaging 

func (body *Body) GongMarshallUnstaging(stage *Stage) (decl string)

insertion point for unstaging

func (*Body) GongReconstructPointersFromInstances 

func (reference *Body) GongReconstructPointersFromInstances(stage *Stage)

insertion point for pointer reconstruction from instances

func (*Body) GongReconstructPointersFromReferences 

func (reference *Body) GongReconstructPointersFromReferences(stage *Stage, instance *Body)

insertion point for pointer reconstruction from references

func (*Body) GongSetFieldValue 

func (body *Body) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

insertion point for generic set gongstruct field value

func (*Body) SetName 

func (body *Body) SetName(name string)

for satisfaction of GongStruct interface

func (*Body) Stage 

func (body *Body) Stage(stage *Stage) *Body

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

func (*Body) StagePreserveOrder 

func (body *Body) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts body to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.BodyOrder - update stage.BodyOrder accordingly

func (*Body) StageVoid 

func (body *Body) StageVoid(stage *Stage)

func (*Body) Unstage 

func (body *Body) Unstage(stage *Stage) *Body

Unstage removes body off the model stage

func (*Body) UnstageVoid 

func (body *Body) UnstageVoid(stage *Stage)

UnstageVoid removes body off the model stage

type BodyUnmarshaller 

type BodyUnmarshaller struct{}

insertion point per named struct

func (*BodyUnmarshaller) Initialize 

func (u *BodyUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*BodyUnmarshaller) UnmarshallField 

func (u *BodyUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type Body_WOP 

type Body_WOP struct {
	Name string
}

insertion point

type Document 

type Document struct {
	Name string
	File *File
	Root *Node
	Body *Body
}

func CopyBranchDocument 

func CopyBranchDocument(mapOrigCopy map[any]any, documentFrom *Document) (documentTo *Document)

func (*Document) Checkout 

func (document *Document) Checkout(stage *Stage) *Document

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

func (*Document) Commit 

func (document *Document) Commit(stage *Stage) *Document

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

func (*Document) CommitVoid 

func (document *Document) CommitVoid(stage *Stage)

func (*Document) CopyBasicFields 

func (from *Document) CopyBasicFields(to *Document)

func (*Document) GetName 

func (document *Document) GetName() (res string)

for satisfaction of GongStruct interface

func (*Document) GongClean 

func (document *Document) GongClean(stage *Stage) (modified bool)

Clean garbage collect unstaged instances that are referenced by Document

func (*Document) GongCopy 

func (document *Document) GongCopy() GongstructIF

func (*Document) GongDiff 

func (document *Document) GongDiff(stage *Stage, documentOther *Document) (diffs []string)

GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*Document) GongGetFieldHeaders 

func (document *Document) GongGetFieldHeaders() (res []GongFieldHeader)

func (*Document) GongGetFieldValue 

func (document *Document) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

func (*Document) GongGetGongstructName 

func (document *Document) GongGetGongstructName() string

func (*Document) GongGetIdentifier 

func (document *Document) GongGetIdentifier(stage *Stage) string

func (*Document) GongGetOrder 

func (document *Document) GongGetOrder(stage *Stage) uint

func (*Document) GongGetReferenceIdentifier 

func (document *Document) GongGetReferenceIdentifier(stage *Stage) string

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*Document) GongGetReverseFieldOwner 

func (inst *Document) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

func (*Document) GongGetReverseFieldOwnerName 

func (inst *Document) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

func (*Document) GongGetUUID 

func (document *Document) GongGetUUID(stage *Stage) (uuid string)

func (*Document) GongMarshallAllFields 

func (document *Document) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

func (*Document) GongMarshallField 

func (document *Document) GongMarshallField(stage *Stage, fieldName string) (res string)

func (*Document) GongMarshallIdentifier 

func (document *Document) GongMarshallIdentifier(stage *Stage) (decl string)

func (*Document) GongMarshallUnstaging 

func (document *Document) GongMarshallUnstaging(stage *Stage) (decl string)

func (*Document) GongReconstructPointersFromInstances 

func (reference *Document) GongReconstructPointersFromInstances(stage *Stage)

func (*Document) GongReconstructPointersFromReferences 

func (reference *Document) GongReconstructPointersFromReferences(stage *Stage, instance *Document)

func (*Document) GongSetFieldValue 

func (document *Document) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

func (*Document) SetName 

func (document *Document) SetName(name string)

for satisfaction of GongStruct interface

func (*Document) Stage 

func (document *Document) Stage(stage *Stage) *Document

Stage puts document to the model stage

func (*Document) StagePreserveOrder 

func (document *Document) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts document to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.DocumentOrder - update stage.DocumentOrder accordingly

func (*Document) StageVoid 

func (document *Document) StageVoid(stage *Stage)

func (*Document) Unstage 

func (document *Document) Unstage(stage *Stage) *Document

Unstage removes document off the model stage

func (*Document) UnstageVoid 

func (document *Document) UnstageVoid(stage *Stage)

UnstageVoid removes document off the model stage

type DocumentUnmarshaller 

type DocumentUnmarshaller struct{}

func (*DocumentUnmarshaller) Initialize 

func (u *DocumentUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*DocumentUnmarshaller) UnmarshallField 

func (u *DocumentUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type Document_WOP 

type Document_WOP struct {
	Name string
}

type Docx 

type Docx struct {
	Name string

	Files []*File

	Document *Document
}

func CopyBranchDocx 

func CopyBranchDocx(mapOrigCopy map[any]any, docxFrom *Docx) (docxTo *Docx)

func NewDocx 

func NewDocx(gongdocx_stage *Stage, path string, embed bool) (docx *Docx)

func (*Docx) Checkout 

func (docx *Docx) Checkout(stage *Stage) *Docx

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

func (*Docx) Commit 

func (docx *Docx) Commit(stage *Stage) *Docx

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

func (*Docx) CommitVoid 

func (docx *Docx) CommitVoid(stage *Stage)

func (*Docx) CopyBasicFields 

func (from *Docx) CopyBasicFields(to *Docx)

func (*Docx) GetName 

func (docx *Docx) GetName() (res string)

for satisfaction of GongStruct interface

func (*Docx) GongClean 

func (docx *Docx) GongClean(stage *Stage) (modified bool)

Clean garbage collect unstaged instances that are referenced by Docx

func (*Docx) GongCopy 

func (docx *Docx) GongCopy() GongstructIF

func (*Docx) GongDiff 

func (docx *Docx) GongDiff(stage *Stage, docxOther *Docx) (diffs []string)

GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*Docx) GongGetFieldHeaders 

func (docx *Docx) GongGetFieldHeaders() (res []GongFieldHeader)

func (*Docx) GongGetFieldValue 

func (docx *Docx) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

func (*Docx) GongGetGongstructName 

func (docx *Docx) GongGetGongstructName() string

func (*Docx) GongGetIdentifier 

func (docx *Docx) GongGetIdentifier(stage *Stage) string

func (*Docx) GongGetOrder 

func (docx *Docx) GongGetOrder(stage *Stage) uint

func (*Docx) GongGetReferenceIdentifier 

func (docx *Docx) GongGetReferenceIdentifier(stage *Stage) string

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*Docx) GongGetReverseFieldOwner 

func (inst *Docx) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

func (*Docx) GongGetReverseFieldOwnerName 

func (inst *Docx) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

func (*Docx) GongGetUUID 

func (docx *Docx) GongGetUUID(stage *Stage) (uuid string)

func (*Docx) GongMarshallAllFields 

func (docx *Docx) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

func (*Docx) GongMarshallField 

func (docx *Docx) GongMarshallField(stage *Stage, fieldName string) (res string)

func (*Docx) GongMarshallIdentifier 

func (docx *Docx) GongMarshallIdentifier(stage *Stage) (decl string)

func (*Docx) GongMarshallUnstaging 

func (docx *Docx) GongMarshallUnstaging(stage *Stage) (decl string)

func (*Docx) GongReconstructPointersFromInstances 

func (reference *Docx) GongReconstructPointersFromInstances(stage *Stage)

func (*Docx) GongReconstructPointersFromReferences 

func (reference *Docx) GongReconstructPointersFromReferences(stage *Stage, instance *Docx)

func (*Docx) GongSetFieldValue 

func (docx *Docx) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

func (*Docx) SetName 

func (docx *Docx) SetName(name string)

for satisfaction of GongStruct interface

func (*Docx) Stage 

func (docx *Docx) Stage(stage *Stage) *Docx

Stage puts docx to the model stage

func (*Docx) StagePreserveOrder 

func (docx *Docx) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts docx to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.DocxOrder - update stage.DocxOrder accordingly

func (*Docx) StageVoid 

func (docx *Docx) StageVoid(stage *Stage)

func (*Docx) Unstage 

func (docx *Docx) Unstage(stage *Stage) *Docx

Unstage removes docx off the model stage

func (*Docx) UnstageVoid 

func (docx *Docx) UnstageVoid(stage *Stage)

UnstageVoid removes docx off the model stage

type DocxUnmarshaller 

type DocxUnmarshaller struct{}

func (*DocxUnmarshaller) Initialize 

func (u *DocxUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*DocxUnmarshaller) UnmarshallField 

func (u *DocxUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type Docx_WOP 

type Docx_WOP struct {
	Name 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 File 

type File struct {
	Name string
}

file embedded in a docx

func CopyBranchFile 

func CopyBranchFile(mapOrigCopy map[any]any, fileFrom *File) (fileTo *File)

func (*File) Checkout 

func (file *File) Checkout(stage *Stage) *File

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

func (*File) Commit 

func (file *File) Commit(stage *Stage) *File

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

func (*File) CommitVoid 

func (file *File) CommitVoid(stage *Stage)

func (*File) CopyBasicFields 

func (from *File) CopyBasicFields(to *File)

func (*File) GetName 

func (file *File) GetName() (res string)

for satisfaction of GongStruct interface

func (*File) GongClean 

func (file *File) GongClean(stage *Stage) (modified bool)

Clean garbage collect unstaged instances that are referenced by File

func (*File) GongCopy 

func (file *File) GongCopy() GongstructIF

func (*File) GongDiff 

func (file *File) GongDiff(stage *Stage, fileOther *File) (diffs []string)

GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*File) GongGetFieldHeaders 

func (file *File) GongGetFieldHeaders() (res []GongFieldHeader)

func (*File) GongGetFieldValue 

func (file *File) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

func (*File) GongGetGongstructName 

func (file *File) GongGetGongstructName() string

func (*File) GongGetIdentifier 

func (file *File) GongGetIdentifier(stage *Stage) string

func (*File) GongGetOrder 

func (file *File) GongGetOrder(stage *Stage) uint

func (*File) GongGetReferenceIdentifier 

func (file *File) GongGetReferenceIdentifier(stage *Stage) string

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*File) GongGetReverseFieldOwner 

func (inst *File) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

func (*File) GongGetReverseFieldOwnerName 

func (inst *File) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

func (*File) GongGetUUID 

func (file *File) GongGetUUID(stage *Stage) (uuid string)

func (*File) GongMarshallAllFields 

func (file *File) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

func (*File) GongMarshallField 

func (file *File) GongMarshallField(stage *Stage, fieldName string) (res string)

func (*File) GongMarshallIdentifier 

func (file *File) GongMarshallIdentifier(stage *Stage) (decl string)

func (*File) GongMarshallUnstaging 

func (file *File) GongMarshallUnstaging(stage *Stage) (decl string)

func (*File) GongReconstructPointersFromInstances 

func (reference *File) GongReconstructPointersFromInstances(stage *Stage)

func (*File) GongReconstructPointersFromReferences 

func (reference *File) GongReconstructPointersFromReferences(stage *Stage, instance *File)

func (*File) GongSetFieldValue 

func (file *File) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

func (*File) SetName 

func (file *File) SetName(name string)

for satisfaction of GongStruct interface

func (*File) Stage 

func (file *File) Stage(stage *Stage) *File

Stage puts file to the model stage

func (*File) StagePreserveOrder 

func (file *File) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts file to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.FileOrder - update stage.FileOrder accordingly

func (*File) StageVoid 

func (file *File) StageVoid(stage *Stage)

func (*File) Unstage 

func (file *File) Unstage(stage *Stage) *File

Unstage removes file off the model stage

func (*File) UnstageVoid 

func (file *File) UnstageVoid(stage *Stage)

UnstageVoid removes file off the model stage

type FileUnmarshaller 

type FileUnmarshaller struct{}

func (*FileUnmarshaller) Initialize 

func (u *FileUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*FileUnmarshaller) UnmarshallField 

func (u *FileUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type File_WOP 

type File_WOP struct {
	Name 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 GongFieldHeader 

type GongFieldHeader struct {
	Name string
	GongFieldValueType
	TargetGongstructName string
}

func GetFieldsFromPointer 

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

GetFieldsFromPointer return the array of the fields

type GongFieldValue 

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

func GetFieldStringValueFromPointer 

func GetFieldStringValueFromPointer(instance GongstructIF, fieldName string, stage *Stage) (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"
	GongFieldValueTypeIntDuration     GongFieldValueType = "GongFieldValueTypeIntDuration"
	GongFieldValueTypeFloat           GongFieldValueType = "GongFieldValueTypeFloat"
	GongFieldValueTypeBool            GongFieldValueType = "GongFieldValueTypeBool"
	GongFieldValueTypeString          GongFieldValueType = "GongFieldValueTypeString"
	GongFieldValueTypeDate            GongFieldValueType = "GongFieldValueTypeDate"
	GongFieldValueTypeBasicKind       GongFieldValueType = "GongFieldValueTypeBasicKind"
	GongFieldValueTypePointer         GongFieldValueType = "GongFieldValueTypePointer"
	GongFieldValueTypeSliceOfPointers GongFieldValueType = "GongFieldValueTypeSliceOfPointers"
)

type GongMarshallingMode 

type GongMarshallingMode string
const (
	// the whole stage is generated at each marshall. This is the default
	GongMarshallingNormal GongMarshallingMode = "GongMarshallingNormal"

	// only the last commit is append to the marshall file
	GongMarshallingAppendCommit GongMarshallingMode = "GongMarshallingAppendCommit"
)

type GongNodeIF 

type GongNodeIF interface {
}

type GongStructInterface 

type GongStructInterface interface {
	GetName() (res string)
	// GetID() (res int)
	// GetFields() (res []string)
	// GetFieldStringValue(fieldName string) (res string)
	GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error
	GongGetGongstructName() string
}

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

type Gong__MouseEvent 

type Gong__MouseEvent struct {
	ShiftKey bool
}

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 GongstructIF 

type GongstructIF interface {
	GetName() string
	SetName(string)
	CommitVoid(*Stage)
	StageVoid(*Stage)
	UnstageVoid(stage *Stage)
	GongGetFieldHeaders() []GongFieldHeader
	GongClean(stage *Stage) (modified bool)
	GongGetFieldValue(fieldName string, stage *Stage) GongFieldValue
	GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error
	GongGetGongstructName() string
	GongGetOrder(stage *Stage) uint
	GongGetReferenceIdentifier(stage *Stage) string
	GongGetIdentifier(stage *Stage) string
	GongCopy() GongstructIF
	GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) string
	GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) GongstructIF
	GongGetUUID(stage *Stage) string
}

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 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 ModelUnmarshaller 

type ModelUnmarshaller interface {
	// Initialize creates the struct, stages it, and returns the pointer as 'any'
	Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

	// UnmarshallField sets a field's value based on the AST expression
	UnmarshallField(stage *Stage, instance GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error
}

ModelUnmarshaller abstracts the logic for setting fields on a staged instance

type NamedStruct 

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

func (*NamedStruct) GetName 

func (namedStruct *NamedStruct) GetName() string

type Node 

type Node struct {
	Name string

	Nodes []*Node
}

func CopyBranchNode 

func CopyBranchNode(mapOrigCopy map[any]any, nodeFrom *Node) (nodeTo *Node)

func (*Node) Checkout 

func (node *Node) Checkout(stage *Stage) *Node

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

func (*Node) Commit 

func (node *Node) Commit(stage *Stage) *Node

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

func (*Node) CommitVoid 

func (node *Node) CommitVoid(stage *Stage)

func (*Node) CopyBasicFields 

func (from *Node) CopyBasicFields(to *Node)

func (*Node) GetName 

func (node *Node) GetName() (res string)

for satisfaction of GongStruct interface

func (*Node) GongClean 

func (node *Node) GongClean(stage *Stage) (modified bool)

Clean garbage collect unstaged instances that are referenced by Node

func (*Node) GongCopy 

func (node *Node) GongCopy() GongstructIF

func (*Node) GongDiff 

func (node *Node) GongDiff(stage *Stage, nodeOther *Node) (diffs []string)

GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*Node) GongGetFieldHeaders 

func (node *Node) GongGetFieldHeaders() (res []GongFieldHeader)

func (*Node) GongGetFieldValue 

func (node *Node) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

func (*Node) GongGetGongstructName 

func (node *Node) GongGetGongstructName() string

func (*Node) GongGetIdentifier 

func (node *Node) GongGetIdentifier(stage *Stage) string

func (*Node) GongGetOrder 

func (node *Node) GongGetOrder(stage *Stage) uint

func (*Node) GongGetReferenceIdentifier 

func (node *Node) GongGetReferenceIdentifier(stage *Stage) string

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*Node) GongGetReverseFieldOwner 

func (inst *Node) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

func (*Node) GongGetReverseFieldOwnerName 

func (inst *Node) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

func (*Node) GongGetUUID 

func (node *Node) GongGetUUID(stage *Stage) (uuid string)

func (*Node) GongMarshallAllFields 

func (node *Node) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

func (*Node) GongMarshallField 

func (node *Node) GongMarshallField(stage *Stage, fieldName string) (res string)

func (*Node) GongMarshallIdentifier 

func (node *Node) GongMarshallIdentifier(stage *Stage) (decl string)

func (*Node) GongMarshallUnstaging 

func (node *Node) GongMarshallUnstaging(stage *Stage) (decl string)

func (*Node) GongReconstructPointersFromInstances 

func (reference *Node) GongReconstructPointersFromInstances(stage *Stage)

func (*Node) GongReconstructPointersFromReferences 

func (reference *Node) GongReconstructPointersFromReferences(stage *Stage, instance *Node)

func (*Node) GongSetFieldValue 

func (node *Node) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

func (*Node) SetName 

func (node *Node) SetName(name string)

for satisfaction of GongStruct interface

func (*Node) Stage 

func (node *Node) Stage(stage *Stage) *Node

Stage puts node to the model stage

func (*Node) StagePreserveOrder 

func (node *Node) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts node to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.NodeOrder - update stage.NodeOrder accordingly

func (*Node) StageVoid 

func (node *Node) StageVoid(stage *Stage)

func (*Node) Unstage 

func (node *Node) Unstage(stage *Stage) *Node

Unstage removes node off the model stage

func (*Node) UnstageVoid 

func (node *Node) UnstageVoid(stage *Stage)

UnstageVoid removes node off the model stage

type NodeUnmarshaller 

type NodeUnmarshaller struct{}

func (*NodeUnmarshaller) Initialize 

func (u *NodeUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*NodeUnmarshaller) UnmarshallField 

func (u *NodeUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type Node_ 

type Node_ struct {
	XMLName xml.Name
	Attrs   []xml.Attr `xml:"-"`
	Content []byte     `xml:",innerxml"`
	Nodes   []Node_    `xml:",any"`
}

Node_ is

func (*Node_) UnmarshalXML 

func (n *Node_) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

UnmarshalXML is

type Node_WOP 

type Node_WOP struct {
	Name string
}

type Numbering 

type Numbering struct {
	XMLName     xml.Name `xml:"numbering"`
	Text        string   `xml:",chardata"`
	Wpc         string   `xml:"wpc,attr"`
	Cx          string   `xml:"cx,attr"`
	Cx1         string   `xml:"cx1,attr"`
	Mc          string   `xml:"mc,attr"`
	O           string   `xml:"o,attr"`
	R           string   `xml:"r,attr"`
	M           string   `xml:"m,attr"`
	V           string   `xml:"v,attr"`
	Wp14        string   `xml:"wp14,attr"`
	Wp          string   `xml:"wp,attr"`
	W10         string   `xml:"w10,attr"`
	W           string   `xml:"w,attr"`
	W14         string   `xml:"w14,attr"`
	W15         string   `xml:"w15,attr"`
	W16se       string   `xml:"w16se,attr"`
	Wpg         string   `xml:"wpg,attr"`
	Wpi         string   `xml:"wpi,attr"`
	Wne         string   `xml:"wne,attr"`
	Wps         string   `xml:"wps,attr"`
	Ignorable   string   `xml:"Ignorable,attr"`
	AbstractNum []struct {
		Text                       string         `xml:",chardata"`
		AbstractNumID              string         `xml:"abstractNumId,attr"`
		RestartNumberingAfterBreak string         `xml:"restartNumberingAfterBreak,attr"`
		Nsid                       TextVal        `xml:"nsid"`
		MultiLevelType             TextVal        `xml:"multiLevelType"`
		Tmpl                       TextVal        `xml:"tmpl"`
		Lvl                        []NumberingLvl `xml:"lvl"`
	} `xml:"abstractNum"`
	Num []struct {
		Text          string  `xml:",chardata"`
		NumID         string  `xml:"numId,attr"`
		AbstractNumID TextVal `xml:"abstractNumId"`
	} `xml:"num"`
}

Numbering is

type NumberingLvl 

type NumberingLvl struct {
	Text      string  `xml:",chardata"`
	Ilvl      string  `xml:"ilvl,attr"`
	Tplc      string  `xml:"tplc,attr"`
	Tentative string  `xml:"tentative,attr"`
	Start     TextVal `xml:"start"`
	NumFmt    TextVal `xml:"numFmt"`
	LvlText   TextVal `xml:"lvlText"`
	LvlJc     TextVal `xml:"lvlJc"`
	PPr       struct {
		Text string `xml:",chardata"`
		Ind  struct {
			Text    string `xml:",chardata"`
			Left    string `xml:"left,attr"`
			Hanging string `xml:"hanging,attr"`
		} `xml:"ind"`
	} `xml:"pPr"`
	RPr struct {
		Text string `xml:",chardata"`
		U    struct {
			Text string `xml:",chardata"`
			Val  string `xml:"val,attr"`
		} `xml:"u"`
		RFonts struct {
			Text string `xml:",chardata"`
			Hint string `xml:"hint,attr"`
		} `xml:"rFonts"`
	} `xml:"rPr"`
}

NumberingLvl is

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 Paragraph 

type Paragraph struct {
	Name                string
	Content             string
	Node                *Node
	ParagraphProperties *ParagraphProperties
	Runes               []*Rune

	CollatedText string // collated text of all runes

	// navigation
	Next                 *Paragraph
	Previous             *Paragraph
	EnclosingBody        *Body
	EnclosingTableColumn *TableColumn
}

func CopyBranchParagraph 

func CopyBranchParagraph(mapOrigCopy map[any]any, paragraphFrom *Paragraph) (paragraphTo *Paragraph)

func (*Paragraph) Checkout 

func (paragraph *Paragraph) Checkout(stage *Stage) *Paragraph

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

func (*Paragraph) Commit 

func (paragraph *Paragraph) Commit(stage *Stage) *Paragraph

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

func (*Paragraph) CommitVoid 

func (paragraph *Paragraph) CommitVoid(stage *Stage)

func (*Paragraph) CopyBasicFields 

func (from *Paragraph) CopyBasicFields(to *Paragraph)

func (*Paragraph) GetName 

func (paragraph *Paragraph) GetName() (res string)

for satisfaction of GongStruct interface

func (*Paragraph) GongClean 

func (paragraph *Paragraph) GongClean(stage *Stage) (modified bool)

Clean garbage collect unstaged instances that are referenced by Paragraph

func (*Paragraph) GongCopy 

func (paragraph *Paragraph) GongCopy() GongstructIF

func (*Paragraph) GongDiff 

func (paragraph *Paragraph) GongDiff(stage *Stage, paragraphOther *Paragraph) (diffs []string)

GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*Paragraph) GongGetFieldHeaders 

func (paragraph *Paragraph) GongGetFieldHeaders() (res []GongFieldHeader)

func (*Paragraph) GongGetFieldValue 

func (paragraph *Paragraph) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

func (*Paragraph) GongGetGongstructName 

func (paragraph *Paragraph) GongGetGongstructName() string

func (*Paragraph) GongGetIdentifier 

func (paragraph *Paragraph) GongGetIdentifier(stage *Stage) string

func (*Paragraph) GongGetOrder 

func (paragraph *Paragraph) GongGetOrder(stage *Stage) uint

func (*Paragraph) GongGetReferenceIdentifier 

func (paragraph *Paragraph) GongGetReferenceIdentifier(stage *Stage) string

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*Paragraph) GongGetReverseFieldOwner 

func (inst *Paragraph) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

func (*Paragraph) GongGetReverseFieldOwnerName 

func (inst *Paragraph) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

func (*Paragraph) GongGetUUID 

func (paragraph *Paragraph) GongGetUUID(stage *Stage) (uuid string)

func (*Paragraph) GongMarshallAllFields 

func (paragraph *Paragraph) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

func (*Paragraph) GongMarshallField 

func (paragraph *Paragraph) GongMarshallField(stage *Stage, fieldName string) (res string)

func (*Paragraph) GongMarshallIdentifier 

func (paragraph *Paragraph) GongMarshallIdentifier(stage *Stage) (decl string)

func (*Paragraph) GongMarshallUnstaging 

func (paragraph *Paragraph) GongMarshallUnstaging(stage *Stage) (decl string)

func (*Paragraph) GongReconstructPointersFromInstances 

func (reference *Paragraph) GongReconstructPointersFromInstances(stage *Stage)

func (*Paragraph) GongReconstructPointersFromReferences 

func (reference *Paragraph) GongReconstructPointersFromReferences(stage *Stage, instance *Paragraph)

func (*Paragraph) GongSetFieldValue 

func (paragraph *Paragraph) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

func (*Paragraph) SetName 

func (paragraph *Paragraph) SetName(name string)

for satisfaction of GongStruct interface

func (*Paragraph) Stage 

func (paragraph *Paragraph) Stage(stage *Stage) *Paragraph

Stage puts paragraph to the model stage

func (*Paragraph) StagePreserveOrder 

func (paragraph *Paragraph) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts paragraph to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.ParagraphOrder - update stage.ParagraphOrder accordingly

func (*Paragraph) StageVoid 

func (paragraph *Paragraph) StageVoid(stage *Stage)

func (*Paragraph) Unstage 

func (paragraph *Paragraph) Unstage(stage *Stage) *Paragraph

Unstage removes paragraph off the model stage

func (*Paragraph) UnstageVoid 

func (paragraph *Paragraph) UnstageVoid(stage *Stage)

UnstageVoid removes paragraph off the model stage

type ParagraphProperties 

type ParagraphProperties struct {
	Name    string
	Content string

	ParagraphStyle *ParagraphStyle

	Node *Node
}

func CopyBranchParagraphProperties 

func CopyBranchParagraphProperties(mapOrigCopy map[any]any, paragraphpropertiesFrom *ParagraphProperties) (paragraphpropertiesTo *ParagraphProperties)

func (*ParagraphProperties) Checkout 

func (paragraphproperties *ParagraphProperties) Checkout(stage *Stage) *ParagraphProperties

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

func (*ParagraphProperties) Commit 

func (paragraphproperties *ParagraphProperties) Commit(stage *Stage) *ParagraphProperties

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

func (*ParagraphProperties) CommitVoid 

func (paragraphproperties *ParagraphProperties) CommitVoid(stage *Stage)

func (*ParagraphProperties) CopyBasicFields 

func (from *ParagraphProperties) CopyBasicFields(to *ParagraphProperties)

func (*ParagraphProperties) GetName 

func (paragraphproperties *ParagraphProperties) GetName() (res string)

for satisfaction of GongStruct interface

func (*ParagraphProperties) GongClean 

func (paragraphproperties *ParagraphProperties) GongClean(stage *Stage) (modified bool)

Clean garbage collect unstaged instances that are referenced by ParagraphProperties

func (*ParagraphProperties) GongCopy 

func (paragraphproperties *ParagraphProperties) GongCopy() GongstructIF

func (*ParagraphProperties) GongDiff 

func (paragraphproperties *ParagraphProperties) GongDiff(stage *Stage, paragraphpropertiesOther *ParagraphProperties) (diffs []string)

GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*ParagraphProperties) GongGetFieldHeaders 

func (paragraphproperties *ParagraphProperties) GongGetFieldHeaders() (res []GongFieldHeader)

func (*ParagraphProperties) GongGetFieldValue 

func (paragraphproperties *ParagraphProperties) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

func (*ParagraphProperties) GongGetGongstructName 

func (paragraphproperties *ParagraphProperties) GongGetGongstructName() string

func (*ParagraphProperties) GongGetIdentifier 

func (paragraphproperties *ParagraphProperties) GongGetIdentifier(stage *Stage) string

func (*ParagraphProperties) GongGetOrder 

func (paragraphproperties *ParagraphProperties) GongGetOrder(stage *Stage) uint

func (*ParagraphProperties) GongGetReferenceIdentifier 

func (paragraphproperties *ParagraphProperties) GongGetReferenceIdentifier(stage *Stage) string

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*ParagraphProperties) GongGetReverseFieldOwner 

func (inst *ParagraphProperties) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

func (*ParagraphProperties) GongGetReverseFieldOwnerName 

func (inst *ParagraphProperties) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

func (*ParagraphProperties) GongGetUUID 

func (paragraphproperties *ParagraphProperties) GongGetUUID(stage *Stage) (uuid string)

func (*ParagraphProperties) GongMarshallAllFields 

func (paragraphproperties *ParagraphProperties) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

func (*ParagraphProperties) GongMarshallField 

func (paragraphproperties *ParagraphProperties) GongMarshallField(stage *Stage, fieldName string) (res string)

func (*ParagraphProperties) GongMarshallIdentifier 

func (paragraphproperties *ParagraphProperties) GongMarshallIdentifier(stage *Stage) (decl string)

func (*ParagraphProperties) GongMarshallUnstaging 

func (paragraphproperties *ParagraphProperties) GongMarshallUnstaging(stage *Stage) (decl string)

func (*ParagraphProperties) GongReconstructPointersFromInstances 

func (reference *ParagraphProperties) GongReconstructPointersFromInstances(stage *Stage)

func (*ParagraphProperties) GongReconstructPointersFromReferences 

func (reference *ParagraphProperties) GongReconstructPointersFromReferences(stage *Stage, instance *ParagraphProperties)

func (*ParagraphProperties) GongSetFieldValue 

func (paragraphproperties *ParagraphProperties) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

func (*ParagraphProperties) SetName 

func (paragraphproperties *ParagraphProperties) SetName(name string)

for satisfaction of GongStruct interface

func (*ParagraphProperties) Stage 

func (paragraphproperties *ParagraphProperties) Stage(stage *Stage) *ParagraphProperties

Stage puts paragraphproperties to the model stage

func (*ParagraphProperties) StagePreserveOrder 

func (paragraphproperties *ParagraphProperties) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts paragraphproperties to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.ParagraphPropertiesOrder - update stage.ParagraphPropertiesOrder accordingly

func (*ParagraphProperties) StageVoid 

func (paragraphproperties *ParagraphProperties) StageVoid(stage *Stage)

func (*ParagraphProperties) Unstage 

func (paragraphproperties *ParagraphProperties) Unstage(stage *Stage) *ParagraphProperties

Unstage removes paragraphproperties off the model stage

func (*ParagraphProperties) UnstageVoid 

func (paragraphproperties *ParagraphProperties) UnstageVoid(stage *Stage)

UnstageVoid removes paragraphproperties off the model stage

type ParagraphPropertiesUnmarshaller 

type ParagraphPropertiesUnmarshaller struct{}

func (*ParagraphPropertiesUnmarshaller) Initialize 

func (u *ParagraphPropertiesUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*ParagraphPropertiesUnmarshaller) UnmarshallField 

func (u *ParagraphPropertiesUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type ParagraphProperties_WOP 

type ParagraphProperties_WOP struct {
	Name string

	Content string
}

type ParagraphStyle 

type ParagraphStyle struct {
	Name    string
	Node    *Node
	Content string

	// 	The "w:val" attribute in WordProcessingML stores a value for a specific
	// property. For "w:pStyle", "w:val" holds the ID of the paragraph style applied
	// to the current paragraph.
	//
	// "w" stands for the Word namespace, a standard in WordProcessingML to avoid
	// naming conflicts with other XML languages. "val" is likely short for "value,"
	// indicating this attribute holds the value of the "w:pStyle" element.
	//
	// Thus, "w:val" holds a value in the Word namespace. Its specific meaning can
	// vary depending on context, but it often holds an ID linking to other data or
	// formatting in the .docx package.
	ValAttr string
}

func CopyBranchParagraphStyle 

func CopyBranchParagraphStyle(mapOrigCopy map[any]any, paragraphstyleFrom *ParagraphStyle) (paragraphstyleTo *ParagraphStyle)

func (*ParagraphStyle) Checkout 

func (paragraphstyle *ParagraphStyle) Checkout(stage *Stage) *ParagraphStyle

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

func (*ParagraphStyle) Commit 

func (paragraphstyle *ParagraphStyle) Commit(stage *Stage) *ParagraphStyle

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

func (*ParagraphStyle) CommitVoid 

func (paragraphstyle *ParagraphStyle) CommitVoid(stage *Stage)

func (*ParagraphStyle) CopyBasicFields 

func (from *ParagraphStyle) CopyBasicFields(to *ParagraphStyle)

func (*ParagraphStyle) GetName 

func (paragraphstyle *ParagraphStyle) GetName() (res string)

for satisfaction of GongStruct interface

func (*ParagraphStyle) GongClean 

func (paragraphstyle *ParagraphStyle) GongClean(stage *Stage) (modified bool)

Clean garbage collect unstaged instances that are referenced by ParagraphStyle

func (*ParagraphStyle) GongCopy 

func (paragraphstyle *ParagraphStyle) GongCopy() GongstructIF

func (*ParagraphStyle) GongDiff 

func (paragraphstyle *ParagraphStyle) GongDiff(stage *Stage, paragraphstyleOther *ParagraphStyle) (diffs []string)

GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*ParagraphStyle) GongGetFieldHeaders 

func (paragraphstyle *ParagraphStyle) GongGetFieldHeaders() (res []GongFieldHeader)

func (*ParagraphStyle) GongGetFieldValue 

func (paragraphstyle *ParagraphStyle) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

func (*ParagraphStyle) GongGetGongstructName 

func (paragraphstyle *ParagraphStyle) GongGetGongstructName() string

func (*ParagraphStyle) GongGetIdentifier 

func (paragraphstyle *ParagraphStyle) GongGetIdentifier(stage *Stage) string

func (*ParagraphStyle) GongGetOrder 

func (paragraphstyle *ParagraphStyle) GongGetOrder(stage *Stage) uint

func (*ParagraphStyle) GongGetReferenceIdentifier 

func (paragraphstyle *ParagraphStyle) GongGetReferenceIdentifier(stage *Stage) string

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*ParagraphStyle) GongGetReverseFieldOwner 

func (inst *ParagraphStyle) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

func (*ParagraphStyle) GongGetReverseFieldOwnerName 

func (inst *ParagraphStyle) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

func (*ParagraphStyle) GongGetUUID 

func (paragraphstyle *ParagraphStyle) GongGetUUID(stage *Stage) (uuid string)

func (*ParagraphStyle) GongMarshallAllFields 

func (paragraphstyle *ParagraphStyle) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

func (*ParagraphStyle) GongMarshallField 

func (paragraphstyle *ParagraphStyle) GongMarshallField(stage *Stage, fieldName string) (res string)

func (*ParagraphStyle) GongMarshallIdentifier 

func (paragraphstyle *ParagraphStyle) GongMarshallIdentifier(stage *Stage) (decl string)

func (*ParagraphStyle) GongMarshallUnstaging 

func (paragraphstyle *ParagraphStyle) GongMarshallUnstaging(stage *Stage) (decl string)

func (*ParagraphStyle) GongReconstructPointersFromInstances 

func (reference *ParagraphStyle) GongReconstructPointersFromInstances(stage *Stage)

func (*ParagraphStyle) GongReconstructPointersFromReferences 

func (reference *ParagraphStyle) GongReconstructPointersFromReferences(stage *Stage, instance *ParagraphStyle)

func (*ParagraphStyle) GongSetFieldValue 

func (paragraphstyle *ParagraphStyle) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

func (*ParagraphStyle) SetName 

func (paragraphstyle *ParagraphStyle) SetName(name string)

for satisfaction of GongStruct interface

func (*ParagraphStyle) Stage 

func (paragraphstyle *ParagraphStyle) Stage(stage *Stage) *ParagraphStyle

Stage puts paragraphstyle to the model stage

func (*ParagraphStyle) StagePreserveOrder 

func (paragraphstyle *ParagraphStyle) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts paragraphstyle to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.ParagraphStyleOrder - update stage.ParagraphStyleOrder accordingly

func (*ParagraphStyle) StageVoid 

func (paragraphstyle *ParagraphStyle) StageVoid(stage *Stage)

func (*ParagraphStyle) Unstage 

func (paragraphstyle *ParagraphStyle) Unstage(stage *Stage) *ParagraphStyle

Unstage removes paragraphstyle off the model stage

func (*ParagraphStyle) UnstageVoid 

func (paragraphstyle *ParagraphStyle) UnstageVoid(stage *Stage)

UnstageVoid removes paragraphstyle off the model stage

type ParagraphStyleUnmarshaller 

type ParagraphStyleUnmarshaller struct{}

func (*ParagraphStyleUnmarshaller) Initialize 

func (u *ParagraphStyleUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*ParagraphStyleUnmarshaller) UnmarshallField 

func (u *ParagraphStyleUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type ParagraphStyle_WOP 

type ParagraphStyle_WOP struct {
	Name string

	Content string

	ValAttr string
}

type ParagraphUnmarshaller 

type ParagraphUnmarshaller struct{}

func (*ParagraphUnmarshaller) Initialize 

func (u *ParagraphUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*ParagraphUnmarshaller) UnmarshallField 

func (u *ParagraphUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type Paragraph_WOP 

type Paragraph_WOP struct {
	Name string

	Content string

	CollatedText string
}

type PointerToGongstruct 

type PointerToGongstruct interface {
	GongstructIF
	comparable
}

type PointerToGongstructEnumIntField 

type PointerToGongstructEnumIntField interface {
	//insertion point for pointers to enum int types
	FromCodeString(input string) (err error)
}

type PointerToGongstructEnumStringField 

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

type ProbeIF 

type ProbeIF interface {
	Refresh()
	GetFormStage() *form.Stage
	GetDataEditor() *split.AsSplit
	GetDiagramEditor() *split.AsSplitArea
	FillUpFormFromGongstruct(instance any, formName string)
	AddNotification(date time.Time, message string)
	CommitNotificationTable()
	ResetNotifications()
	SetMaxElementsNbPerGongStructNode(nb int)
	GetMaxElementsNbPerGongStructNode() int
	AddCommitNavigationNode(appendChildrenNodeFunc func(GongNodeIF))
	SetCommitMode(bool)
	RefreshNavigationTree() // to be called in delta mode, when the navigation tree shall be refreshed to navigate commits
}

type Relationship 

type Relationship struct {
	Text       string `xml:",chardata"`
	ID         string `xml:"Id,attr"`
	Type       string `xml:"Type,attr"`
	Target     string `xml:"Target,attr"`
	TargetMode string `xml:"TargetMode,attr"`
}

Relationship is

type Relationships 

type Relationships struct {
	XMLName      xml.Name       `xml:"Relationships"`
	Text         string         `xml:",chardata"`
	Xmlns        string         `xml:"xmlns,attr"`
	Relationship []Relationship `xml:"Relationship"`
}

Relationships is

type ReverseField 

type ReverseField struct {
	GongstructName string
	Fieldname      string
}

func GetReverseFields 

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

type Rune 

type Rune struct {
	Name    string
	Content string

	Node           *Node
	Text           *Text
	RuneProperties *RuneProperties

	// navigation
	EnclosingParagraph *Paragraph
}

func CopyBranchRune 

func CopyBranchRune(mapOrigCopy map[any]any, runeFrom *Rune) (runeTo *Rune)

func (*Rune) Checkout 

func (rune *Rune) Checkout(stage *Stage) *Rune

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

func (*Rune) Commit 

func (rune *Rune) Commit(stage *Stage) *Rune

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

func (*Rune) CommitVoid 

func (rune *Rune) CommitVoid(stage *Stage)

func (*Rune) CopyBasicFields 

func (from *Rune) CopyBasicFields(to *Rune)

func (*Rune) GetName 

func (rune *Rune) GetName() (res string)

for satisfaction of GongStruct interface

func (*Rune) GongClean 

func (rune *Rune) GongClean(stage *Stage) (modified bool)

Clean garbage collect unstaged instances that are referenced by Rune

func (*Rune) GongCopy 

func (rune *Rune) GongCopy() GongstructIF

func (*Rune) GongDiff 

func (rune *Rune) GongDiff(stage *Stage, runeOther *Rune) (diffs []string)

GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*Rune) GongGetFieldHeaders 

func (rune *Rune) GongGetFieldHeaders() (res []GongFieldHeader)

func (*Rune) GongGetFieldValue 

func (rune *Rune) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

func (*Rune) GongGetGongstructName 

func (rune *Rune) GongGetGongstructName() string

func (*Rune) GongGetIdentifier 

func (rune *Rune) GongGetIdentifier(stage *Stage) string

func (*Rune) GongGetOrder 

func (rune *Rune) GongGetOrder(stage *Stage) uint

func (*Rune) GongGetReferenceIdentifier 

func (rune *Rune) GongGetReferenceIdentifier(stage *Stage) string

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*Rune) GongGetReverseFieldOwner 

func (inst *Rune) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

func (*Rune) GongGetReverseFieldOwnerName 

func (inst *Rune) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

func (*Rune) GongGetUUID 

func (rune *Rune) GongGetUUID(stage *Stage) (uuid string)

func (*Rune) GongMarshallAllFields 

func (rune *Rune) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

func (*Rune) GongMarshallField 

func (rune *Rune) GongMarshallField(stage *Stage, fieldName string) (res string)

func (*Rune) GongMarshallIdentifier 

func (rune *Rune) GongMarshallIdentifier(stage *Stage) (decl string)

func (*Rune) GongMarshallUnstaging 

func (rune *Rune) GongMarshallUnstaging(stage *Stage) (decl string)

func (*Rune) GongReconstructPointersFromInstances 

func (reference *Rune) GongReconstructPointersFromInstances(stage *Stage)

func (*Rune) GongReconstructPointersFromReferences 

func (reference *Rune) GongReconstructPointersFromReferences(stage *Stage, instance *Rune)

func (*Rune) GongSetFieldValue 

func (rune *Rune) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

func (*Rune) SetName 

func (rune *Rune) SetName(name string)

for satisfaction of GongStruct interface

func (*Rune) Stage 

func (rune *Rune) Stage(stage *Stage) *Rune

Stage puts rune to the model stage

func (*Rune) StagePreserveOrder 

func (rune *Rune) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts rune to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.RuneOrder - update stage.RuneOrder accordingly

func (*Rune) StageVoid 

func (rune *Rune) StageVoid(stage *Stage)

func (*Rune) Unstage 

func (rune *Rune) Unstage(stage *Stage) *Rune

Unstage removes rune off the model stage

func (*Rune) UnstageVoid 

func (rune *Rune) UnstageVoid(stage *Stage)

UnstageVoid removes rune off the model stage

type RuneProperties 

type RuneProperties struct {
	Name     string
	Node     *Node
	IsBold   bool
	IsStrike bool
	IsItalic bool

	Content string
}

func CopyBranchRuneProperties 

func CopyBranchRuneProperties(mapOrigCopy map[any]any, runepropertiesFrom *RuneProperties) (runepropertiesTo *RuneProperties)

func (*RuneProperties) Checkout 

func (runeproperties *RuneProperties) Checkout(stage *Stage) *RuneProperties

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

func (*RuneProperties) Commit 

func (runeproperties *RuneProperties) Commit(stage *Stage) *RuneProperties

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

func (*RuneProperties) CommitVoid 

func (runeproperties *RuneProperties) CommitVoid(stage *Stage)

func (*RuneProperties) CopyBasicFields 

func (from *RuneProperties) CopyBasicFields(to *RuneProperties)

func (*RuneProperties) GetName 

func (runeproperties *RuneProperties) GetName() (res string)

for satisfaction of GongStruct interface

func (*RuneProperties) GongClean 

func (runeproperties *RuneProperties) GongClean(stage *Stage) (modified bool)

Clean garbage collect unstaged instances that are referenced by RuneProperties

func (*RuneProperties) GongCopy 

func (runeproperties *RuneProperties) GongCopy() GongstructIF

func (*RuneProperties) GongDiff 

func (runeproperties *RuneProperties) GongDiff(stage *Stage, runepropertiesOther *RuneProperties) (diffs []string)

GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*RuneProperties) GongGetFieldHeaders 

func (runeproperties *RuneProperties) GongGetFieldHeaders() (res []GongFieldHeader)

func (*RuneProperties) GongGetFieldValue 

func (runeproperties *RuneProperties) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

func (*RuneProperties) GongGetGongstructName 

func (runeproperties *RuneProperties) GongGetGongstructName() string

func (*RuneProperties) GongGetIdentifier 

func (runeproperties *RuneProperties) GongGetIdentifier(stage *Stage) string

func (*RuneProperties) GongGetOrder 

func (runeproperties *RuneProperties) GongGetOrder(stage *Stage) uint

func (*RuneProperties) GongGetReferenceIdentifier 

func (runeproperties *RuneProperties) GongGetReferenceIdentifier(stage *Stage) string

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*RuneProperties) GongGetReverseFieldOwner 

func (inst *RuneProperties) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

func (*RuneProperties) GongGetReverseFieldOwnerName 

func (inst *RuneProperties) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

func (*RuneProperties) GongGetUUID 

func (runeproperties *RuneProperties) GongGetUUID(stage *Stage) (uuid string)

func (*RuneProperties) GongMarshallAllFields 

func (runeproperties *RuneProperties) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

func (*RuneProperties) GongMarshallField 

func (runeproperties *RuneProperties) GongMarshallField(stage *Stage, fieldName string) (res string)

func (*RuneProperties) GongMarshallIdentifier 

func (runeproperties *RuneProperties) GongMarshallIdentifier(stage *Stage) (decl string)

func (*RuneProperties) GongMarshallUnstaging 

func (runeproperties *RuneProperties) GongMarshallUnstaging(stage *Stage) (decl string)

func (*RuneProperties) GongReconstructPointersFromInstances 

func (reference *RuneProperties) GongReconstructPointersFromInstances(stage *Stage)

func (*RuneProperties) GongReconstructPointersFromReferences 

func (reference *RuneProperties) GongReconstructPointersFromReferences(stage *Stage, instance *RuneProperties)

func (*RuneProperties) GongSetFieldValue 

func (runeproperties *RuneProperties) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

func (*RuneProperties) SetName 

func (runeproperties *RuneProperties) SetName(name string)

for satisfaction of GongStruct interface

func (*RuneProperties) Stage 

func (runeproperties *RuneProperties) Stage(stage *Stage) *RuneProperties

Stage puts runeproperties to the model stage

func (*RuneProperties) StagePreserveOrder 

func (runeproperties *RuneProperties) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts runeproperties to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.RunePropertiesOrder - update stage.RunePropertiesOrder accordingly

func (*RuneProperties) StageVoid 

func (runeproperties *RuneProperties) StageVoid(stage *Stage)

func (*RuneProperties) Unstage 

func (runeproperties *RuneProperties) Unstage(stage *Stage) *RuneProperties

Unstage removes runeproperties off the model stage

func (*RuneProperties) UnstageVoid 

func (runeproperties *RuneProperties) UnstageVoid(stage *Stage)

UnstageVoid removes runeproperties off the model stage

type RunePropertiesUnmarshaller 

type RunePropertiesUnmarshaller struct{}

func (*RunePropertiesUnmarshaller) Initialize 

func (u *RunePropertiesUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*RunePropertiesUnmarshaller) UnmarshallField 

func (u *RunePropertiesUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type RuneProperties_WOP 

type RuneProperties_WOP struct {
	Name string

	IsBold bool

	IsStrike bool

	IsItalic bool

	Content string
}

type RuneUnmarshaller 

type RuneUnmarshaller struct{}

func (*RuneUnmarshaller) Initialize 

func (u *RuneUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*RuneUnmarshaller) UnmarshallField 

func (u *RuneUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type Rune_WOP 

type Rune_WOP struct {
	Name string

	Content string
}

type Stage 

type Stage struct {

	// insertion point for definition of arrays registering instances
	Bodys                map[*Body]struct{}
	Bodys_instance       map[*Body]*Body
	Bodys_mapString      map[string]*Body
	BodyOrder            uint
	Body_stagedOrder     map[*Body]uint
	Bodys_reference      map[*Body]*Body
	Bodys_referenceOrder map[*Body]uint

	// insertion point for slice of pointers maps
	Body_Paragraphs_reverseMap map[*Paragraph]*Body

	Body_Tables_reverseMap map[*Table]*Body

	OnAfterBodyCreateCallback OnAfterCreateInterface[Body]
	OnAfterBodyUpdateCallback OnAfterUpdateInterface[Body]
	OnAfterBodyDeleteCallback OnAfterDeleteInterface[Body]
	OnAfterBodyReadCallback   OnAfterReadInterface[Body]

	Documents                map[*Document]struct{}
	Documents_instance       map[*Document]*Document
	Documents_mapString      map[string]*Document
	DocumentOrder            uint
	Document_stagedOrder     map[*Document]uint
	Documents_reference      map[*Document]*Document
	Documents_referenceOrder map[*Document]uint

	// insertion point for slice of pointers maps
	OnAfterDocumentCreateCallback OnAfterCreateInterface[Document]
	OnAfterDocumentUpdateCallback OnAfterUpdateInterface[Document]
	OnAfterDocumentDeleteCallback OnAfterDeleteInterface[Document]
	OnAfterDocumentReadCallback   OnAfterReadInterface[Document]

	Docxs                map[*Docx]struct{}
	Docxs_instance       map[*Docx]*Docx
	Docxs_mapString      map[string]*Docx
	DocxOrder            uint
	Docx_stagedOrder     map[*Docx]uint
	Docxs_reference      map[*Docx]*Docx
	Docxs_referenceOrder map[*Docx]uint

	// insertion point for slice of pointers maps
	Docx_Files_reverseMap map[*File]*Docx

	OnAfterDocxCreateCallback OnAfterCreateInterface[Docx]
	OnAfterDocxUpdateCallback OnAfterUpdateInterface[Docx]
	OnAfterDocxDeleteCallback OnAfterDeleteInterface[Docx]
	OnAfterDocxReadCallback   OnAfterReadInterface[Docx]

	Files                map[*File]struct{}
	Files_instance       map[*File]*File
	Files_mapString      map[string]*File
	FileOrder            uint
	File_stagedOrder     map[*File]uint
	Files_reference      map[*File]*File
	Files_referenceOrder map[*File]uint

	// insertion point for slice of pointers maps
	OnAfterFileCreateCallback OnAfterCreateInterface[File]
	OnAfterFileUpdateCallback OnAfterUpdateInterface[File]
	OnAfterFileDeleteCallback OnAfterDeleteInterface[File]
	OnAfterFileReadCallback   OnAfterReadInterface[File]

	Nodes                map[*Node]struct{}
	Nodes_instance       map[*Node]*Node
	Nodes_mapString      map[string]*Node
	NodeOrder            uint
	Node_stagedOrder     map[*Node]uint
	Nodes_reference      map[*Node]*Node
	Nodes_referenceOrder map[*Node]uint

	// insertion point for slice of pointers maps
	Node_Nodes_reverseMap map[*Node]*Node

	OnAfterNodeCreateCallback OnAfterCreateInterface[Node]
	OnAfterNodeUpdateCallback OnAfterUpdateInterface[Node]
	OnAfterNodeDeleteCallback OnAfterDeleteInterface[Node]
	OnAfterNodeReadCallback   OnAfterReadInterface[Node]

	Paragraphs                map[*Paragraph]struct{}
	Paragraphs_instance       map[*Paragraph]*Paragraph
	Paragraphs_mapString      map[string]*Paragraph
	ParagraphOrder            uint
	Paragraph_stagedOrder     map[*Paragraph]uint
	Paragraphs_reference      map[*Paragraph]*Paragraph
	Paragraphs_referenceOrder map[*Paragraph]uint

	// insertion point for slice of pointers maps
	Paragraph_Runes_reverseMap map[*Rune]*Paragraph

	OnAfterParagraphCreateCallback OnAfterCreateInterface[Paragraph]
	OnAfterParagraphUpdateCallback OnAfterUpdateInterface[Paragraph]
	OnAfterParagraphDeleteCallback OnAfterDeleteInterface[Paragraph]
	OnAfterParagraphReadCallback   OnAfterReadInterface[Paragraph]

	ParagraphPropertiess                map[*ParagraphProperties]struct{}
	ParagraphPropertiess_instance       map[*ParagraphProperties]*ParagraphProperties
	ParagraphPropertiess_mapString      map[string]*ParagraphProperties
	ParagraphPropertiesOrder            uint
	ParagraphProperties_stagedOrder     map[*ParagraphProperties]uint
	ParagraphPropertiess_reference      map[*ParagraphProperties]*ParagraphProperties
	ParagraphPropertiess_referenceOrder map[*ParagraphProperties]uint

	// insertion point for slice of pointers maps
	OnAfterParagraphPropertiesCreateCallback OnAfterCreateInterface[ParagraphProperties]
	OnAfterParagraphPropertiesUpdateCallback OnAfterUpdateInterface[ParagraphProperties]
	OnAfterParagraphPropertiesDeleteCallback OnAfterDeleteInterface[ParagraphProperties]
	OnAfterParagraphPropertiesReadCallback   OnAfterReadInterface[ParagraphProperties]

	ParagraphStyles                map[*ParagraphStyle]struct{}
	ParagraphStyles_instance       map[*ParagraphStyle]*ParagraphStyle
	ParagraphStyles_mapString      map[string]*ParagraphStyle
	ParagraphStyleOrder            uint
	ParagraphStyle_stagedOrder     map[*ParagraphStyle]uint
	ParagraphStyles_reference      map[*ParagraphStyle]*ParagraphStyle
	ParagraphStyles_referenceOrder map[*ParagraphStyle]uint

	// insertion point for slice of pointers maps
	OnAfterParagraphStyleCreateCallback OnAfterCreateInterface[ParagraphStyle]
	OnAfterParagraphStyleUpdateCallback OnAfterUpdateInterface[ParagraphStyle]
	OnAfterParagraphStyleDeleteCallback OnAfterDeleteInterface[ParagraphStyle]
	OnAfterParagraphStyleReadCallback   OnAfterReadInterface[ParagraphStyle]

	Runes                map[*Rune]struct{}
	Runes_instance       map[*Rune]*Rune
	Runes_mapString      map[string]*Rune
	RuneOrder            uint
	Rune_stagedOrder     map[*Rune]uint
	Runes_reference      map[*Rune]*Rune
	Runes_referenceOrder map[*Rune]uint

	// insertion point for slice of pointers maps
	OnAfterRuneCreateCallback OnAfterCreateInterface[Rune]
	OnAfterRuneUpdateCallback OnAfterUpdateInterface[Rune]
	OnAfterRuneDeleteCallback OnAfterDeleteInterface[Rune]
	OnAfterRuneReadCallback   OnAfterReadInterface[Rune]

	RunePropertiess                map[*RuneProperties]struct{}
	RunePropertiess_instance       map[*RuneProperties]*RuneProperties
	RunePropertiess_mapString      map[string]*RuneProperties
	RunePropertiesOrder            uint
	RuneProperties_stagedOrder     map[*RuneProperties]uint
	RunePropertiess_reference      map[*RuneProperties]*RuneProperties
	RunePropertiess_referenceOrder map[*RuneProperties]uint

	// insertion point for slice of pointers maps
	OnAfterRunePropertiesCreateCallback OnAfterCreateInterface[RuneProperties]
	OnAfterRunePropertiesUpdateCallback OnAfterUpdateInterface[RuneProperties]
	OnAfterRunePropertiesDeleteCallback OnAfterDeleteInterface[RuneProperties]
	OnAfterRunePropertiesReadCallback   OnAfterReadInterface[RuneProperties]

	Tables                map[*Table]struct{}
	Tables_instance       map[*Table]*Table
	Tables_mapString      map[string]*Table
	TableOrder            uint
	Table_stagedOrder     map[*Table]uint
	Tables_reference      map[*Table]*Table
	Tables_referenceOrder map[*Table]uint

	// insertion point for slice of pointers maps
	Table_TableRows_reverseMap map[*TableRow]*Table

	OnAfterTableCreateCallback OnAfterCreateInterface[Table]
	OnAfterTableUpdateCallback OnAfterUpdateInterface[Table]
	OnAfterTableDeleteCallback OnAfterDeleteInterface[Table]
	OnAfterTableReadCallback   OnAfterReadInterface[Table]

	TableColumns                map[*TableColumn]struct{}
	TableColumns_instance       map[*TableColumn]*TableColumn
	TableColumns_mapString      map[string]*TableColumn
	TableColumnOrder            uint
	TableColumn_stagedOrder     map[*TableColumn]uint
	TableColumns_reference      map[*TableColumn]*TableColumn
	TableColumns_referenceOrder map[*TableColumn]uint

	// insertion point for slice of pointers maps
	TableColumn_Paragraphs_reverseMap map[*Paragraph]*TableColumn

	OnAfterTableColumnCreateCallback OnAfterCreateInterface[TableColumn]
	OnAfterTableColumnUpdateCallback OnAfterUpdateInterface[TableColumn]
	OnAfterTableColumnDeleteCallback OnAfterDeleteInterface[TableColumn]
	OnAfterTableColumnReadCallback   OnAfterReadInterface[TableColumn]

	TablePropertiess                map[*TableProperties]struct{}
	TablePropertiess_instance       map[*TableProperties]*TableProperties
	TablePropertiess_mapString      map[string]*TableProperties
	TablePropertiesOrder            uint
	TableProperties_stagedOrder     map[*TableProperties]uint
	TablePropertiess_reference      map[*TableProperties]*TableProperties
	TablePropertiess_referenceOrder map[*TableProperties]uint

	// insertion point for slice of pointers maps
	OnAfterTablePropertiesCreateCallback OnAfterCreateInterface[TableProperties]
	OnAfterTablePropertiesUpdateCallback OnAfterUpdateInterface[TableProperties]
	OnAfterTablePropertiesDeleteCallback OnAfterDeleteInterface[TableProperties]
	OnAfterTablePropertiesReadCallback   OnAfterReadInterface[TableProperties]

	TableRows                map[*TableRow]struct{}
	TableRows_instance       map[*TableRow]*TableRow
	TableRows_mapString      map[string]*TableRow
	TableRowOrder            uint
	TableRow_stagedOrder     map[*TableRow]uint
	TableRows_reference      map[*TableRow]*TableRow
	TableRows_referenceOrder map[*TableRow]uint

	// insertion point for slice of pointers maps
	TableRow_TableColumns_reverseMap map[*TableColumn]*TableRow

	OnAfterTableRowCreateCallback OnAfterCreateInterface[TableRow]
	OnAfterTableRowUpdateCallback OnAfterUpdateInterface[TableRow]
	OnAfterTableRowDeleteCallback OnAfterDeleteInterface[TableRow]
	OnAfterTableRowReadCallback   OnAfterReadInterface[TableRow]

	TableStyles                map[*TableStyle]struct{}
	TableStyles_instance       map[*TableStyle]*TableStyle
	TableStyles_mapString      map[string]*TableStyle
	TableStyleOrder            uint
	TableStyle_stagedOrder     map[*TableStyle]uint
	TableStyles_reference      map[*TableStyle]*TableStyle
	TableStyles_referenceOrder map[*TableStyle]uint

	// insertion point for slice of pointers maps
	OnAfterTableStyleCreateCallback OnAfterCreateInterface[TableStyle]
	OnAfterTableStyleUpdateCallback OnAfterUpdateInterface[TableStyle]
	OnAfterTableStyleDeleteCallback OnAfterDeleteInterface[TableStyle]
	OnAfterTableStyleReadCallback   OnAfterReadInterface[TableStyle]

	Texts                map[*Text]struct{}
	Texts_instance       map[*Text]*Text
	Texts_mapString      map[string]*Text
	TextOrder            uint
	Text_stagedOrder     map[*Text]uint
	Texts_reference      map[*Text]*Text
	Texts_referenceOrder map[*Text]uint

	// insertion point for slice of pointers maps
	OnAfterTextCreateCallback OnAfterCreateInterface[Text]
	OnAfterTextUpdateCallback OnAfterUpdateInterface[Text]
	OnAfterTextDeleteCallback OnAfterDeleteInterface[Text]
	OnAfterTextReadCallback   OnAfterReadInterface[Text]

	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

	NamedStructs []*NamedStruct

	// GongUnmarshallers is the registry of all model unmarshallers
	GongUnmarshallers map[string]ModelUnmarshaller
	// contains filtered or unexported fields
}

Stage enables storage of staged instances

func NewStage 

func NewStage(name string) (stage *Stage)

func (*Stage) ApplyBackwardCommit 

func (stage *Stage) ApplyBackwardCommit() error

ApplyBackwardCommit applies the commit before the current one

func (*Stage) ApplyForwardCommit 

func (stage *Stage) ApplyForwardCommit() error

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) Clean 

func (stage *Stage) Clean() (modified bool)

Clean garbage collect unstaged instances that are referenced by staged elements

func (*Stage) Commit 

func (stage *Stage) Commit()

func (*Stage) CommitWithSuspendedCallbacks 

func (stage *Stage) CommitWithSuspendedCallbacks()

func (*Stage) ComputeForwardAndBackwardCommits 

func (stage *Stage) ComputeForwardAndBackwardCommits()

func (*Stage) ComputeInstancesNb 

func (stage *Stage) ComputeInstancesNb()

func (*Stage) ComputeReferenceAndOrders 

func (stage *Stage) ComputeReferenceAndOrders()

ComputeReferenceAndOrders will creates a deep copy of each of the staged elements

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) GetBackwardCommits 

func (stage *Stage) GetBackwardCommits() []string

func (*Stage) GetCommitsBehind 

func (stage *Stage) GetCommitsBehind() int

func (*Stage) GetDigramsEmbededDir 

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

func (*Stage) GetForwardCommits 

func (stage *Stage) GetForwardCommits() []string

func (*Stage) GetGongMarshallingMode 

func (s *Stage) GetGongMarshallingMode() GongMarshallingMode

func (*Stage) GetInstances 

func (stage *Stage) GetInstances() (res []GongstructIF)

func (*Stage) GetIsWithGenesisCommit 

func (s *Stage) GetIsWithGenesisCommit() bool

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) GetProbeIF 

func (stage *Stage) GetProbeIF() ProbeIF

func (*Stage) GetProbeNavigationTreeSidebarStageName 

func (stage *Stage) GetProbeNavigationTreeSidebarStageName() string

func (*Stage) GetProbeNotificationTableStageName 

func (stage *Stage) GetProbeNotificationTableStageName() 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) IsInDeltaMode 

func (stage *Stage) IsInDeltaMode() bool

func (*Stage) IsStagedBody 

func (stage *Stage) IsStagedBody(body *Body) (ok bool)

insertion point for stage per struct

func (*Stage) IsStagedDocument 

func (stage *Stage) IsStagedDocument(document *Document) (ok bool)

func (*Stage) IsStagedDocx 

func (stage *Stage) IsStagedDocx(docx *Docx) (ok bool)

func (*Stage) IsStagedFile 

func (stage *Stage) IsStagedFile(file *File) (ok bool)

func (*Stage) IsStagedNode 

func (stage *Stage) IsStagedNode(node *Node) (ok bool)

func (*Stage) IsStagedParagraph 

func (stage *Stage) IsStagedParagraph(paragraph *Paragraph) (ok bool)

func (*Stage) IsStagedParagraphProperties 

func (stage *Stage) IsStagedParagraphProperties(paragraphproperties *ParagraphProperties) (ok bool)

func (*Stage) IsStagedParagraphStyle 

func (stage *Stage) IsStagedParagraphStyle(paragraphstyle *ParagraphStyle) (ok bool)

func (*Stage) IsStagedRune 

func (stage *Stage) IsStagedRune(rune *Rune) (ok bool)

func (*Stage) IsStagedRuneProperties 

func (stage *Stage) IsStagedRuneProperties(runeproperties *RuneProperties) (ok bool)

func (*Stage) IsStagedTable 

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

func (*Stage) IsStagedTableColumn 

func (stage *Stage) IsStagedTableColumn(tablecolumn *TableColumn) (ok bool)

func (*Stage) IsStagedTableProperties 

func (stage *Stage) IsStagedTableProperties(tableproperties *TableProperties) (ok bool)

func (*Stage) IsStagedTableRow 

func (stage *Stage) IsStagedTableRow(tablerow *TableRow) (ok bool)

func (*Stage) IsStagedTableStyle 

func (stage *Stage) IsStagedTableStyle(tablestyle *TableStyle) (ok bool)

func (*Stage) IsStagedText 

func (stage *Stage) IsStagedText(text *Text) (ok bool)

func (*Stage) Lock 

func (stage *Stage) Lock()

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) MarshallFile 

func (stage *Stage) MarshallFile(filename, modelsPackageName, packageName string)

MarshallFile marshall the stage content into a file as an instanciation into a stage according to the marshalling policy of the stage.

In GongMarshallingAppendCommit mode, it will append the last commit to the file. In other modes, it will rewrite the entire file.

func (*Stage) MarshallToString 

func (stage *Stage) MarshallToString(modelsPackageName, packageName string) (res string, err error)

MarshallToString marshall the stage content into a string

func (*Stage) Nil 

func (stage *Stage) Nil()

func (*Stage) RLock 

func (stage *Stage) RLock()

func (*Stage) RUnlock 

func (stage *Stage) RUnlock()

func (*Stage) RegisterAfterCommit 

func (s *Stage) RegisterAfterCommit(hook func(stage *Stage))

RegisterAfterCommit adds a hook that runs after the commit succeeds

func (*Stage) RegisterBeforeCommit 

func (s *Stage) RegisterBeforeCommit(hook func(stage *Stage))

RegisterBeforeCommit adds a hook that runs before the commit happens

func (*Stage) Reset 

func (stage *Stage) Reset()

func (*Stage) ResetHard 

func (stage *Stage) ResetHard()

ResetHard removes the more recent commitsBehind forward/backward Commits from the stage

func (*Stage) ResetMapStrings 

func (stage *Stage) ResetMapStrings()

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) SetDeltaMode 

func (stage *Stage) SetDeltaMode(inDeltaMode bool)

func (*Stage) SetGongMarshallingMode 

func (s *Stage) SetGongMarshallingMode(mode GongMarshallingMode)

func (*Stage) SetIsWithGenesisCommit 

func (s *Stage) SetIsWithGenesisCommit(isWithGenesisCommit bool)

func (*Stage) SetProbeIF 

func (stage *Stage) SetProbeIF(probeIF ProbeIF)

func (*Stage) Squash 

func (stage *Stage) Squash()

Squash removes all commits and marshals the stage as a single commit

func (*Stage) StageBranchBody 

func (stage *Stage) StageBranchBody(body *Body)

insertion point for stage branch per struct

func (*Stage) StageBranchDocument 

func (stage *Stage) StageBranchDocument(document *Document)

func (*Stage) StageBranchDocx 

func (stage *Stage) StageBranchDocx(docx *Docx)

func (*Stage) StageBranchFile 

func (stage *Stage) StageBranchFile(file *File)

func (*Stage) StageBranchNode 

func (stage *Stage) StageBranchNode(node *Node)

func (*Stage) StageBranchParagraph 

func (stage *Stage) StageBranchParagraph(paragraph *Paragraph)

func (*Stage) StageBranchParagraphProperties 

func (stage *Stage) StageBranchParagraphProperties(paragraphproperties *ParagraphProperties)

func (*Stage) StageBranchParagraphStyle 

func (stage *Stage) StageBranchParagraphStyle(paragraphstyle *ParagraphStyle)

func (*Stage) StageBranchRune 

func (stage *Stage) StageBranchRune(rune *Rune)

func (*Stage) StageBranchRuneProperties 

func (stage *Stage) StageBranchRuneProperties(runeproperties *RuneProperties)

func (*Stage) StageBranchTable 

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

func (*Stage) StageBranchTableColumn 

func (stage *Stage) StageBranchTableColumn(tablecolumn *TableColumn)

func (*Stage) StageBranchTableProperties 

func (stage *Stage) StageBranchTableProperties(tableproperties *TableProperties)

func (*Stage) StageBranchTableRow 

func (stage *Stage) StageBranchTableRow(tablerow *TableRow)

func (*Stage) StageBranchTableStyle 

func (stage *Stage) StageBranchTableStyle(tablestyle *TableStyle)

func (*Stage) StageBranchText 

func (stage *Stage) StageBranchText(text *Text)

func (*Stage) Unlock 

func (stage *Stage) Unlock()

func (*Stage) UnmarshallFile 

func (stage *Stage) UnmarshallFile(pathToFile string, preserveOrder bool) error

func (*Stage) Unstage 

func (stage *Stage) Unstage()

func (*Stage) UnstageBranchBody 

func (stage *Stage) UnstageBranchBody(body *Body)

insertion point for unstage branch per struct

func (*Stage) UnstageBranchDocument 

func (stage *Stage) UnstageBranchDocument(document *Document)

func (*Stage) UnstageBranchDocx 

func (stage *Stage) UnstageBranchDocx(docx *Docx)

func (*Stage) UnstageBranchFile 

func (stage *Stage) UnstageBranchFile(file *File)

func (*Stage) UnstageBranchNode 

func (stage *Stage) UnstageBranchNode(node *Node)

func (*Stage) UnstageBranchParagraph 

func (stage *Stage) UnstageBranchParagraph(paragraph *Paragraph)

func (*Stage) UnstageBranchParagraphProperties 

func (stage *Stage) UnstageBranchParagraphProperties(paragraphproperties *ParagraphProperties)

func (*Stage) UnstageBranchParagraphStyle 

func (stage *Stage) UnstageBranchParagraphStyle(paragraphstyle *ParagraphStyle)

func (*Stage) UnstageBranchRune 

func (stage *Stage) UnstageBranchRune(rune *Rune)

func (*Stage) UnstageBranchRuneProperties 

func (stage *Stage) UnstageBranchRuneProperties(runeproperties *RuneProperties)

func (*Stage) UnstageBranchTable 

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

func (*Stage) UnstageBranchTableColumn 

func (stage *Stage) UnstageBranchTableColumn(tablecolumn *TableColumn)

func (*Stage) UnstageBranchTableProperties 

func (stage *Stage) UnstageBranchTableProperties(tableproperties *TableProperties)

func (*Stage) UnstageBranchTableRow 

func (stage *Stage) UnstageBranchTableRow(tablerow *TableRow)

func (*Stage) UnstageBranchTableStyle 

func (stage *Stage) UnstageBranchTableStyle(tablestyle *TableStyle)

func (*Stage) UnstageBranchText 

func (stage *Stage) UnstageBranchText(text *Text)

type Stager 

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

func NewStager 

func NewStager(
	r *gin.Engine,
	stage *Stage,
	probeForm ProbeIF,
	filename string,
) (stager *Stager)

type Table 

type Table struct {
	Name            string
	Node            *Node
	Content         string
	TableProperties *TableProperties
	TableRows       []*TableRow
}

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) GongClean 

func (table *Table) GongClean(stage *Stage) (modified bool)

Clean garbage collect unstaged instances that are referenced by Table

func (*Table) GongCopy 

func (table *Table) GongCopy() GongstructIF

func (*Table) GongDiff 

func (table *Table) GongDiff(stage *Stage, tableOther *Table) (diffs []string)

GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*Table) GongGetFieldHeaders 

func (table *Table) GongGetFieldHeaders() (res []GongFieldHeader)

func (*Table) GongGetFieldValue 

func (table *Table) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

func (*Table) GongGetGongstructName 

func (table *Table) GongGetGongstructName() string

func (*Table) GongGetIdentifier 

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

func (*Table) GongGetOrder 

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

func (*Table) GongGetReferenceIdentifier 

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

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*Table) GongGetReverseFieldOwner 

func (inst *Table) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

func (*Table) GongGetReverseFieldOwnerName 

func (inst *Table) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

func (*Table) GongGetUUID 

func (table *Table) GongGetUUID(stage *Stage) (uuid string)

func (*Table) GongMarshallAllFields 

func (table *Table) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

func (*Table) GongMarshallField 

func (table *Table) GongMarshallField(stage *Stage, fieldName string) (res string)

func (*Table) GongMarshallIdentifier 

func (table *Table) GongMarshallIdentifier(stage *Stage) (decl string)

func (*Table) GongMarshallUnstaging 

func (table *Table) GongMarshallUnstaging(stage *Stage) (decl string)

func (*Table) GongReconstructPointersFromInstances 

func (reference *Table) GongReconstructPointersFromInstances(stage *Stage)

func (*Table) GongReconstructPointersFromReferences 

func (reference *Table) GongReconstructPointersFromReferences(stage *Stage, instance *Table)

func (*Table) GongSetFieldValue 

func (table *Table) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

func (*Table) SetName 

func (table *Table) SetName(name 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) StagePreserveOrder 

func (table *Table) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts table to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.TableOrder - update stage.TableOrder accordingly

func (*Table) StageVoid 

func (table *Table) StageVoid(stage *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 TableColumn 

type TableColumn struct {
	Name       string
	Content    string
	Node       *Node
	Paragraphs []*Paragraph
}

func CopyBranchTableColumn 

func CopyBranchTableColumn(mapOrigCopy map[any]any, tablecolumnFrom *TableColumn) (tablecolumnTo *TableColumn)

func (*TableColumn) Checkout 

func (tablecolumn *TableColumn) Checkout(stage *Stage) *TableColumn

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

func (*TableColumn) Commit 

func (tablecolumn *TableColumn) Commit(stage *Stage) *TableColumn

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

func (*TableColumn) CommitVoid 

func (tablecolumn *TableColumn) CommitVoid(stage *Stage)

func (*TableColumn) CopyBasicFields 

func (from *TableColumn) CopyBasicFields(to *TableColumn)

func (*TableColumn) GetName 

func (tablecolumn *TableColumn) GetName() (res string)

for satisfaction of GongStruct interface

func (*TableColumn) GongClean 

func (tablecolumn *TableColumn) GongClean(stage *Stage) (modified bool)

Clean garbage collect unstaged instances that are referenced by TableColumn

func (*TableColumn) GongCopy 

func (tablecolumn *TableColumn) GongCopy() GongstructIF

func (*TableColumn) GongDiff 

func (tablecolumn *TableColumn) GongDiff(stage *Stage, tablecolumnOther *TableColumn) (diffs []string)

GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*TableColumn) GongGetFieldHeaders 

func (tablecolumn *TableColumn) GongGetFieldHeaders() (res []GongFieldHeader)

func (*TableColumn) GongGetFieldValue 

func (tablecolumn *TableColumn) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

func (*TableColumn) GongGetGongstructName 

func (tablecolumn *TableColumn) GongGetGongstructName() string

func (*TableColumn) GongGetIdentifier 

func (tablecolumn *TableColumn) GongGetIdentifier(stage *Stage) string

func (*TableColumn) GongGetOrder 

func (tablecolumn *TableColumn) GongGetOrder(stage *Stage) uint

func (*TableColumn) GongGetReferenceIdentifier 

func (tablecolumn *TableColumn) GongGetReferenceIdentifier(stage *Stage) string

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*TableColumn) GongGetReverseFieldOwner 

func (inst *TableColumn) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

func (*TableColumn) GongGetReverseFieldOwnerName 

func (inst *TableColumn) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

func (*TableColumn) GongGetUUID 

func (tablecolumn *TableColumn) GongGetUUID(stage *Stage) (uuid string)

func (*TableColumn) GongMarshallAllFields 

func (tablecolumn *TableColumn) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

func (*TableColumn) GongMarshallField 

func (tablecolumn *TableColumn) GongMarshallField(stage *Stage, fieldName string) (res string)

func (*TableColumn) GongMarshallIdentifier 

func (tablecolumn *TableColumn) GongMarshallIdentifier(stage *Stage) (decl string)

func (*TableColumn) GongMarshallUnstaging 

func (tablecolumn *TableColumn) GongMarshallUnstaging(stage *Stage) (decl string)

func (*TableColumn) GongReconstructPointersFromInstances 

func (reference *TableColumn) GongReconstructPointersFromInstances(stage *Stage)

func (*TableColumn) GongReconstructPointersFromReferences 

func (reference *TableColumn) GongReconstructPointersFromReferences(stage *Stage, instance *TableColumn)

func (*TableColumn) GongSetFieldValue 

func (tablecolumn *TableColumn) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

func (*TableColumn) SetName 

func (tablecolumn *TableColumn) SetName(name string)

for satisfaction of GongStruct interface

func (*TableColumn) Stage 

func (tablecolumn *TableColumn) Stage(stage *Stage) *TableColumn

Stage puts tablecolumn to the model stage

func (*TableColumn) StagePreserveOrder 

func (tablecolumn *TableColumn) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts tablecolumn to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.TableColumnOrder - update stage.TableColumnOrder accordingly

func (*TableColumn) StageVoid 

func (tablecolumn *TableColumn) StageVoid(stage *Stage)

func (*TableColumn) Unstage 

func (tablecolumn *TableColumn) Unstage(stage *Stage) *TableColumn

Unstage removes tablecolumn off the model stage

func (*TableColumn) UnstageVoid 

func (tablecolumn *TableColumn) UnstageVoid(stage *Stage)

UnstageVoid removes tablecolumn off the model stage

type TableColumnUnmarshaller 

type TableColumnUnmarshaller struct{}

func (*TableColumnUnmarshaller) Initialize 

func (u *TableColumnUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*TableColumnUnmarshaller) UnmarshallField 

func (u *TableColumnUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type TableColumn_WOP 

type TableColumn_WOP struct {
	Name string

	Content string
}

type TableProperties 

type TableProperties struct {
	Name       string
	Node       *Node
	Content    string
	TableStyle *TableStyle
}

func CopyBranchTableProperties 

func CopyBranchTableProperties(mapOrigCopy map[any]any, tablepropertiesFrom *TableProperties) (tablepropertiesTo *TableProperties)

func (*TableProperties) Checkout 

func (tableproperties *TableProperties) Checkout(stage *Stage) *TableProperties

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

func (*TableProperties) Commit 

func (tableproperties *TableProperties) Commit(stage *Stage) *TableProperties

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

func (*TableProperties) CommitVoid 

func (tableproperties *TableProperties) CommitVoid(stage *Stage)

func (*TableProperties) CopyBasicFields 

func (from *TableProperties) CopyBasicFields(to *TableProperties)

func (*TableProperties) GetName 

func (tableproperties *TableProperties) GetName() (res string)

for satisfaction of GongStruct interface

func (*TableProperties) GongClean 

func (tableproperties *TableProperties) GongClean(stage *Stage) (modified bool)

Clean garbage collect unstaged instances that are referenced by TableProperties

func (*TableProperties) GongCopy 

func (tableproperties *TableProperties) GongCopy() GongstructIF

func (*TableProperties) GongDiff 

func (tableproperties *TableProperties) GongDiff(stage *Stage, tablepropertiesOther *TableProperties) (diffs []string)

GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*TableProperties) GongGetFieldHeaders 

func (tableproperties *TableProperties) GongGetFieldHeaders() (res []GongFieldHeader)

func (*TableProperties) GongGetFieldValue 

func (tableproperties *TableProperties) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

func (*TableProperties) GongGetGongstructName 

func (tableproperties *TableProperties) GongGetGongstructName() string

func (*TableProperties) GongGetIdentifier 

func (tableproperties *TableProperties) GongGetIdentifier(stage *Stage) string

func (*TableProperties) GongGetOrder 

func (tableproperties *TableProperties) GongGetOrder(stage *Stage) uint

func (*TableProperties) GongGetReferenceIdentifier 

func (tableproperties *TableProperties) GongGetReferenceIdentifier(stage *Stage) string

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*TableProperties) GongGetReverseFieldOwner 

func (inst *TableProperties) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

func (*TableProperties) GongGetReverseFieldOwnerName 

func (inst *TableProperties) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

func (*TableProperties) GongGetUUID 

func (tableproperties *TableProperties) GongGetUUID(stage *Stage) (uuid string)

func (*TableProperties) GongMarshallAllFields 

func (tableproperties *TableProperties) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

func (*TableProperties) GongMarshallField 

func (tableproperties *TableProperties) GongMarshallField(stage *Stage, fieldName string) (res string)

func (*TableProperties) GongMarshallIdentifier 

func (tableproperties *TableProperties) GongMarshallIdentifier(stage *Stage) (decl string)

func (*TableProperties) GongMarshallUnstaging 

func (tableproperties *TableProperties) GongMarshallUnstaging(stage *Stage) (decl string)

func (*TableProperties) GongReconstructPointersFromInstances 

func (reference *TableProperties) GongReconstructPointersFromInstances(stage *Stage)

func (*TableProperties) GongReconstructPointersFromReferences 

func (reference *TableProperties) GongReconstructPointersFromReferences(stage *Stage, instance *TableProperties)

func (*TableProperties) GongSetFieldValue 

func (tableproperties *TableProperties) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

func (*TableProperties) SetName 

func (tableproperties *TableProperties) SetName(name string)

for satisfaction of GongStruct interface

func (*TableProperties) Stage 

func (tableproperties *TableProperties) Stage(stage *Stage) *TableProperties

Stage puts tableproperties to the model stage

func (*TableProperties) StagePreserveOrder 

func (tableproperties *TableProperties) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts tableproperties to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.TablePropertiesOrder - update stage.TablePropertiesOrder accordingly

func (*TableProperties) StageVoid 

func (tableproperties *TableProperties) StageVoid(stage *Stage)

func (*TableProperties) Unstage 

func (tableproperties *TableProperties) Unstage(stage *Stage) *TableProperties

Unstage removes tableproperties off the model stage

func (*TableProperties) UnstageVoid 

func (tableproperties *TableProperties) UnstageVoid(stage *Stage)

UnstageVoid removes tableproperties off the model stage

type TablePropertiesUnmarshaller 

type TablePropertiesUnmarshaller struct{}

func (*TablePropertiesUnmarshaller) Initialize 

func (u *TablePropertiesUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*TablePropertiesUnmarshaller) UnmarshallField 

func (u *TablePropertiesUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type TableProperties_WOP 

type TableProperties_WOP struct {
	Name string

	Content string
}

type TableRow 

type TableRow struct {
	Name         string
	Content      string
	Node         *Node
	TableColumns []*TableColumn
}

func CopyBranchTableRow 

func CopyBranchTableRow(mapOrigCopy map[any]any, tablerowFrom *TableRow) (tablerowTo *TableRow)

func (*TableRow) Checkout 

func (tablerow *TableRow) Checkout(stage *Stage) *TableRow

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

func (*TableRow) Commit 

func (tablerow *TableRow) Commit(stage *Stage) *TableRow

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

func (*TableRow) CommitVoid 

func (tablerow *TableRow) CommitVoid(stage *Stage)

func (*TableRow) CopyBasicFields 

func (from *TableRow) CopyBasicFields(to *TableRow)

func (*TableRow) GetName 

func (tablerow *TableRow) GetName() (res string)

for satisfaction of GongStruct interface

func (*TableRow) GongClean 

func (tablerow *TableRow) GongClean(stage *Stage) (modified bool)

Clean garbage collect unstaged instances that are referenced by TableRow

func (*TableRow) GongCopy 

func (tablerow *TableRow) GongCopy() GongstructIF

func (*TableRow) GongDiff 

func (tablerow *TableRow) GongDiff(stage *Stage, tablerowOther *TableRow) (diffs []string)

GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*TableRow) GongGetFieldHeaders 

func (tablerow *TableRow) GongGetFieldHeaders() (res []GongFieldHeader)

func (*TableRow) GongGetFieldValue 

func (tablerow *TableRow) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

func (*TableRow) GongGetGongstructName 

func (tablerow *TableRow) GongGetGongstructName() string

func (*TableRow) GongGetIdentifier 

func (tablerow *TableRow) GongGetIdentifier(stage *Stage) string

func (*TableRow) GongGetOrder 

func (tablerow *TableRow) GongGetOrder(stage *Stage) uint

func (*TableRow) GongGetReferenceIdentifier 

func (tablerow *TableRow) GongGetReferenceIdentifier(stage *Stage) string

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*TableRow) GongGetReverseFieldOwner 

func (inst *TableRow) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

func (*TableRow) GongGetReverseFieldOwnerName 

func (inst *TableRow) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

func (*TableRow) GongGetUUID 

func (tablerow *TableRow) GongGetUUID(stage *Stage) (uuid string)

func (*TableRow) GongMarshallAllFields 

func (tablerow *TableRow) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

func (*TableRow) GongMarshallField 

func (tablerow *TableRow) GongMarshallField(stage *Stage, fieldName string) (res string)

func (*TableRow) GongMarshallIdentifier 

func (tablerow *TableRow) GongMarshallIdentifier(stage *Stage) (decl string)

func (*TableRow) GongMarshallUnstaging 

func (tablerow *TableRow) GongMarshallUnstaging(stage *Stage) (decl string)

func (*TableRow) GongReconstructPointersFromInstances 

func (reference *TableRow) GongReconstructPointersFromInstances(stage *Stage)

func (*TableRow) GongReconstructPointersFromReferences 

func (reference *TableRow) GongReconstructPointersFromReferences(stage *Stage, instance *TableRow)

func (*TableRow) GongSetFieldValue 

func (tablerow *TableRow) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

func (*TableRow) SetName 

func (tablerow *TableRow) SetName(name string)

for satisfaction of GongStruct interface

func (*TableRow) Stage 

func (tablerow *TableRow) Stage(stage *Stage) *TableRow

Stage puts tablerow to the model stage

func (*TableRow) StagePreserveOrder 

func (tablerow *TableRow) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts tablerow to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.TableRowOrder - update stage.TableRowOrder accordingly

func (*TableRow) StageVoid 

func (tablerow *TableRow) StageVoid(stage *Stage)

func (*TableRow) Unstage 

func (tablerow *TableRow) Unstage(stage *Stage) *TableRow

Unstage removes tablerow off the model stage

func (*TableRow) UnstageVoid 

func (tablerow *TableRow) UnstageVoid(stage *Stage)

UnstageVoid removes tablerow off the model stage

type TableRowUnmarshaller 

type TableRowUnmarshaller struct{}

func (*TableRowUnmarshaller) Initialize 

func (u *TableRowUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*TableRowUnmarshaller) UnmarshallField 

func (u *TableRowUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type TableRow_WOP 

type TableRow_WOP struct {
	Name string

	Content string
}

type TableStyle 

type TableStyle struct {
	Name    string
	Node    *Node
	Content string
	Val     string
}

func CopyBranchTableStyle 

func CopyBranchTableStyle(mapOrigCopy map[any]any, tablestyleFrom *TableStyle) (tablestyleTo *TableStyle)

func (*TableStyle) Checkout 

func (tablestyle *TableStyle) Checkout(stage *Stage) *TableStyle

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

func (*TableStyle) Commit 

func (tablestyle *TableStyle) Commit(stage *Stage) *TableStyle

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

func (*TableStyle) CommitVoid 

func (tablestyle *TableStyle) CommitVoid(stage *Stage)

func (*TableStyle) CopyBasicFields 

func (from *TableStyle) CopyBasicFields(to *TableStyle)

func (*TableStyle) GetName 

func (tablestyle *TableStyle) GetName() (res string)

for satisfaction of GongStruct interface

func (*TableStyle) GongClean 

func (tablestyle *TableStyle) GongClean(stage *Stage) (modified bool)

Clean garbage collect unstaged instances that are referenced by TableStyle

func (*TableStyle) GongCopy 

func (tablestyle *TableStyle) GongCopy() GongstructIF

func (*TableStyle) GongDiff 

func (tablestyle *TableStyle) GongDiff(stage *Stage, tablestyleOther *TableStyle) (diffs []string)

GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*TableStyle) GongGetFieldHeaders 

func (tablestyle *TableStyle) GongGetFieldHeaders() (res []GongFieldHeader)

func (*TableStyle) GongGetFieldValue 

func (tablestyle *TableStyle) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

func (*TableStyle) GongGetGongstructName 

func (tablestyle *TableStyle) GongGetGongstructName() string

func (*TableStyle) GongGetIdentifier 

func (tablestyle *TableStyle) GongGetIdentifier(stage *Stage) string

func (*TableStyle) GongGetOrder 

func (tablestyle *TableStyle) GongGetOrder(stage *Stage) uint

func (*TableStyle) GongGetReferenceIdentifier 

func (tablestyle *TableStyle) GongGetReferenceIdentifier(stage *Stage) string

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*TableStyle) GongGetReverseFieldOwner 

func (inst *TableStyle) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

func (*TableStyle) GongGetReverseFieldOwnerName 

func (inst *TableStyle) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

func (*TableStyle) GongGetUUID 

func (tablestyle *TableStyle) GongGetUUID(stage *Stage) (uuid string)

func (*TableStyle) GongMarshallAllFields 

func (tablestyle *TableStyle) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

func (*TableStyle) GongMarshallField 

func (tablestyle *TableStyle) GongMarshallField(stage *Stage, fieldName string) (res string)

func (*TableStyle) GongMarshallIdentifier 

func (tablestyle *TableStyle) GongMarshallIdentifier(stage *Stage) (decl string)

func (*TableStyle) GongMarshallUnstaging 

func (tablestyle *TableStyle) GongMarshallUnstaging(stage *Stage) (decl string)

func (*TableStyle) GongReconstructPointersFromInstances 

func (reference *TableStyle) GongReconstructPointersFromInstances(stage *Stage)

func (*TableStyle) GongReconstructPointersFromReferences 

func (reference *TableStyle) GongReconstructPointersFromReferences(stage *Stage, instance *TableStyle)

func (*TableStyle) GongSetFieldValue 

func (tablestyle *TableStyle) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

func (*TableStyle) SetName 

func (tablestyle *TableStyle) SetName(name string)

for satisfaction of GongStruct interface

func (*TableStyle) Stage 

func (tablestyle *TableStyle) Stage(stage *Stage) *TableStyle

Stage puts tablestyle to the model stage

func (*TableStyle) StagePreserveOrder 

func (tablestyle *TableStyle) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts tablestyle to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.TableStyleOrder - update stage.TableStyleOrder accordingly

func (*TableStyle) StageVoid 

func (tablestyle *TableStyle) StageVoid(stage *Stage)

func (*TableStyle) Unstage 

func (tablestyle *TableStyle) Unstage(stage *Stage) *TableStyle

Unstage removes tablestyle off the model stage

func (*TableStyle) UnstageVoid 

func (tablestyle *TableStyle) UnstageVoid(stage *Stage)

UnstageVoid removes tablestyle off the model stage

type TableStyleUnmarshaller 

type TableStyleUnmarshaller struct{}

func (*TableStyleUnmarshaller) Initialize 

func (u *TableStyleUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*TableStyleUnmarshaller) UnmarshallField 

func (u *TableStyleUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type TableStyle_WOP 

type TableStyle_WOP struct {
	Name string

	Content string

	Val string
}

type TableUnmarshaller 

type TableUnmarshaller struct{}

func (*TableUnmarshaller) Initialize 

func (u *TableUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*TableUnmarshaller) UnmarshallField 

func (u *TableUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type Table_WOP 

type Table_WOP struct {
	Name string

	Content 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 Text 

type Text struct {
	Name               string
	Content            string
	Node               *Node
	PreserveWhiteSpace bool

	// navigation
	EnclosingRune *Rune
}

func CopyBranchText 

func CopyBranchText(mapOrigCopy map[any]any, textFrom *Text) (textTo *Text)

func (*Text) Checkout 

func (text *Text) Checkout(stage *Stage) *Text

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

func (*Text) Commit 

func (text *Text) Commit(stage *Stage) *Text

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

func (*Text) CommitVoid 

func (text *Text) CommitVoid(stage *Stage)

func (*Text) CopyBasicFields 

func (from *Text) CopyBasicFields(to *Text)

func (*Text) GetName 

func (text *Text) GetName() (res string)

for satisfaction of GongStruct interface

func (*Text) GongClean 

func (text *Text) GongClean(stage *Stage) (modified bool)

Clean garbage collect unstaged instances that are referenced by Text

func (*Text) GongCopy 

func (text *Text) GongCopy() GongstructIF

func (*Text) GongDiff 

func (text *Text) GongDiff(stage *Stage, textOther *Text) (diffs []string)

GongDiff computes the diff between the instance and another instance of same gong struct type and returns the list of differences as strings

func (*Text) GongGetFieldHeaders 

func (text *Text) GongGetFieldHeaders() (res []GongFieldHeader)

func (*Text) GongGetFieldValue 

func (text *Text) GongGetFieldValue(fieldName string, stage *Stage) (res GongFieldValue)

func (*Text) GongGetGongstructName 

func (text *Text) GongGetGongstructName() string

func (*Text) GongGetIdentifier 

func (text *Text) GongGetIdentifier(stage *Stage) string

func (*Text) GongGetOrder 

func (text *Text) GongGetOrder(stage *Stage) uint

func (*Text) GongGetReferenceIdentifier 

func (text *Text) GongGetReferenceIdentifier(stage *Stage) string

GongGetReferenceIdentifier returns an identifier when it was staged (it may have been unstaged since)

func (*Text) GongGetReverseFieldOwner 

func (inst *Text) GongGetReverseFieldOwner(stage *Stage, reverseField *ReverseField) (res GongstructIF)

func (*Text) GongGetReverseFieldOwnerName 

func (inst *Text) GongGetReverseFieldOwnerName(stage *Stage, reverseField *ReverseField) (res string)

func (*Text) GongGetUUID 

func (text *Text) GongGetUUID(stage *Stage) (uuid string)

func (*Text) GongMarshallAllFields 

func (text *Text) GongMarshallAllFields(stage *Stage) (initRes string, ptrRes string)

func (*Text) GongMarshallField 

func (text *Text) GongMarshallField(stage *Stage, fieldName string) (res string)

func (*Text) GongMarshallIdentifier 

func (text *Text) GongMarshallIdentifier(stage *Stage) (decl string)

func (*Text) GongMarshallUnstaging 

func (text *Text) GongMarshallUnstaging(stage *Stage) (decl string)

func (*Text) GongReconstructPointersFromInstances 

func (reference *Text) GongReconstructPointersFromInstances(stage *Stage)

func (*Text) GongReconstructPointersFromReferences 

func (reference *Text) GongReconstructPointersFromReferences(stage *Stage, instance *Text)

func (*Text) GongSetFieldValue 

func (text *Text) GongSetFieldValue(fieldName string, value GongFieldValue, stage *Stage) error

func (*Text) SetName 

func (text *Text) SetName(name string)

for satisfaction of GongStruct interface

func (*Text) Stage 

func (text *Text) Stage(stage *Stage) *Text

Stage puts text to the model stage

func (*Text) StagePreserveOrder 

func (text *Text) StagePreserveOrder(stage *Stage, order uint)

StagePreserveOrder puts text to the model stage, and if the astrtuct was not staged before:

- force the order if the order is equal or greater than the stage.TextOrder - update stage.TextOrder accordingly

func (*Text) StageVoid 

func (text *Text) StageVoid(stage *Stage)

func (*Text) Unstage 

func (text *Text) Unstage(stage *Stage) *Text

Unstage removes text off the model stage

func (*Text) UnstageVoid 

func (text *Text) UnstageVoid(stage *Stage)

UnstageVoid removes text off the model stage

type TextUnmarshaller 

type TextUnmarshaller struct{}

func (*TextUnmarshaller) Initialize 

func (u *TextUnmarshaller) Initialize(stage *Stage, identifier string, instanceName string, preserveOrder bool) (GongstructIF, error)

func (*TextUnmarshaller) UnmarshallField 

func (u *TextUnmarshaller) UnmarshallField(stage *Stage, i GongstructIF, fieldName string, valueExpr ast.Expr, identifierMap map[string]GongstructIF) error

type TextVal 

type TextVal struct {
	Text string `xml:",chardata"`
	Val  string `xml:"val,attr"`
}

TextVal is

type Text_WOP 

type Text_WOP struct {
	Name string

	Content string

	PreserveWhiteSpace bool
}

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.