public async void sdf()
{
// Prepare
var expectedDestination = new DestinationNode
{
AcceptedProducts = new List <ProductType>(new []
{
ProductTypes.Paket
}),
Location = Locations.PZ_50
};
var testee = new DestinationLocator(new []
{
expectedDestination
});
var order = OrderBuilder
.At(Locations.KölnerDom)
.From(2020, 12, 07)
.Every(DayOfWeek.Monday)
.Between(new TimeSpan(16, 00, 00), new TimeSpan(20, 00, 00))
.Load(1, ContainerTypes.Kiste, ProductTypes.Paket)
.Build();
// Execute
var result = await testee.GetDestination(order.Positions.First());
// Verify
Assert.Equal <DestinationNode>(expectedDestination, result);
}
public void OptimizeTest_InputHasDependenciesOfTwoGroup_GivesProperOutput()
{
DestinationNode locA = new DestinationNode("Location A");
DestinationNode locC = new DestinationNode("Location C", locA);
DestinationNode locB = new DestinationNode("Location B", locC);
DestinationNode locE = new DestinationNode("Location D");
DestinationNode locF = new DestinationNode("Location E", locE);
DestinationNode locD = new DestinationNode("Location F", locF);
List <DestinationNode> allLocations = new List <DestinationNode> {
locB,
locF,
locD,
locC,
locA,
locE
};
List <DestinationNode> expectedLocations = new List <DestinationNode>
{
locA,
locC,
locB,
locE,
locF,
locD
};
Optimizer optimizer = new Optimizer(allLocations);
CollectionAssert.AreEqual(expectedLocations, optimizer.Optimize());
}
/// <summary>
/// Compiles the supplied expression tree to the CSharp code string.
/// </summary>
/// <param name="resultNode">The root node of the expression tree.</param>
/// <returns>The python script representation of the expression tree.</returns>
public string Compile(DestinationNode resultNode)
{
_resultCode = new StringBuilder();
//_resultNodeVisited = false;
Visit(resultNode);
return _resultCode.ToString();
}
/// <summary>
/// Compiles the supplied expression tree to the Python prepared script string.
/// </summary>
/// <param name="resultNode">The root node of the expression tree.</param>
/// <returns>The python prepared script representation of the expression tree.</returns>
public string PrepareScript(DestinationNode resultNode)
{
_isInPrepareMode = true;
string script = Compile(resultNode);
_isInPrepareMode = false;
return script;
}
public override IDictionary<string, string> PrepareMultipleScripts(DestinationNode node)
{
try
{
return NodeCompiler.PrepareMultipleScripts(node);
}
catch (Exception ex)
{
throw new ExpressionTreeCompilerException("Can't compile the tree. See inner exception for details.", ex);
}
}
/// <summary>
/// Precompile the expression tree into a prepared script.
/// </summary>
/// <param name="node">Root node of the expression tree that should be compiled and executed.</param>
/// <param name="parametresToReplace">String value to replace the placeholder in the script</param>
/// <returns>Prepared script.</returns>
public override string PrepareScript(DestinationNode node, IDictionary<string, string> parametresToReplace)
{
try
{
return NodeCompiler.PrepareScript(node, parametresToReplace);
}
catch (Exception ex)
{
throw new ExpressionTreeCompilerException("Can't compile the tree. See inner exception for details.", ex);
}
}
public void DestinationsNodeTest()
{
FormatterNode formatter = new TextFormatterNode();
SinkNode sink = new CustomSinkNode();
DestinationNode node = new DestinationNode();
GeneratedApplicationNode.Nodes.Add(node);
node.Formatter = formatter;
node.Sink = sink;
Assert.AreEqual(formatter, node.Formatter);
Assert.AreEqual(sink, node.Sink);
}
public void OptimizeTest_DestinationIsThePreviousOfMultipleDestinations_ThrowsException()
{
DestinationNode locA = new DestinationNode("Location A");
DestinationNode locB = new DestinationNode("Location B", locA);
DestinationNode locC = new DestinationNode("Location C", locA);
List <DestinationNode> allLocations = new List <DestinationNode> {
locA,
locB,
locC
};
Optimizer optimizer = new Optimizer(allLocations);
optimizer.Optimize();
}
/// <summary>
/// Compiles the supplied expression tree to the CSharp prepared code string.
/// </summary>
/// <param name="resultNode">The root node of the expression tree.</param>
/// <param name="parametresToReplace">String value to replace the placeholder in the script</param>
/// <returns>The python prepared script representation of the expression tree.</returns>
public string PrepareScript(DestinationNode resultNode, IDictionary<string, string> parametresToReplace)
{
_isInPrepareMode = true;
var script = Compile(resultNode);
_isInPrepareMode = false;
if (parametresToReplace != null && parametresToReplace.Count > 0)
{
foreach (var str in parametresToReplace)
{
script = script.Replace(str.Key, str.Value);
}
}
return script;
}
public void OptimizeTest_InputHasCircularDependency_ThrowsException()
{
DestinationNode locA = new DestinationNode("Location A");
DestinationNode locB = new DestinationNode("Location B");
DestinationNode locC = new DestinationNode("Location C");
locA.Previous = locB;
locB.Previous = locC;
locC.Previous = locA;
List <DestinationNode> allLocations = new List <DestinationNode> {
locA,
locB,
locC
};
Optimizer optimizer = new Optimizer(allLocations);
optimizer.Optimize();
}
/// <summary>
/// Creates the destination node from connector.
/// </summary>
/// <param name="objectsCollection">The objects collection.</param>
/// <param name="connector">The connector.</param>
/// <returns>DestinationNode.</returns>
public DestinationNode CreateDestinationNodeFromConnector(ICollection<IExpressionObjectBase> objectsCollection, IConnectorIn connector)
{
RestoreConnections(objectsCollection);
Validate(objectsCollection);
_values = new Dictionary<string, object>();
if (connector.Connection != null && connector.Connection.Source != null)
{
var destinationNode = new DestinationNode();
destinationNode.ResultNodes.Add(
CreateResultNode(connector, connector.DataType, Constants.Result));
return destinationNode;
}
return null;
}
public void Evaluate(float timeInSecond)
{
SourceNode?.Evaluate(timeInSecond);
DestinationNode?.Evaluate(timeInSecond);
if (SourceNode == null)
{
Runtime.CGfxAnimationRuntime.CopyPose(OutPose, DestinationNode.OutPose);
}
if (DestinationNode == null)
{
Runtime.CGfxAnimationRuntime.CopyPose(OutPose, SourceNode.OutPose);
}
if (EvaluateWeight != null)
{
Weight = EvaluateWeight.Invoke();
}
Runtime.CGfxAnimationRuntime.BlendPose(OutPose, SourceNode.OutPose, DestinationNode.OutPose, Weight);
}
public void OptimizeTest_InputHasTwoDependencies_GivesProperOutput()
{
DestinationNode locA = new DestinationNode("Location A");
DestinationNode locC = new DestinationNode("Location C", locA);
DestinationNode locB = new DestinationNode("Location B", locC);
List <DestinationNode> allLocations = new List <DestinationNode> {
locB,
locC,
locA
};
List <DestinationNode> expectedLocations = new List <DestinationNode>
{
locA,
locC,
locB
};
Optimizer optimizer = new Optimizer(allLocations);
CollectionAssert.AreEqual(expectedLocations, optimizer.Optimize());
}
private void ImagesTreeList_DragDrop(object sender, DragEventArgs e)
{
DevExpress.XtraTreeList.Nodes.TreeListNode DestinationNode;
Point pt = ((DevExpress.XtraTreeList.TreeList)sender).PointToClient(new Point(e.X, e.Y));
//DevExpress.XtraTreeList.Nodes.TreeListNode DestinationNode = ((DevExpress.XtraTreeList.Nodes.TreeListNode)sender).Calc
var _Info = ImagesTreeList.CalcHitInfo(pt);
gto:
DestinationNode = _Info.Node;
if (DestinationNode == null)
{
goto gto;
}
DevExpress.XtraTreeList.Nodes.TreeListNode _Node = (DevExpress.XtraTreeList.Nodes.TreeListNode)e.Data.GetData("DevExpress.XtraTreeList.Nodes.TreeListNode");
StartGetNodeID:
var _DestinationID = DestinationNode.GetValue("ID").ToString();
var _NodeID = _Node.GetValue("ID").ToString();
if (DestinationNode.GetValue("IsFolder").ToString().ToLower() == "1")
{
var _Group = _GroupCollection.GetGroupByID(_DestinationID);
if (_Node.GetValue("IsFolder").ToString().ToLower() == "1")
{
_GroupCollection.MoveGroupToGroup(_Node.GetValue("ID").ToString(), _DestinationID);
}
}
else
{
DestinationNode = DestinationNode.ParentNode;
goto StartGetNodeID;
}
e.Effect = DragDropEffects.None;
PopulateTreeView();
}
public void InitializePose(Pose.CGfxSkeletonPose pose)
{
OutPose = pose.Clone();
SourceNode?.InitializePose(pose);
DestinationNode?.InitializePose(pose);
}
public override string ToString()
{
return(SourceNode.ToString() + " -> " + DestinationNode.ToString());
}
/// <summary>
/// Visits the specified node.
/// </summary>
/// <param name="node">The node.</param>
public void Visit(DestinationNode node)
{
//Custom mode we dont need the function cause it will be attached on compilation.
if (!_isInPrepareCustomMode)
{
//AppendToResult("var result = null;");
}
foreach (var resultNode in node.ResultNodes)
{
resultNode.AcceptVisitor(this);
}
if (!_isInPrepareCustomMode)
{
//AppendToResult(Environment.NewLine);
//AppendToResult("return result;");
}
}
public void Notifying(GamePlay.Component.GComponent component)
{
SourceNode?.Notifying(component);
DestinationNode?.Notifying(component);
}
/// <summary>
/// Adds the destination node.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="destinationNode">The destination node.</param>
/// <param name="prefix">The prefix.</param>
private void AddDestinationNode(DestinationField field, DestinationNode destinationNode, string prefix = "")
{
if (field.ConnectorIn.Connection != null && field.ConnectorIn.Connection.Source != null)
{
var name = prefix + field.SystemName;
destinationNode.ResultNodes.Add(
CreateResultNode(field.ConnectorIn, field.DataType, name));
}
foreach (var subfield in field.Subfields.OfType<DestinationField>())
{
AddDestinationNode(subfield, destinationNode, prefix + field.SystemName + ".");
}
}
/// <summary>
/// Prepares the multiple scripts.
/// </summary>
/// <param name="resultNode">The result node.</param>
/// <returns>Dictionary{System.StringSystem.String}.</returns>
public Dictionary<string, string> PrepareMultipleScripts(DestinationNode resultNode)
{
_isInPrepareMode = true;
var result = new Dictionary<string, string>();
_resultCode = new StringBuilder();
foreach (var node in resultNode.ResultNodes)
{
_resultCode.Clear();
node.AcceptVisitor(this);
result[node.FieldName] = _resultCode.ToString();
}
_isInPrepareMode = false;
return result;
}
public DestinationNode(string name, DestinationNode previous)
{
Name = name;
Previous = previous;
}
/// <summary>
/// To the expression node.
/// </summary>
/// <param name="destination">The destination.</param>
/// <returns>DestinationNode.</returns>
private DestinationNode ToExpressionNode(DestinationFieldList destination)
{
var destinationNode = new DestinationNode();
foreach (var field in destination.Fields)
{
AddDestinationNode(field, destinationNode);
}
return destinationNode;
}
