254 lines
5.6 KiB
Markdown
254 lines
5.6 KiB
Markdown
### StratWorkspaceManager:
|
|
```plantuml
|
|
@startuml
|
|
start
|
|
:Initialize StratWorkspaceManager;
|
|
note right
|
|
- workspace = null
|
|
- blocksDefined = false
|
|
- MAX_TOP_LEVEL_BLOCKS = 10
|
|
end note
|
|
|
|
if (blocklyDiv exists?) then (yes)
|
|
if (workspace exists?) then (yes)
|
|
:Dispose of existing workspace;
|
|
endif
|
|
|
|
:Load Modules and Init Workspace;
|
|
note right
|
|
Calls _loadModulesAndInitWorkspace()
|
|
end note
|
|
|
|
:Initialize Blockly Workspace;
|
|
note right
|
|
- Set blocksDefined = true
|
|
- Inject workspace into blocklyDiv
|
|
end note
|
|
else (no)
|
|
:Log error "blocklyDiv is not loaded.";
|
|
endif
|
|
|
|
:Adjust Workspace;
|
|
note right
|
|
Calls adjustWorkspace()
|
|
end note
|
|
|
|
stop
|
|
@enduml
|
|
|
|
```
|
|
### initWorkspace:
|
|
```plantuml
|
|
@startuml
|
|
participant "StratWorkspaceManager" as SWM
|
|
participant "Document" as Doc
|
|
participant "Blockly"
|
|
|
|
SWM -> Doc: getElementById('blocklyDiv')
|
|
alt blocklyDiv exists
|
|
SWM -> SWM: workspace.dispose() [if workspace exists]
|
|
SWM -> SWM: _loadModulesAndInitWorkspace()
|
|
SWM -> SWM: blocksDefined = true
|
|
SWM -> Blockly: inject('blocklyDiv', options)
|
|
else
|
|
SWM -> SWM: console.error("blocklyDiv is not loaded.")
|
|
end
|
|
@enduml
|
|
|
|
```
|
|
|
|
### _loadModulesAndInitWorkspace:
|
|
```plantuml
|
|
@startuml
|
|
participant "StratWorkspaceManager" as SWM
|
|
participant "Document" as Doc
|
|
participant "Blockly"
|
|
@startuml
|
|
participant "StratWorkspaceManager" as SWM
|
|
participant "Custom Blocks Modules" as Modules
|
|
participant "Document" as Doc
|
|
participant "Blockly"
|
|
|
|
SWM -> SWM: Check blocksDefined
|
|
alt blocksDefined is false
|
|
SWM -> Modules: Import and define modules
|
|
SWM -> SWM: blocksDefined = true
|
|
else
|
|
SWM -> SWM: Skip module loading
|
|
end
|
|
|
|
SWM -> Doc: getElementById('toolbox_advanced')
|
|
alt toolbox exists
|
|
SWM -> Blockly: inject('blocklyDiv', options)
|
|
SWM -> SWM: Workspace initialized
|
|
else
|
|
SWM -> SWM: console.error("toolbox is not loaded.")
|
|
end
|
|
@enduml
|
|
|
|
SWM -> Doc: getElementById('blocklyDiv')
|
|
alt blocklyDiv exists
|
|
SWM -> SWM: workspace.dispose() [if workspace exists]
|
|
SWM -> SWM: _loadModulesAndInitWorkspace()
|
|
SWM -> SWM: blocksDefined = true
|
|
SWM -> Blockly: inject('blocklyDiv', options)
|
|
else
|
|
SWM -> SWM: console.error("blocklyDiv is not loaded.")
|
|
end
|
|
@enduml
|
|
|
|
```
|
|
### adjustWorkspace:
|
|
```plantuml
|
|
@startuml
|
|
participant "StratWorkspaceManager" as SWM
|
|
participant "Document" as Doc
|
|
participant "Blockly"
|
|
|
|
SWM -> Doc: getElementById('blocklyDiv')
|
|
alt blocklyDiv and workspace exist
|
|
SWM -> Blockly: svgResize(workspace)
|
|
else
|
|
SWM -> SWM: console.error("Cannot resize workspace.")
|
|
end
|
|
@enduml
|
|
|
|
```
|
|
### compileStrategyJson:
|
|
```plantuml
|
|
@startuml
|
|
start
|
|
:Check if workspace is available;
|
|
if (workspace exists?) then (yes)
|
|
:Get strategy name from name_box;
|
|
:Generate strategy JSON;
|
|
note right
|
|
Calls _generateStrategyJsonFromWorkspace()
|
|
end note
|
|
if (strategyJson is null?) then (yes)
|
|
:Log error "Failed to generate strategy JSON.";
|
|
stop
|
|
endif
|
|
:Serialize workspace to XML;
|
|
:Return JSON string containing strategy data;
|
|
else (no)
|
|
:Log error "Workspace is not available.";
|
|
stop
|
|
endif
|
|
@enduml
|
|
|
|
|
|
```
|
|
### _generateStrategyJsonFromWorkspace:
|
|
```plantuml
|
|
@startuml
|
|
start
|
|
:Categorize orphaned blocks;
|
|
note right
|
|
Calls _categorizeOrphanedBlocks(workspace)
|
|
end note
|
|
|
|
:Calculate totalTopLevelBlocks;
|
|
|
|
if (totalTopLevelBlocks > MAX_TOP_LEVEL_BLOCKS?) then (yes)
|
|
:Log error "Too many top-level blocks.";
|
|
:Alert user;
|
|
:Return null;
|
|
stop
|
|
else (no)
|
|
:Create strategy JSON;
|
|
note right
|
|
Calls _createStrategyJson(initializationBlocks, actionBlocks)
|
|
end note
|
|
:Return strategy JSON;
|
|
stop
|
|
endif
|
|
@enduml
|
|
|
|
```
|
|
|
|
### _categorizeOrphanedBlocks:
|
|
```plantuml
|
|
@startuml
|
|
start
|
|
:Get top-level blocks from workspace;
|
|
|
|
:Initialize initializationBlocks and actionBlocks arrays;
|
|
|
|
:Initialize index = 0;
|
|
|
|
while (index < total number of blocks?) is (yes)
|
|
:Get block at index;
|
|
if (block.type is initialization type?) then (yes)
|
|
:Add block to initializationBlocks;
|
|
else if (block.type is action type?) then (yes)
|
|
:Add block to actionBlocks;
|
|
else
|
|
:Log warning "Block type not allowed as top-level block.";
|
|
endif
|
|
:Increment index;
|
|
endwhile
|
|
|
|
:Return { initializationBlocks, actionBlocks };
|
|
stop
|
|
@enduml
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
### _createStrategyJson:
|
|
```plantuml
|
|
@startuml
|
|
start
|
|
:Initialize empty statements array;
|
|
|
|
:Initialize index = 0;
|
|
|
|
while (index < number of initializationBlocks?) is (yes)
|
|
:Get block at index from initializationBlocks;
|
|
:Convert block to JSON;
|
|
:Add to statements array;
|
|
:Increment index;
|
|
endwhile
|
|
|
|
:Reset index = 0;
|
|
|
|
while (index < number of actionBlocks?) is (yes)
|
|
:Get block at index from actionBlocks;
|
|
:Convert block to JSON;
|
|
:Add to statements array;
|
|
:Increment index;
|
|
endwhile
|
|
|
|
:Create strategy JSON with type 'strategy' and statements;
|
|
:Return strategy JSON;
|
|
stop
|
|
@enduml
|
|
```
|
|
|
|
### _loadWorkspaceFromXml:
|
|
```plantuml
|
|
@startuml
|
|
participant "StratWorkspaceManager" as SWM
|
|
participant "Blockly"
|
|
participant "Workspace" as WS
|
|
|
|
SWM -> SWM: Check if workspace is initialized
|
|
alt workspace exists
|
|
SWM -> Blockly: textToDom(workspaceXmlText)
|
|
alt workspaceXml is valid
|
|
SWM -> WS: clear()
|
|
SWM -> Blockly: domToWorkspace(workspaceXml, workspace)
|
|
else
|
|
SWM -> SWM: console.error('Invalid workspace XML.')
|
|
SWM -> User: alert('Invalid workspace data.')
|
|
end
|
|
else
|
|
SWM -> SWM: console.error('Workspace is not initialized.')
|
|
end
|
|
@enduml
|
|
|
|
|
|
``` |