protected internal override void Preprocess(int currentDepth)
{
if (!Preprocessed)
{
if (ObjectBuilder.SequenceInputID != -1)
{
var sequenceInputNode = Navigator.GetNodeByID(ObjectBuilder.SequenceInputID);
Debug.Assert(sequenceInputNode != null);
SequenceInputs.Add(sequenceInputNode);
}
foreach (var inputData in ObjectBuilder.Inputs)
{
if (inputData.Input.NodeID != -1)
{
var valueInputNode = Navigator.GetNodeByID(inputData.Input.NodeID);
Debug.Assert(valueInputNode != null);
m_inputNodes.Add(valueInputNode);
Inputs.Add(valueInputNode);
}
else
{
throw new Exception("Output node missing input for " + inputData.Name + ". NodeID: " + ObjectBuilder.ID);
}
}
}
base.Preprocess(currentDepth);
}
protected internal override void Preprocess(int currentDepth)
{
if (!Preprocessed)
{
if (ObjectBuilder.SequenceInputID != -1)
{
var sequenceInputNode = Navigator.GetNodeByID(ObjectBuilder.SequenceInputID);
Debug.Assert(sequenceInputNode != null);
SequenceInputs.Add(sequenceInputNode);
}
for (var index = 0; index < ObjectBuilder.InputNames.Count; index++)
{
if (ObjectBuilder.InputIDs[index].NodeID == -1)
{
throw new Exception("TriggerNode is missing an input of " + ObjectBuilder.InputNames[index] +
" . NodeId: " + ObjectBuilder.ID);
}
var valueSupplierNode = Navigator.GetNodeByID(ObjectBuilder.InputIDs[index].NodeID);
Debug.Assert(valueSupplierNode != null);
Inputs.Add(valueSupplierNode);
}
}
base.Preprocess(currentDepth);
}
protected internal override void Preprocess(int currentDepth)
{
if (!Preprocessed)
{
if (ObjectBuilder.SequenceOuputID != -1)
{
// Collect expressions from children
m_nextSequenceNode = Navigator.GetNodeByID(ObjectBuilder.SequenceOuputID);
Debug.Assert(m_nextSequenceNode != null);
SequenceOutputs.Add(m_nextSequenceNode);
}
var sequenceInputNode = Navigator.GetNodeByID(ObjectBuilder.SequenceInputID);
Debug.Assert(sequenceInputNode != null);
SequenceInputs.Add(sequenceInputNode);
if (ObjectBuilder.InputID.NodeID == -1)
{
throw new Exception("Cast node has no input. NodeId: " + ObjectBuilder.ID);
}
m_inputNode = Navigator.GetNodeByID(ObjectBuilder.InputID.NodeID);
Debug.Assert(m_inputNode != null);
Inputs.Add(m_inputNode);
}
base.Preprocess(currentDepth);
}
protected internal override void Preprocess(int currentDepth)
{
if (!Preprocessed)
{
if (ObjectBuilder.SequenceOutputID != -1)
{
var nextSequenceNode = Navigator.GetNodeByID(ObjectBuilder.SequenceOutputID);
Debug.Assert(nextSequenceNode != null);
SequenceOutputs.Add(nextSequenceNode);
}
if (ObjectBuilder.SequenceInputID != -1)
{
var sequenceInputNode = Navigator.GetNodeByID(ObjectBuilder.SequenceInputID);
Debug.Assert(sequenceInputNode != null);
SequenceInputs.Add(sequenceInputNode);
}
if (ObjectBuilder.ValueInputID.NodeID != -1)
{
m_inputNode = Navigator.GetNodeByID(ObjectBuilder.ValueInputID.NodeID);
Debug.Assert(m_inputNode != null);
Inputs.Add(m_inputNode);
}
}
base.Preprocess(currentDepth);
}
/// <summary>
/// Resets nodes to state when they are ready for new run of the builder.
/// </summary>
internal virtual void Reset()
{
Depth = int.MaxValue;
SubTreeNodes.Clear();
Inputs.Clear();
Outputs.Clear();
SequenceOutputs.Clear();
SequenceInputs.Clear();
Collected = false;
Preprocessed = false;
}
protected internal override void Preprocess(int currentDepth)
{
if (!Preprocessed)
{
if (ObjectBuilder.SequenceOutput != -1)
{
var nextSequeceNode = Navigator.GetNodeByID(ObjectBuilder.SequenceOutput);
Debug.Assert(nextSequeceNode != null);
SequenceOutputs.Add(nextSequeceNode);
}
if (ObjectBuilder.SequenceInput != -1)
{
var sequenceInputNode = Navigator.GetNodeByID(ObjectBuilder.SequenceInput);
Debug.Assert(sequenceInputNode != null);
SequenceInputs.Add(sequenceInputNode);
}
foreach (var inputData in ObjectBuilder.Inputs)
{
if (inputData.Input.NodeID == -1)
{
throw new Exception("Output node missing input data. NodeID: " + ObjectBuilder.ID);
}
var inputValueNode = Navigator.GetNodeByID(inputData.Input.NodeID);
Debug.Assert(inputValueNode != null);
Inputs.Add(inputValueNode);
}
foreach (var outputData in ObjectBuilder.Outputs)
{
foreach (var identifier in outputData.Outputs.Ids)
{
var outputValueNode = Navigator.GetNodeByID(identifier.NodeID);
Outputs.Add(outputValueNode);
}
}
}
base.Preprocess(currentDepth);
}
protected internal override void Preprocess(int currentDepth)
{
if (!Preprocessed)
{
// Load true sequence node data
if (ObjectBuilder.SequenceTrueOutputID != -1)
{
// Sequence outputs can be connected only to one input
m_nextTrueSequenceNode = Navigator.GetNodeByID(ObjectBuilder.SequenceTrueOutputID);
Debug.Assert(m_nextTrueSequenceNode != null);
SequenceOutputs.Add(m_nextTrueSequenceNode);
}
// Load false sequence node data
if (ObjectBuilder.SequnceFalseOutputID != -1)
{
m_nextFalseSequenceNode = Navigator.GetNodeByID(ObjectBuilder.SequnceFalseOutputID);
Debug.Assert(m_nextFalseSequenceNode != null);
SequenceOutputs.Add(m_nextFalseSequenceNode);
}
// Load the sequence input
if (ObjectBuilder.SequenceInputID != -1)
{
var inputNode = Navigator.GetNodeByID(ObjectBuilder.SequenceInputID);
Debug.Assert(inputNode != null);
SequenceInputs.Add(inputNode);
}
// Load the input node data
if (ObjectBuilder.InputID.NodeID == -1)
{
throw new Exception("Branching node has no comparer input. NodeID: " + ObjectBuilder.ID);
}
m_comparerNode = Navigator.GetNodeByID(ObjectBuilder.InputID.NodeID);
Debug.Assert(m_comparerNode != null);
Inputs.Add(m_comparerNode);
}
base.Preprocess(currentDepth);
}
protected internal override void Preprocess(int currentDepth)
{
if (!Preprocessed)
{
if (ObjectBuilder.SequenceInput != -1)
{
var sequenceInputNode = Navigator.GetNodeByID(ObjectBuilder.SequenceInput);
Debug.Assert(sequenceInputNode != null);
SequenceInputs.Add(sequenceInputNode);
}
foreach (var sequenceOutputId in ObjectBuilder.SequenceOutputs)
{
if (sequenceOutputId != -1)
{
var interaction = Navigator.GetNodeByID(sequenceOutputId);
Debug.Assert(interaction != null);
SequenceOutputs.Add(interaction);
}
}
}
base.Preprocess(currentDepth);
}
protected internal override void Preprocess(int currentDepth)
{
if (!Preprocessed)
{
if (SequenceDependent)
{
// Fill in the sequence output
if (ObjectBuilder.SequenceOutputID != -1)
{
m_sequenceOutputNode = Navigator.GetNodeByID(ObjectBuilder.SequenceOutputID);
Debug.Assert(m_sequenceOutputNode != null);
SequenceOutputs.Add(m_sequenceOutputNode);
}
// Fill in the sequence input
var sequenceInputNode = Navigator.GetNodeByID(ObjectBuilder.SequenceInputID);
Debug.Assert(sequenceInputNode != null);
SequenceInputs.Add(sequenceInputNode);
}
else
{
// Fill in all the outputs of the node
foreach (var identifierList in ObjectBuilder.OutputParametersIDs)
{
foreach (var identifier in identifierList.Ids)
{
var node = Navigator.GetNodeByID(identifier.NodeID);
Outputs.Add(node);
}
}
}
var parameters = m_methodInfo.GetParameters();
// Change the capacity to match the OB
Inputs.Capacity = ObjectBuilder.InputParameterIDs.Count;
if (ObjectBuilder.Version == 0)
{
//// <<BACKWARDS COMPATIBILITY>>
for (int index = 0; index < ObjectBuilder.InputParameterIDs.Count; index++)
{
// Check for missing mandatory inputs
var inputIdentifier = ObjectBuilder.InputParameterIDs[index];
// Input parameters
var inputNode = Navigator.GetNodeByID(inputIdentifier.NodeID);
if (inputNode != null)
{
Inputs.Add(inputNode);
m_parametersToInputs.Add(parameters[index],
new MyTuple <MyVisualSyntaxNode, MyVariableIdentifier>(inputNode, inputIdentifier));
}
}
//// <<BACKWARDS COMPATIBILITY>>
}
else
{
var index = 0;
// Skip the first parameter for extension methods.
if (m_methodInfo.IsDefined(typeof(ExtensionAttribute), false))
{
index++;
}
for (; index < parameters.Length; index++)
{
var parameter = parameters[index];
// Find the node node identifier in the OB
var identifier =
ObjectBuilder.InputParameterIDs.Find(ident => ident.OriginName == parameter.Name);
// Continue for empty records
if (string.IsNullOrEmpty(identifier.OriginName))
{
continue;
}
// Find node
var inputNode = Navigator.GetNodeByID(identifier.NodeID);
if (inputNode == null)
{
if (!parameter.HasDefaultValue)
{
Debug.Fail("FunctionNode: " + ObjectBuilder.ID + " Input node missing! NodeID: "
+ identifier.NodeID + " Function Signature:" + m_methodInfo.Signature() +
" parameter: " + parameter.Name);
}
continue;
}
// register data
Inputs.Add(inputNode);
var t = !m_parametersToInputs.ContainsKey(parameter);
m_parametersToInputs.Add(parameter,
new MyTuple <MyVisualSyntaxNode, MyVariableIdentifier>(inputNode, identifier));
}
// Add instance input as regular input
if (ObjectBuilder.InstanceInputID.NodeID != -1)
{
m_instance = Navigator.GetNodeByID(ObjectBuilder.InstanceInputID.NodeID);
if (m_instance != null)
{
Inputs.Add(m_instance);
}
}
}
}
base.Preprocess(currentDepth);
}
public void AddSequenceInput(MyVisualSyntaxNode node)
{
SequenceInputs.Add(node);
}
