builder

type Element struct {
	Id            string
	Name          string
	BpmnType      string
	XMLElement    any
	NextStateCode string
}

type ElementProcessor interface {
	// CreateElements creates new elements and adds them to the process and/or subprocess for the given element BPMN processor type
	CreateElements(process *Process, subprocess *SubProcess, spElements *XMLSubProcess, elements *XMLBPMNElements, ps *ProcessorSet) error
	// GenerateElementNextStateCodes generates the code for the next state for each element of the element BPMN processor type
	GenerateElementNextStateCodes(process *Process, defs *XMLBPMNElements, ps *ProcessorSet)
	// GenerateNextStateCode generates the code of the next elements for the current element
	GenerateNextStateCode(currentElement *Element, nextElements []*Element, process *Process, ps *ProcessorSet) string
	// GenerateCodeForNewElement generates code for a new instance of this BPMN element
	GenerateCodeForNewElement(currentElement, newElement *Element, process *Process, ps *ProcessorSet) string
}

type EndEventProcessor struct {
}

type ExclusiveGatewayProcessor struct {
}

type IDName interface {
	GetId() string
	GetName() string
}

type Incoming interface {
	GetIncoming() []string
}

type Outgoing interface {
	GetOutgoing() []string
}

type OutputDefProcessCode struct {
	InputFile  string // Input BPMN file path including file name
	OutputFile string // Output go code path including file name
	Defs       *XMLBPMNDefinitions
	OutputCode *ProcessCode // Output code
	PkgName    string
}

type ParallelGatewayProcessor struct {
}

type Process struct {
	Id           string
	Name         string
	StartEvent   *Element
	Elements     []*Element
	AllElements  []*Element
	SubProcesses []*SubProcess
	UserTasks    []*Element

	GoModule            string
	GoPackage           string
	GoStartVariableName string
	GoStartVariableType string
	// contains filtered or unexported fields
}

type ProcessCode struct {
	Process *Process
	Code    *string
}

type ProcessGenerator struct {
	// Input BPMN file or path to process BPMN files
	Input string

	// Output BPMN file or path for generated code
	Output string

	// Generates the output file path/name for a given input file, and the input/output args.
	OutputFileNameGenerator func(inputFile string, process *XMLBPMNProcess, input, output string, isOutputDir bool) string

	// Stores output definitions and code given input file path and name
	OutputGen map[string]*OutputDefProcessCode

	ProcessTemplate string
	ProcessorSet    *ProcessorSet
	PackageName     string
}

type ProcessorSet struct {
	ElementProcessors   []ElementProcessor          // Ordered sequence of element processors
	ElementProcessorMap map[string]ElementProcessor // Look up processors by key
}

type Script interface {
	GetScript() string
}

type ScriptProcessor struct {
}

type SequenceFlowProcessor struct {
}

type StartEventProcessor struct {
}

type SubProcess struct {
	Id           string
	Name         string
	Elements     []*Element
	SubProcesses []*SubProcess
	// contains filtered or unexported fields
}

type SubProcessProcessor struct {
}

type UserTaskProcessor struct {
}

type XMLBPMNDefinitions struct {
	XMLName xml.Name       `xml:"definitions"`
	Process XMLBPMNProcess `xml:"process"`
}

type XMLBPMNElements struct {
	StartEvents       []XMLBPMNStartEvent   `xml:"startEvent"`
	ExclusiveGateways []XMLExclusiveGateway `xml:"exclusiveGateway"`
	ParallelGateways  []XMLParallelGateway  `xml:"parallelGateway"`
	SequenceFlows     []XMLSequenceFlow     `xml:"sequenceFlow"`
	UserTasks         []XMLUserTask         `xml:"userTask"`
	EndEvents         []XMLEndEvent         `xml:"endEvent"`
	ScriptTasks       []XMLScriptTask       `xml:"scriptTask"`
	SubProcesses      []XMLSubProcess       `xml:"subProcess"`
}

type XMLBPMNProcess struct {
	XMLIDName
	XMLBPMNElements
	XMLName             xml.Name `xml:"process"`
	GoModule            string   `xml:"module,attr"`
	GoPackage           string   `xml:"package,attr"`
	GoStartVariableName string   `xml:"startVariableName,attr"`
	GoStartVariableType string   `xml:"startVariableType,attr"`
}

type XMLBPMNStartEvent struct {
	XMLName xml.Name `xml:"startEvent"`
	XMLIDName
	XMLOutgoingElements
	TimerEventDefinition XMLTimerEventDefinition `xml:"timerEventDefinition"`
}

type XMLConditionExpression struct {
	XMLName             xml.Name `xml:"conditionExpression"`
	Type                string   `xml:"type,attr"`
	ConditionExpression string   `xml:"conditionExpression"`
}

type XMLEndEvent struct {
	XMLIDName
	XMLIncomingElements
	XMLName xml.Name `xml:"endEvent"`
}

type XMLExclusiveGateway struct {
	XMLIDName
	XMLIncomingElements
	XMLOutgoingElements
	XMLName xml.Name `xml:"exclusiveGateway"`
	Default string   `xml:"default,attr"`
}

type XMLIDName struct {
	Id   string `xml:"id,attr"`
	Name string `xml:"name,attr"`
}

type XMLIncomingElements struct {
	Incoming []string `xml:"incoming"`
}

type XMLMultiInstanceLoopCharacteristics struct {
	IsSequentialAtt    string `xml:"isSequential,attr"`
	LoopCardinalityAtt string `xml:"loopCardinality"`
}

type XMLOutgoingElements struct {
	Outgoing []string `xml:"outgoing"`
}

type XMLParallelGateway struct {
	XMLIDName
	XMLIncomingElements
	XMLOutgoingElements
	XMLName xml.Name `xml:"parallelGateway"`
}

type XMLScript struct {
	Script string `xml:"script"`
}

type XMLScriptTask struct {
	XMLIDName
	XMLIncomingElements
	XMLOutgoingElements
	XMLScript
	XMLName xml.Name `xml:"scriptTask"`
}

type XMLSequenceFlow struct {
	XMLIDName
	XMLConditionExpression
	XMLName   xml.Name `xml:"sequenceFlow"`
	SourceRef string   `xml:"sourceRef,attr"`
	TargetRef string   `xml:"targetRef,attr"`
}

type XMLSubProcess struct {
	XMLIDName
	XMLBPMNElements
	XMLIncomingElements
	XMLOutgoingElements
	XMLName                          xml.Name                            `xml:"subProcess"`
	MultiInstanceLoopCharacteristics XMLMultiInstanceLoopCharacteristics `xml:"multiInstanceLoopCharacteristics"`
}

type XMLTimeCycle struct {
	XMLName       xml.Name `xml:"timeCycle"`
	Type          string   `xml:"type,attr"`
	TimeCycle     string   `xml:"timeCycle"`
	ISO8601       dynamap.ISO8601DateTime
	DurationMicro int64
}

type XMLTimerEventDefinition struct {
	XMLName xml.Name `xml:"timerEventDefinition"`
	XMLTimeCycle
}

type XMLUserTask struct {
	XMLIDName
	XMLIncomingElements
	XMLOutgoingElements
	XMLName    xml.Name `xml:"userTask"`
	GoDataType string   `xml:"dataType,attr"`
}