bool DrawWithinTimeRangeInterior(ConditionNode currentCondition, bool typeChangedToThis)
{
bool result = false;
int labelWidth = 90;
WorldDate startDate;
WorldDate finishDate;
bool hoursOnly;
EditorGUILayout.BeginVertical(Config.FoldoutInteriorStyle);
{
result |= DrawGenericWorldDateField(currentCondition.WithinTimeRange.Start, labelWidth, "Start", out startDate, currentCondition.WithinTimeRange.HoursOnly);
result |= DrawGenericWorldDateField(currentCondition.WithinTimeRange.Finish, labelWidth, "Finish", out finishDate, currentCondition.WithinTimeRange.HoursOnly);
result |= DrawGenericBoolField(currentCondition.WithinTimeRange.HoursOnly, labelWidth, "Hours Only?", out hoursOnly);
}
EditorGUILayout.EndVertical();
if (typeChangedToThis || result)
{
currentCondition.SetWithinTimeRangeCondition(startDate, finishDate, hoursOnly);
Debug.Log("Zmiana na Within Time Range");
}
return(result);
}
/// <summary>
/// Renders a dialog step
/// </summary>
/// <param name="data">Dialog Step Data</param>
/// <param name="flexFieldObject">Flex field object to which the dialog belongs</param>
/// <returns>Dialog Step Render Result</returns>
public async Task <ExportDialogStepRenderResult> RenderDialogStep(ExportDialogData data, FlexFieldObject flexFieldObject)
{
ConditionNode conditionNode = data.Condition;
if (conditionNode == null)
{
return(null);
}
ExportTemplate template = await _defaultTemplateProvider.GetDefaultTemplateByType(_project.Id, TemplateType.TaleCondition);
if (!_renderers.ContainsKey(template.RenderingEngine))
{
throw new KeyNotFoundException(string.Format("Unknown rendering engine {0} for ConditionNode", template.RenderingEngine.ToString()));
}
string oldContext = _errorCollection.CurrentErrorContext;
_errorCollection.CurrentErrorContext = _localizer["ErrorContextCondition"];
try
{
return(await _renderers[template.RenderingEngine].RenderDialogStep(template, data, flexFieldObject, conditionNode));
}
catch (Exception ex)
{
_errorCollection.AddException(ex);
return(new ExportDialogStepRenderResult {
StepCode = "<<ERROR_RENDERING_CONDITION>>"
});
}
finally
{
_errorCollection.CurrentErrorContext = oldContext;
}
}
bool DrawStoryStateHappenedInterior(ConditionNode currentCondition, bool typeChangedToThis)
{
bool result = false;
int labelWidth = 90;
string stateMachineName;
string stateName;
bool stateHappened;
EditorGUILayout.BeginVertical(Config.FoldoutInteriorStyle);
{
//Item setting
result |= DrawGenericStringField(currentCondition.StoryStateHappened.PlotName, labelWidth, "Plot Name", out stateMachineName);
result |= DrawGenericStringField(currentCondition.StoryStateHappened.StateName, labelWidth, "State Name", out stateName);
result |= DrawGenericBoolField(currentCondition.StoryStateHappened.HasHappened, labelWidth, "Happened?", out stateHappened);
}
EditorGUILayout.EndVertical();
if (typeChangedToThis || result)
{
currentCondition.SetStoryStateHappenedCondition(stateMachineName, stateName, stateHappened);
Debug.Log("Zmiana story state happened");
}
return(typeChangedToThis || result);
}
//TO FINISH
bool DrawPlayerHasItemInterior(ConditionNode currentCondition, bool typeChangedToThis)
{
bool result = false;
int labelWidth = 90;
ItemScript item;
int quantity;
bool weWantItem;
EditorGUILayout.BeginVertical(Config.FoldoutInteriorStyle);
{
result |= DrawGenericAssetField <ItemScript>(currentCondition.PlayerHasItem.Item, labelWidth, "Item", out item);
result |= DrawGenericIntField(currentCondition.PlayerHasItem.Quantity, labelWidth, "Quantity", out quantity, 0);
result |= DrawGenericBoolField(currentCondition.PlayerHasItem.IsRequired, labelWidth, "Wanted?", out weWantItem);
}
EditorGUILayout.EndVertical();
if (typeChangedToThis || result)
{
currentCondition.SetPlayerHasItemCondition(item, quantity, weWantItem);
Debug.Log("Zmiana playerHasItem");
}
return(typeChangedToThis || result);
}
bool DrawAttributeTestInterior(ConditionNode currentCondition, bool typeChangedToThis)
{
bool result = false;
int labelWidth = 90;
CharacterAttribute stat;
int modificator;
CharacterSkills skill;
EditorGUILayout.BeginVertical(Config.FoldoutInteriorStyle);
{
result |= DrawCharacterAttributeField(currentCondition.AttributeTest.Attribute, labelWidth, out stat);
result |= DrawTestModificatorField(currentCondition.AttributeTest.AttributeMod, labelWidth, out modificator);
result |= DrawPlayerSkillField(currentCondition.AttributeTest.Skill, labelWidth, out skill);
}
EditorGUILayout.EndVertical();
if (typeChangedToThis || result)
{
currentCondition.SetAttributeTestCondition(stat, modificator, skill);
Debug.Log("Zmiana attribute test");
}
return(typeChangedToThis || result);
}
public void Execute(object parameter)
{
ConditionNode newNode = new ConditionNode();
newNode.Loaded = Node.Loaded;
Node.ChildNodes.Add(newNode);
}
public IConditionalExpressionNodeWrapper AddConditionalExpressionNode()
{
var node = new ConditionNode();
CurrentNode.Nodes.Add(node);
return(new SparkConditionNodeWrapper(node));
}
public Node Create(NodeType type)
{
Node node = null;
switch (type)
{
case NodeType.Root:
node = new RootNode();
break;
case NodeType.Action:
node = new ActionNode();
break;
case NodeType.Sequencer:
node = new SequencerNode();
break;
case NodeType.Selector:
node = new SelectorNode();
break;
case NodeType.Random:
node = new RandomNode();
break;
case NodeType.RandomSelector:
node = new RandomSelectorNode();
break;
case NodeType.RandomSequencer:
node = new RandomSequencerNode();
break;
case NodeType.Decorator:
node = new DecoratorNode();
break;
case NodeType.Condition:
node = new ConditionNode();
break;
case NodeType.ConditionWhile:
node = new ConditionWhileNode();
break;
default:
Debug.Assert(false, "未定義のノードタイプ");
break;
}
if (node != null)
{
node.Init(idSeed);
Register(idSeed, node);
idSeed += 1;
}
return(node);
}
protected override void VisitCondition(ConditionNode conditionNode)
{
AddNode(conditionNode);
AddLink(conditionNode, conditionNode.WhenFalse, Categories.NormalFlowEdge, "False");
AddLink(conditionNode, conditionNode.WhenTrue, Categories.NormalFlowEdge, "True");
}
public virtual void SetPrevious(ConditionNode previous, Vector2 clickPos, int idChoice)
{
SetPrevious(previous, clickPos);
previous.nextNodeIdList[idChoice] = id;
previous.nextNodeList[idChoice] = this;
}
public IConditionalExpressionNodeWrapper AddConditionalExpressionNode()
{
ConditionNode expressionNode = new ConditionNode();
_body.Add(expressionNode);
return(new SparkConditionNodeWrapper(expressionNode));
}
void DrawExitField(ConditionNode condition, bool isSuccess)
{
EditorGUILayout.BeginHorizontal();
{
if (isSuccess)
{
/*
* condition.NextDialogueIDIfPassed =
* EditorGUILayout.TextField(
* (condition.NextDialogueIDIfPassed == null) ?
* "" : condition.NextDialogueIDIfPassed
* );*/
condition.NextDialogueIfPassed =
(Dialogue)EditorGUILayout.ObjectField("", condition.NextDialogueIfPassed, typeof(Dialogue), false, GUILayout.Width(100));
}
else
{/*
* condition.NextDialogueIDIfFailed =
* EditorGUILayout.TextField(
* (condition.NextDialogueIDIfFailed == null) ?
* "" : condition.NextDialogueIDIfFailed
* );*/
condition.NextDialogueIfFailed =
(Dialogue)EditorGUILayout.ObjectField("", condition.NextDialogueIfFailed, typeof(Dialogue), false, GUILayout.Width(100));
}
}
EditorGUILayout.EndHorizontal();
}
private void btnRemoveCondition_Click(object sender, EventArgs e)
{
if (m_CurrentExpression == m_ConditionalRoot)
{
m_ConditionalRoot = null;
}
else
{
LogicalNode selectedLogicalNode = (LogicalNode)tlvCondition.GetParent(m_CurrentExpression);
if (selectedLogicalNode != null)
{
selectedLogicalNode.Nodes.Remove(m_CurrentExpression);
if (selectedLogicalNode.Nodes.Count < 2)
{
//Remove logical node
LogicalNode parentLogicalNode = (LogicalNode)tlvCondition.GetParent(selectedLogicalNode);
if (parentLogicalNode != null && selectedLogicalNode.Nodes.Count == 0)
{
parentLogicalNode.Nodes.Remove(selectedLogicalNode);
}
else if (parentLogicalNode == null && selectedLogicalNode.Nodes.Count == 1)
{
//TODO when not drinking beer: resolve lowest level in loop in case nested logical node
m_ConditionalRoot = selectedLogicalNode.Nodes.First();
selectedLogicalNode.Nodes.Clear();
}
}
}
}
m_CurrentExpression = null;
zRefreshCondition();
}
public override DynValue Visit(ConditionNode conditionNode)
{
foreach (var branch in conditionNode.IfElifBranches)
{
var exprResult = Visit(branch.Key);
if (exprResult.IsTruth)
{
Environment.EnterScope();
{
ExecuteStatementList(branch.Value);
}
Environment.ExitScope();
return(DynValue.Zero);
}
}
if (conditionNode.ElseBranch != null)
{
Environment.EnterScope();
{
ExecuteStatementList(conditionNode.ElseBranch);
}
Environment.ExitScope();
}
return(DynValue.Zero);
}
public override string GetExpressionString()
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < _childNodes.Count; i++)
{
if (i > 0)
{
sb.AppendFormat(" {0} ", OperatorName);
}
ConditionNode child = (ConditionNode)_childNodes[i];
string formatString;
if (child is LogicalNode)
{
formatString = "({0})";
}
else
{
formatString = "{0}";
}
sb.AppendFormat(formatString, child.GetExpressionString());
}
return(sb.ToString());
}
private void Transform(ElementNode node, IList <Node> body)
{
AttributeNode forAttribute = node.GetAttribute("for");
AttributeNode forType = node.GetAttribute("fortype");
AttributeNode forProperty = node.GetAttribute("forproperty");
if (forAttribute != null)
{
// put in as content property
node.Attributes.Remove(forAttribute);
node.RemoveAttributesByName("name");
node.RemoveAttributesByName("value");
var nameNode = new ExpressionNode(forAttribute.Value.GetPropertyNameSnippet());
var valueNode = new ConditionNode("resource!=null")
{
Nodes = new List <Node>()
{
new ExpressionNode(forAttribute.Value)
}
};
SetNodeNameAndValue(node, valueNode, nameNode, body, forAttribute);
}
else if (forType != null)
{
if (forProperty == null)
{
throw new Exception("Must have both a forProperty attribute if using the forType attribute.");
}
node.Attributes.Remove(forType);
node.Attributes.Remove(forProperty);
node.RemoveAttributesByName("name");
SetNodeNameAndValue(node, null, new TextNode(string.Concat(forType.Value, ".", forProperty.Value)), body, forAttribute);
}
}
static ConditionNode ComputeNot(ConditionNode root, ref int i)
{
int j = i;
while (j < root.Children.Count)
{
if (root.Children[j].Operator == ConditionOperator.NOT)
{
j++;
}
else
{
break;
}
}
var right = root.Children[j];
int p = j;
Compute(right);
right = new ConditionNode()
{
Symbol = right.Symbol,
Operator = right.Operator,
Value = right.Value
};
while (j > i)
{
right.Not();
j--;
}
;
i = p;
return(right);
}
private FunctionNode CreateFunctionNode(ASTNode himeDeclNode)
{
ASTNode himeFuncNode = GetHimeFuncNode(himeDeclNode);
FunctionTypeNode type = _expressionHelper.CreateFunctionTypeNode(himeFuncNode.Children[_conf.FUNCTIONTYPE_POS]);
List <string> parameterIdentifiers = GetParameterIdentifiers(himeFuncNode);
string typeID = GetTypeID(himeFuncNode);
string functionID = GetFunctionID(himeFuncNode);
if (typeID != functionID)
{
throw new FunctionIdentifierMatchException(functionID, typeID);
}
TextPosition position = himeFuncNode.Children[0].Position;
if (IsConditional(himeDeclNode))
{
List <ConditionNode> conditions = new List <ConditionNode>();
VisitConditions(GetFunctionContent(himeDeclNode),
conditions,
false);
return(new FunctionNode(conditions, typeID, parameterIdentifiers, type,
position.Line, position.Column));
}
else
{
ConditionNode condition = GetInsertedConditionNode(himeDeclNode);
return(new FunctionNode(typeID, condition, parameterIdentifiers, type,
position.Line, position.Column));
}
}
private void CheckCondition(ConditionNode node, List <string> identifiers)
{
if (node.Condition != null)
{
_dispatch(node.Condition, identifiers);
}
}
bool DrawStatisticCheckInterior(ConditionNode currentCondition, bool typeChangedToThis)
{
bool result = false;
int labelWidth = 90;
CharacterStatistic stat;
float value;
InequalityTypes inequality;
EditorGUILayout.BeginVertical(Config.FoldoutInteriorStyle);
{
result |= DrawCharacterStatisticField(currentCondition.StatisticCheck.Statistic, labelWidth, out stat);
result |= DrawInequalityField(currentCondition.StatisticCheck.InequalityType, labelWidth, out inequality);
result |= DrawGenericFloatField(currentCondition.StatisticCheck.ValueChecked, labelWidth, "Statistic Value", out value);
//DrawValueCheckedField(currentCondition.AttributeCheck.ValueChecked, labelWidth, out value);
}
EditorGUILayout.EndVertical();
if (typeChangedToThis || result)
{
currentCondition.SetStatisticCheckCondition(stat, inequality, value);
Debug.Log("Zmiana attribute check");
}
return(typeChangedToThis || result);
}
protected override void Visit(ConditionNode conditionNode)
{
var conditionChunk = new ConditionalChunk
{
Condition = conditionNode.Code,
Type = ConditionalType.If,
Position = Locate(conditionNode)
};
Chunks.Add(conditionChunk);
if (_sendAttributeOnce != null)
{
conditionChunk.Body.Add(_sendAttributeOnce);
}
if (_sendAttributeIncrement != null)
{
conditionChunk.Body.Add(_sendAttributeIncrement);
}
using (new Frame(this, conditionChunk.Body))
{
Accept(conditionNode.Nodes);
}
}
/// <summary>
/// Renders a dialog step
/// </summary>
/// <param name="data">Dialog Step Data</param>
/// <param name="npc">Npc to which the dialog belongs</param>
/// <returns>Dialog Step Render Result</returns>
public async Task <ExportDialogStepRenderResult> RenderDialogStep(ExportDialogData data, KortistoNpc npc)
{
ConditionNode conditionNode = data.Condition;
if (conditionNode == null)
{
return(null);
}
ExportTemplate template = await _defaultTemplateProvider.GetDefaultTemplateByType(_project.Id, TemplateType.TaleCondition);
ExportDialogStepRenderResult renderResult = new ExportDialogStepRenderResult();
renderResult.StepCode = ReplaceNodeId(template.Code, data);
renderResult.StepCode = ExportUtil.BuildRangePlaceholderRegex(Placeholder_ConditionsStart, Placeholder_ConditionsEnd).Replace(renderResult.StepCode, m => {
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(BuildConditions(m.Groups[1].Value, data, conditionNode, npc, false), m.Groups[2].Value)));
});
renderResult.StepCode = ExportUtil.BuildRangePlaceholderRegex(Placeholder_AllConditionsStart, Placeholder_AllConditionsEnd).Replace(renderResult.StepCode, m => {
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(BuildConditions(m.Groups[1].Value, data, conditionNode, npc, true), m.Groups[2].Value)));
});
renderResult.StepCode = ExportUtil.BuildRangePlaceholderRegex(Placeholder_ElseStart, Placeholder_ElseEnd).Replace(renderResult.StepCode, m => {
return(ExportUtil.IndentListTemplate(BuildElsePart(m.Groups[1].Value, data), m.Groups[2].Value));
});
return(renderResult);
}
/// <summary>
/// Builds a parent text preview for the a dialog step
/// </summary>
/// <param name="child">Child node</param>
/// <param name="parent">Parent</param>
/// <param name="npc">Npc to which the dialog belongs</param>
/// <param name="errorCollection">Error Collection</param>
/// <returns>Parent text preview for the dialog step</returns>
public async Task <string> BuildParentTextPreview(ExportDialogData child, ExportDialogData parent, KortistoNpc npc, ExportPlaceholderErrorCollection errorCollection)
{
ConditionNode conditionNode = parent.Condition;
if (conditionNode == null)
{
return(null);
}
List <string> previewForConditions = new List <string>();
foreach (Condition curCondition in conditionNode.Conditions)
{
ExportDialogDataChild childObj = parent.Children.FirstOrDefault(c => c.NodeChildId == curCondition.Id);
if (childObj == null || childObj.Child != child)
{
continue;
}
string conditionText = await _conditionRenderer.RenderCondition(_project, curCondition, _errorCollection, npc, _exportSettings);
previewForConditions.Add(ExportUtil.BuildTextPreview(conditionText));
}
if (parent.Children.Any(c => c.Child == child && c.NodeChildId == ExportConstants.ConditionElseNodeChildId))
{
previewForConditions.Add("else");
}
return(string.Join(", ", previewForConditions));
}
public void RemoveLinkedParameterFromVariableNode()
{
int paramIndex = this.Connection.OrderOfArgumentID;
if (this.Connection.ParentNode.NodeType == NodeType.ConditionNode)
{
ConditionNode n = this.Connection.ParentNode as ConditionNode;
n.ConnectedToVariableName = "";
n.ConnectedToVariableCallerClassName = "";
}
if (this.Connection.ParentNode.NodeType == NodeType.MethodNode)
{
DynamicNode n = this.Connection.ParentNode as DynamicNode;
n.ArgumentCache[paramIndex].ArgIsExistingVariable = false;
n.ArgumentCache[paramIndex].ArgExistingVariableName = "";
if (!this.IsNoLinkedInputField)
{
n.EnableInputOnParameter(paramIndex);
}
}
//MainViewModel.Instance.LogStatus("Removing linked parameter connection on " + n.NodeName + ", parameter " + paramIndex);
}
public void SetStep(StepEditContext stepEditContext)
{
this.m_StepEditContext = stepEditContext;
cbVariable.DataSource = m_StepEditContext.StateVariables.Primitives();
//Step
tpStep.Text = m_StepEditContext.Step.DisplayName;
m_StepEditor = StepEditorFactory.GetStepEditor(m_StepEditContext);
m_StepEditor.Dock = DockStyle.Fill;
tpStep.Controls.Add(m_StepEditor);
//Condition
if (m_StepEditContext.Step.Condition != null)
{
m_ConditionalRoot = m_StepEditContext.Step.Condition;
//m_CurrentExpression =
zUpdateExpressionBuilder();
btnRemoveCondition.Enabled = true;
panelExpressionBuilder.Enabled = true;
}
//Behavior
cbStepFailureScope.SelectedItem = m_StepEditContext.Step.FailureScope;
zRefreshCondition();
}
public static Node GetPropertyValueNode(this string propertyAccessor)
{
string objectName = propertyAccessor.GetObjectName();
var conditionNode = new ConditionNode(string.Format("{0}!=null", objectName));
conditionNode.Nodes.Add(new ExpressionNode(propertyAccessor));
return conditionNode;
}
public static Node GetPropertyValueNode(this string propertyAccessor)
{
string objectName = propertyAccessor.GetObjectName();
var conditionNode = new ConditionNode(string.Format("{0}!=null", objectName));
conditionNode.Nodes.Add(new ExpressionNode(propertyAccessor));
return(conditionNode);
}
public override void PopulateBranches(List <Node> list)
{
list.Add(this);
VariableIdentifierNode.PopulateBranches(list);
InitialValueNode?.PopulateBranches(list);
ConditionNode?.PopulateBranches(list);
WithExpressionNode?.PopulateBranches(list);
}
public void CheckConditionNode(TypeNode expectedType, ConditionNode condition, List <TypeNode> parameterTypes)
{
CheckElements(condition.Elements, parameterTypes);
var newParams = GetNewParameters(parameterTypes, condition);
CheckCondition(condition, newParams);
CheckReturnExpr(condition, newParams, expectedType);
}
/// <summary>
/// Creates a new default ConditionNode at the given location.
/// </summary>
/// <param name="position"></param>
/// <returns>A condition node with default values.</returns>
private ConditionNode CreateConditionNode(Vector2 position)
{
ConditionNode node = new ConditionNode {
title = "Condition"
};
node.SetPosition(new Rect(position, BaseNode.DefaultNodeSize));
return(node);
}
public static ConditionNode GeneratePlan(Condition condition, IWorldState worldState, int depth, int width)
{
LinkedList <Condition> stack = new LinkedList <Condition>();
stack.AddFirst(condition);
ConditionNode topNode = FillTree(stack, worldState, depth, width);
return(topNode);
}
public static Node GetCreateUriSnippet(this string entity, bool isType)
{
if (isType)
{
entity = "typeof(" + entity + ")";
return new ExpressionNode(entity + ".CreateUri()");
}
var nullCheck = new ConditionNode(entity.GetIsNotNullExpression());
nullCheck.Nodes.Add(new ExpressionNode(entity + ".CreateUri()"));
return nullCheck;
}
public static Node GetSelectedSnippet(this string propertyAccessor, string currentSelectedState, string optionValue)
{
string propertyNullTest = propertyAccessor.GetObjectName().GetIsNotNullExpression();
string currentSelectedValueTest = string.Format(@"(""{0}""!="""")", currentSelectedState);
string propertyValueTest = string.Format("({0}==\"{1}\")", propertyAccessor, optionValue);
// argh
// if ((propertyNullTest)&&(propertyValueTest))||(currentSelectedValueTest))
string conidtion = string.Format("({0}&&{1})||{2}", propertyNullTest, propertyValueTest, currentSelectedValueTest);
var node = new ConditionNode(conidtion);
node.Nodes.Add(new TextNode("true"));
return node;
}
public void Only_those_that_are_matched_should_be_called()
{
var junction = new JoinNode<Customer>(_constantNode);
junction.AddSuccessor(_actionNode);
var alphaNodeA = new AlphaNode<Customer>();
alphaNodeA.AddSuccessor(junction);
var joinJunction = new JoinNode<Customer>(alphaNodeA);
var alphaNodeB = new AlphaNode<Customer>();
alphaNodeB.AddSuccessor(joinJunction);
var actionNode = new ActionNode<Customer>(x => _secondaryCalled.Complete(x.Element.Object));
var joinJunction2 = new JoinNode<Customer>(alphaNodeA);
joinJunction2.AddSuccessor(actionNode);
var alphaNodeC = new AlphaNode<Customer>();
alphaNodeC.AddSuccessor(joinJunction2);
var tree = new TypeNode<Customer>();
var isPreferred = new ConditionNode<Customer>(x => x.Preferred);
isPreferred.AddSuccessor(alphaNodeA);
tree.AddSuccessor(isPreferred);
tree.AddSuccessor(alphaNodeB);
var isActive = new ConditionNode<Customer>(x => x.Active);
isActive.AddSuccessor(alphaNodeC);
tree.AddSuccessor(isActive);
var visitor = new StringNodeVisitor();
tree.Visit(visitor);
Trace.WriteLine(visitor.Result);
tree.Activate(_context);
_session.Run();
_primaryCalled.IsCompleted.ShouldBeTrue();
_secondaryCalled.IsCompleted.ShouldBeFalse();
}
/// <summary>
///
/// </summary>
/// <param name="condition"></param>
/// <param name="node"></param>
public IfNode(ConditionNode condition, IBehaviourNode node,string name)
: base(name)
{
this.AddNode(condition);
this.AddNode(node);
}
/// <summary>
/// Constructs a new, empty, query.
/// </summary>
public Filter()
{
_topNode = null;
}
/// <summary>
/// clone
/// </summary>
/// <returns></returns>
public IBehaviourNode Clone()
{
var behaviourNode = new ConditionNode(this._condition);
base.CopyTo(behaviourNode);
behaviourNode._fn = this._fn;
behaviourNode._condition = this._condition;
return behaviourNode;
}
Filter Or(ConditionNode newCondition)
{
if (_topNode == null)
{
_topNode = newCondition;
}
else
{
MergeConditionIntoTree(LogicalOperator.OR, newCondition);
}
return this;
}
Filter And(ConditionNode newCondition)
{
if (newCondition == null)
throw new ArgumentNullException("newCondition", "condition may not be null");
if (_topNode == null)
{
_topNode = newCondition;
}
else
{
MergeConditionIntoTree(LogicalOperator.AND, newCondition);
}
return this;
}
void MergeConditionIntoTree(LogicalOperator desiredLogicalOperator, ConditionNode newCondition)
{
if (newCondition == null)
throw new ArgumentNullException("newCondition", "condition may not be null");
if (_topNode is LogicalNode && ((LogicalNode)_topNode).Operator == desiredLogicalOperator)
{
// top node is already of the desired type, so just add into it
LogicalNode logicalNode = _topNode as LogicalNode;
logicalNode.AddCondition(newCondition);
}
else
{
// push existing top node down to be beneath this node...
LogicalNode newTopNode = new LogicalNode(desiredLogicalOperator);
newTopNode.AddCondition(_topNode);
newTopNode.AddCondition(newCondition);
_topNode = newTopNode;
}
}
public void AddCondition(ConditionNode condition)
{
if (condition == null)
throw new ArgumentNullException("condition", "Cannot add a null condition.");
_childNodes.Add(condition);
}