/// <summary>
/// Fills in the defined color keys of the opened simulation
/// </summary>
public static void UpdateColorKeys(TextEdit textEdit, IProcessingData processingData)
{
textEdit.ClearColors();
List <string> booleanInputKeys = processingData.InputRegisters.BooleanKeys;
foreach (string key in booleanInputKeys)
{
textEdit.AddKeywordColor(key, BooleanInputColor);
}
foreach (string key in St.Boolean.Constant.Values)
{
textEdit.AddKeywordColor(key, BooleanInputColor);
}
List <string> booleanOutputKeys = processingData.OutputRegisters.BooleanKeys;
foreach (string key in booleanOutputKeys)
{
textEdit.AddKeywordColor(key, BooleanOutputColor);
}
List <string> IntegerInputKeys = processingData.InputRegisters.IntegerKeys;
foreach (string key in IntegerInputKeys)
{
textEdit.AddKeywordColor(key, IntegerInputColor);
}
// Godot already forces integer static inputs and colors them. (They can not be deleted so far)
textEdit.AddColorOverride("number_color", IntegerInputColor);
List <string> IntegerOutputKeys = processingData.OutputRegisters.IntegerKeys;
foreach (string key in IntegerOutputKeys)
{
textEdit.AddKeywordColor(key, IntegerInputColor);
}
}
public string ProcessGarbage(string name, double weight, double volumePerKg, string type)
{
if (this.requarementsAreSet)
{
bool requarementsAreSatisfied = true;
if (this.typeOfGarbage == type)
{
requarementsAreSatisfied = this.capitalBalance >= this.minCapitalBalance &&
this.energyBalance >= this.minEnergyBalance;
}
if (!requarementsAreSatisfied)
{
return(ProcessingDeniedMessage);
}
}
IWaste someWaste = this.wasteFactory.Create(name, weight, volumePerKg, type);
IProcessingData processedData = this.garbageProcessor.ProcessWaste(someWaste);
this.capitalBalance += processedData.CapitalBalance;
this.energyBalance += processedData.EnergyBalance;
string formattedMessage = string.Format(ProcessGarbageMessageToFormat, someWaste.Weight.ToString(FloatingPointNumberFormat), someWaste.Name);
return(formattedMessage);
// return $"{someWaste.Weight} kg of {someWaste.Name} successfully processed!";
}
public string ProcessGarbage(string name, double weight, double volumePerKg, string type)
{
if (this.requirmentsAreSet == true)
{
bool requirmentsAreSatisfied = true;
if (this.typeOfGarbage == type)
{
requirmentsAreSatisfied = this.capitalBalance >= minimumCapitalBalance &&
this.energyBalance >= this.minimumEnergyBalance;
}
if (requirmentsAreSatisfied == false)
{
return("Processing Denied!");
}
}
IWaste someWaste = this.wasteFactory.Create(name, weight, volumePerKg, type);
IProcessingData processedData = this.garbageProcessor.ProcessWaste(someWaste);
this.capitalBalance += processedData.CapitalBalance;
this.energyBalance += processedData.EnergyBalance;
return($"{(someWaste.Weight):f2} kg of {someWaste.Name} successfully processed!");
}
public string ProcessGarbage(string name, double weight, double volumePerKg, string type)
{
// Bonus task: Check current Management Min Requirements
if (this.hasRequierementsSet)
{
bool meetsRequirements = true;
if (this.garbageTypeRequirement == type)
{
meetsRequirements = this.energyBalance >= this.minEnergyBalanceRequirement &&
this.capitalBalance >= this.minCapitalBalanceRequirement;
}
if (!meetsRequirements)
{
return(ProcessingDeniedMessage);
}
}
IWaste waste = this.wasteFactory.Create(name, weight, volumePerKg, type);
IProcessingData processedData = this.garbageProcessor.ProcessWaste(waste);
this.capitalBalance += processedData.CapitalBalance;
this.energyBalance += processedData.EnergyBalance;
//return $"{waste.Weight:f2} kg of {waste.Name} successfully processed!";
var formattedMessage = string.Format(
ProcessedGarbageMessageToFormat,
waste.Weight.ToString(FloatingPointNumberFormat),
waste.Name);
return(formattedMessage);
}
public string ProcessGarbage(string name, double weight, double volumePerKg, string type)
{
if (this.requirementsAreSet)
{
bool requirementsAreSatisfied = true;
if (this.requiredGarbageType == type)
{
requirementsAreSatisfied = this.capitalBalance >= this.minCapitalBalance && this.energyBalance >= this.minEnergyBalance;
}
if (!requirementsAreSatisfied)
{
return($"Processing Denied!");
}
}
IWaste waste = this.wasteFactory.Create(name, weight, volumePerKg, type);
IProcessingData processingData = this.garbageProcessor.ProcessWaste(waste);
this.capitalBalance += processingData.CapitalBalance;
this.energyBalance += processingData.EnergyBalance;
return($"{waste.Weight:F2} kg of {waste.Name} successfully processed!");
}
public GarbageProcessor(IProcessingData processingData, IStrategyHolder strategyHolder)
{
this.ProcessingData = processingData;
this.StrategyHolder = new StrategyHolder();
this.InitialiseStrategyHoder();
}
public string ProcessGarbage(string name, double weight, double volumePerKg, string type)
{
//Add checks for ChangedMenagementRequirement
if (requirenmentsAreSet)
{
bool requirementsAreSatisfied = true;
if (this.typeOfGarbage == type)
{
requirementsAreSatisfied = this.capitalBalance >= minimumCapitalBalance && this.energyBalance >= minimumEnergyBalance;
}
if (!requirementsAreSatisfied)
{
return(ProcessingDeniedMessage);
}
}
IWaste someWaste = this.wasteFactory.Create(name, weight, volumePerKg, type);
IProcessingData processedData = this.garbageProcessor.ProcessWaste(someWaste);
capitalBalance += processedData.CapitalBalance;
energyBalance += processedData.EnergyBalance;
string formatedMessage = string.Format(ProcessGarbageMessageToFormat, someWaste.Weight.ToString(FloatingPointNumberFormat), someWaste.Name);
return(formatedMessage);
}
public void AddData(IProcessingData newData)
{
if (newData != null)
{
this.data.Add(newData);
}
}
/// <summary>
/// If there is only one word in the action box, it can be assumed that the user likes to activate / set a boolean.
/// From a feature request: It seem to be like this in other SFC-ST actions.
/// </summary>
private static Boolean InterpretAsDirectBooleanAssignment(string targetWord, IProcessingData context)
{
if (context.OutputRegisters.ContainsBoolean(targetWord))
{
return(new Boolean(targetWord, new St.Boolean.Constant("true"), context));
}
return(null);
}
public void GivingNullGarbageToProcessShouldThrowError()
{
IStrategyHolder testStrategy = new StrategyHolder();
testStrategy.AddStrategy(typeof(RecyclableGarbage), new RecyclableStrategy());
this.garbageProcessor = new GarbageProcessor(testStrategy);
IWaste burnableWasteTestObject = null;
IProcessingData tempData = this.garbageProcessor.ProcessWaste(burnableWasteTestObject);
}
public void GarbageProcessorShouldThrowErrorIfNoStrategyIsPresentForGivenType()
{
IStrategyHolder testStrategy = new StrategyHolder();
testStrategy.AddStrategy(typeof(RecyclableGarbage), new RecyclableStrategy());
this.garbageProcessor = new GarbageProcessor(testStrategy);
IWaste burnableWasteTestObject = new BurnableGarbage("RecyclMePls", 10, 10);
IProcessingData tempData = this.garbageProcessor.ProcessWaste(burnableWasteTestObject);
}
private void AddActionEditor(IProcessingData data)
{
Node node = ((PackedScene)GD.Load(EditorScenePath)).Instance();
ActionEditor actionEditor = (ActionEditor)node;
_actionEditors.Add(actionEditor);
GetNode <BoxContainer>("ScrollContainer/VerticalBoxContainer").AddChild(actionEditor);
actionEditor.InitializeWith(this, data);
}
public string ProcessGarbage(string name, double volumePerKg, double weight, string type)
{
var currentWaste = this.wasteFactory.CreateWaste(name, volumePerKg, weight, type);
IProcessingData info = this.garbageProcessor.ProcessWaste(currentWaste);
this.energyBalance += info.EnergyBalance;
this.capitalBalance += info.CapitalBalance;
return($"{currentWaste.Weight:F2} kg of {currentWaste.Name} successfully processed!");
}
public void ProcessWaste_WithVallidWaste_ShoudReturnCorrectEnergyAndCapitalBalance()
{
IProcessingData result = this.processor.ProcessWaste(this.waste);
double expectedEnergyBalance = 464.0;
double capitalEnergyBalance = 0.0;
Assert.AreEqual(expectedEnergyBalance, result.EnergyBalance, "Energy Balance not calculated correctly");
Assert.AreEqual(capitalEnergyBalance, result.CapitalBalance, "CapitalBalance not calculated correctly");
}
public void InitializeWith(ActionEditorBox controller, IProcessingData data)
{
_controller = controller;
_actionDescriptionNode = GetNode <TextEdit>("ActionTextEditor");
_actionDescriptionNode.Connect("focus_exited", this, nameof(OnTextEditorFocusExited));
_actionDescriptionNode.Connect("text_changed", this, nameof(OnActionTextChanged));
_qualifierNode = GetNode <MenuButton>("ActionQualifierSelector");
ConfigureQualifierPopupMenu();
ActionMaster.UpdateColorKeys(_actionDescriptionNode, data);
}
/// <summary>
/// Converts the string to a logical model.
/// </summary>
public static BooleanExpression AsBooleanExpression(string transition, IProcessingData context)
{
Terminals data = new Terminals(transition);
BooleanExpression mainExpression = InterpretBooleanExpression(data, context);
if (!data.IsEndReached)
{
mainExpression = AppendFailureInfo(data, mainExpression);
}
return(mainExpression);
}
private static BooleanExpression InterpretBoolean(string word, IProcessingData context)
{
if (Constant.Values.Contains(word))
{
return(new Constant(word));
}
if (context.HasBoolVariable(word))
{
return(new StepReference(word));
}
return(new PlantReference(word, context));
}
public void GarbageProcessorProperlyProcessingBurnableGarbageWithBurnableStrategy()
{
IStrategyHolder testStrategy = new StrategyHolder();
testStrategy.AddStrategy(typeof(BurnableGarbage), new BurnableStrategy());
this.garbageProcessor = new GarbageProcessor(testStrategy);
IWaste burnableWasteTestObject = new BurnableGarbage("BurnItUp", 10, 10);
IProcessingData tempData = this.garbageProcessor.ProcessWaste(burnableWasteTestObject);
Assert.AreEqual(0, tempData.CapitalBalance);
Assert.AreEqual(80, tempData.EnergyBalance);
}
/// <summary>
/// Converts the string to a numerical Expression.
/// </summary>
public static NumericalExpression AsNumericalExpression(string word, IProcessingData context)
{
if (int.TryParse(word, out int number))
{
return(new Constant(number));
}
if (context.HasIntVariable(word))
{
return(new StepReference(word));
}
return(new PlantReference(word, context));
}
public string ProcessGarbage(string[] parameters)
{
IWaste garbage = this.InstantiateWaste(parameters);
if (this.BalanceManager.CheckWasteForProcessing(garbage))
{
IProcessingData result = this.GarbageProcessor.ProcessWaste(garbage);
this.BalanceManager.ApplyProcessingResult(result);
return(string.Format("{0:F2} kg of {1} successfully processed!", garbage.Weight, garbage.Name));
}
return("Processing Denied!");
}
public override void Execute()
{
string name = this.Parameters[0];
double volumePerKg = double.Parse(this.Parameters[2]);
double weight = double.Parse(this.Parameters[1]);
string garbageTypeName = this.Parameters[3];
IWaste waste = null;
var garbageTypes = Assembly.GetExecutingAssembly()
.GetTypes()
.Where(t => t.GetCustomAttributes().Any(a => a.GetType() == typeof(GarbageAttribute)));
foreach (var garbageType in garbageTypes)
{
var attribute = (GarbageAttribute)garbageType.GetCustomAttribute(typeof(GarbageAttribute));
if (attribute.Name == garbageTypeName)
{
waste = (IWaste)Activator.CreateInstance(
garbageType,
new object[] { name, volumePerKg, weight });
break;
}
}
if (waste == null)
{
return;
}
IProcessingData processData = this.garbageProcessor.ProcessWaste(waste);
IChangeManagementRequirement requirement =
this.repository.GetManagmentRequirement(garbageTypeName);
if (requirement != null)
{
if (this.repository.Energy < requirement.EnergyBalance ||
this.repository.Capital < requirement.CapitalBalance)
{
this.inputOutput.WriteMessage("Processing Denied!");
return;
}
}
this.repository.Add(processData);
this.inputOutput.WriteMessage($"{waste.Weight:f2} kg of {waste.Name} successfully processed!");
}
/// <summary>
/// Called when the model has changed or is initialized.
/// </summary>
public void UpdateAction(ActionEntity action, IProcessingData context)
{
_selectedQualifier = action.Qualifier;
SetQualifierText((int)_selectedQualifier);
_actionDescriptionNode.Text = action.Action;
_isRelevant = !string.IsNullOrEmpty(_actionDescriptionNode.Text);
AssignmentExpression expression = ActionMaster.InterpretTransitionText(action.Action, context);
_actionDescriptionNode.HintTooltip = expression == null ? "???" : expression.ToString();
bool validExpression = expression != null && expression.IsValid();
Color background = validExpression ? new Color(1, 0, 0, 0f) : new Color(1, 0, 0, 0.2f);
_actionDescriptionNode.AddColorOverride("background_color", background);
}
//{name}|{weight}|{volumePerKg}|{type}
public override string Execute()
{
string name = base.Data[1];
double weight = double.Parse(base.Data[2]);
double volumePerKg = double.Parse(base.Data[3]);
string type = base.Data[4];
IWaste garbage = this.wasteFactory.CreateWaste(name, weight, volumePerKg, type);
IProcessingData data = this.processor.ProcessWaste(garbage);
this.repo.CalculateBalance(data);
return($"{(garbage.Weight):F2} kg of { garbage.Name} successfully processed!");
}
private void AssignActionsFrom(PatchEntity source, IProcessingData context)
{
_actions = new Dictionary <ActionQualifier, List <AssignmentExpression> >();
foreach (ActionQualifier qualifier in (ActionQualifier[])Enum.GetValues(typeof(ActionQualifier)))
{
_actions.Add(qualifier, new List <AssignmentExpression>());
}
for (int i = 0; i < source.ActionEntries.Count; i++)
{
AssignmentExpression expression = ActionMaster.InterpretTransitionText(source.ActionEntries[i].Action, context);
_actions[source.ActionEntries[i].Qualifier].Add(expression);
}
}
public bool UpdateData(IProcessingData data)
{
if (this.isManagementSet &&
data.Type == this.typeOfGarbageToCheck &&
(this.capitalBalanceMin > this.capital ||
this.energyBalanceMin > this.energy))
{
return(false);
}
this.energy += data.EnergyBalance;
this.capital += data.CapitalBalance;
return(true);
}
public string ProcessGarbage(string name, double weight, double volumePerKg, string type)
{
IWaste someWaste = this.wasteFactory.Create(name, weight, volumePerKg, type);
IProcessingData processedData = this.garbageProcessor.ProcessWaste(someWaste);
this.capitalBalance += processedData.CapitalBalance;
this.energyBalance += processedData.EnergyBalance;
string formattedMessage = string.Format(ProcessGarbageMessageToFormat,
someWaste.Weight.ToString(FloatingPointNumberFormat),
someWaste.Name);
return(formattedMessage);
}
public string ProcessGarbage(string[] parameters)
{
IWaste garbage = InstantiateWaste(parameters);
if (this.BalanceManager.CheckWasteForProcessing(garbage))
{
IProcessingData processingData = this.GarbageProcessor.ProcessWaste(garbage);
this.BalanceManager.ApplyProcessedResult(processingData);
return($"{garbage.Weight:f2} kg of {garbage.Name} successfully processed!");
}
else
{
return("Processing Denied!");
}
}
/// <inheritdoc/>
public async Task ProcessDataAsync(IProcessingData data, CancellationToken cancellationToken = default)
{
if (data is null)
{
throw new ArgumentNullException(nameof(data));
}
using var _ = _logger.BeginScope("Processing data {@data}.", data);
_logger.LogInformation("Start processing.");
await _uow.ProcessDataAsync(data, cancellationToken).ConfigureAwait(false);
await _uow.SaveAsync(cancellationToken).ConfigureAwait(false);
_logger.LogInformation("End processing.");
}
public void ProcessWaste()
{
double expectedRecCapital = 4000;
double expectedRecBurnEnergy = -5.7;
double expectedBurnEnergy = 97.0012;
double expectedCapital = 0;
double expectedStorCapital = -2.2961;
double expectedStorEnergy = -0.4592;
BurnableGarbage burnGarbage = new BurnableGarbage("Burnable", 3.657, 33.156);
RecyclableGarbage recGarbage = new RecyclableGarbage("rec", 1.14, 10);
StorableGarbage storGarbage = new StorableGarbage("stor", 1.57, 2.25);
IStrategyHolder strategyHolder = new StrategyHolder();
strategyHolder.AddStrategy(
typeof(BurnableDisposableAttribute),
new BurnableDisposalStrategy());
strategyHolder.AddStrategy(
typeof(RecyclableDisposableAttribute),
new RecyclableDisposalStrategy());
strategyHolder.AddStrategy(
typeof(StorableDisposableAttribute),
new StorableDisposalStrategy());
IGarbageProcessor processor = new GarbageProcessor(strategyHolder);
IProcessingData processData = processor.ProcessWaste(burnGarbage);
Assert.AreEqual(expectedBurnEnergy, Math.Round(processData.EnergyBalance, 4));
Assert.AreEqual(expectedCapital, processData.CapitalBalance);
processData = processor.ProcessWaste(recGarbage);
Assert.AreEqual(expectedRecBurnEnergy, Math.Round(processData.EnergyBalance, 1));
Assert.AreEqual(expectedRecCapital, processData.CapitalBalance);
processData = processor.ProcessWaste(storGarbage);
Assert.AreEqual(expectedStorEnergy, Math.Round(processData.EnergyBalance, 4));
Assert.AreEqual(expectedStorCapital, Math.Round(processData.CapitalBalance, 4));
}
public string ProcessGarbage(string name, double weight, double volumePerKg, string type)
{
if (type == restrictedType)
{
if (energyBalance < energyRequired || capitalBalance < capitalRequired)
{
return("Processing Denied!");
}
}
IWaste waste = this.wasteFactory.CreateWaste(name, weight, volumePerKg, type);
IProcessingData result = this.garbageProcessor.ProcessWaste(waste);
this.energyBalance += result.EnergyBalance;
this.capitalBalance += result.CapitalBalance;
return($"{weight:f2} kg of {name} successfully processed!");
}
