/// <remarks>Compare <see cref="InterpretNumbers"/>. </remarks>
private IEnumerable <IFormulaToken> CompleteNumbers(IEnumerable <IFormulaToken> tokens)
{
var numberTokens = new List <IFormulaToken>();
var decimalSeparators = 0;
foreach (var token in tokens.WithContext().Select(context => context[1]))
{
// append digit
if (token is FormulaNodeNumber)
{
numberTokens.Add(token);
continue;
}
// append decimal separator
if (token is FormulaTokenDecimalSeparator)
{
if (decimalSeparators == 0)
{
numberTokens.Add(token);
decimalSeparators++;
continue;
}
decimalSeparators++;
}
// create common token of value
if (numberTokens.Count != 0)
{
IFormulaToken commonToken;
if (numberTokens.Count == 1)
{
if (decimalSeparators != 0)
{
yield break;
}
commonToken = numberTokens[0];
}
else
{
commonToken = FormulaTreeFactory.CreateNumberNode(default(double));
SetOrigin(commonToken, GetOrigin(numberTokens));
}
yield return(commonToken);
if (decimalSeparators > 1)
{
yield break;
}
numberTokens.Clear();
decimalSeparators = 0;
}
// yield any non-number token
yield return(token);
}
}
private IFormulaOperator InterpretMinusToken(IFormulaToken previousToken, FormulaNodeSubtract minusToken)
{
// change from subtract to negative sign token
if (previousToken == null || previousToken is IFormulaOperator || previousToken is FormulaTokenParameterSeparator)
{
var negativeSignToken = FormulaTreeFactory.CreateNegativeSignNode(null);
SetOrigin(negativeSignToken, minusToken);
return(negativeSignToken);
}
return(minusToken);
}
private IFormulaTree ConvertVariableNode(XmlFormulaTree node)
{
if (node.VariableValue != null)
{
UserVariable variable;
if (_localVariables.TryGetValue(node.VariableValue, out variable))
{
return(FormulaTreeFactory.CreateLocalVariableNode(variable));
}
if (_globalVariables.TryGetValue(node.VariableValue, out variable))
{
return(FormulaTreeFactory.CreateGlobalVariableNode(variable));
}
}
Debug.Assert(false, "Invalid project");
return(null);
}
public IFormulaTree Convert(XmlFormulaTree formula)
{
if (formula == null)
{
return(null);
}
if (formula.VariableType == "NUMBER")
{
return(FormulaTreeFactory.CreateNumberNode(double.Parse(formula.VariableValue, CultureInfo.InvariantCulture)));
}
if (formula.VariableType == "OPERATOR")
{
return(ConvertOperatorNode(formula));
}
if (formula.VariableType == "FUNCTION")
{
return(ConvertFunctionNode(formula));
}
if (formula.VariableType == "SENSOR")
{
return(ConvertSensorOrPropertiesNode(formula));
}
if (formula.VariableType == "USER_VARIABLE")
{
return(ConvertVariableNode(formula));
}
if (formula.VariableType == "BRACKET")
{
return(ConvertParenthesesNode(formula));
}
if (String.IsNullOrEmpty(formula.VariableType))
{
return(null);
}
Debugger.Break();
throw new NotImplementedException();
}
public static FormulaNodeGreaterEqual CreateGreaterEqualToken()
{
return(FormulaTreeFactory.CreateGreaterEqualNode(null, null));
}
public static FormulaNodeLess CreateLessToken()
{
return(FormulaTreeFactory.CreateLessNode(null, null));
}
public static FormulaNodePower CreateCaretToken()
{
return(FormulaTreeFactory.CreatePowerNode(null, null));
}
public static FormulaNodeMultiply CreateMultiplyToken()
{
return(FormulaTreeFactory.CreateMultiplyNode(null, null));
}
public static FormulaNodeGlobalVariable CreateGlobalVariableToken(GlobalVariable variable)
{
return(FormulaTreeFactory.CreateGlobalVariableNode(variable));
}
public static FormulaNodeSize CreateSizeToken()
{
return(FormulaTreeFactory.CreateSizeNode());
}
public static FormulaNodeRandom CreateRandomToken()
{
return(FormulaTreeFactory.CreateRandomNode(null, null));
}
public static FormulaNodeAbs CreateAbsToken()
{
return(FormulaTreeFactory.CreateAbsNode(null));
}
public static FormulaNodeSqrt CreateSqrtToken()
{
return(FormulaTreeFactory.CreateSqrtNode(null));
}
public static FormulaNodeArctan CreateArctanToken()
{
return(FormulaTreeFactory.CreateArctanNode(null));
}
public static FormulaNodePi CreatePiToken()
{
return(FormulaTreeFactory.CreatePiNode());
}
public static FormulaNodeFalse CreateFalseToken()
{
return(FormulaTreeFactory.CreateFalseNode());
}
public static FormulaNodeRotation CreateRotationToken()
{
return(FormulaTreeFactory.CreateRotationNode());
}
public static FormulaNodeTrue CreateTrueToken()
{
return(FormulaTreeFactory.CreateTrueNode());
}
public static FormulaNodeTransparency CreateTransparencyToken()
{
return(FormulaTreeFactory.CreateTransparencyNode());
}
public static FormulaNodeAccelerationZ CreateAccelerationZToken()
{
return(FormulaTreeFactory.CreateAccelerationZNode());
}
public static FormulaNodeSubtract CreateMinusToken()
{
return(FormulaTreeFactory.CreateSubtractNode(null, null));
}
public static FormulaNodeCompass CreateCompassToken()
{
return(FormulaTreeFactory.CreateCompassNode());
}
public static FormulaNodeDivide CreateDivideToken()
{
return(FormulaTreeFactory.CreateDivideNode(null, null));
}
public static FormulaNodeInclinationX CreateInclinationXToken()
{
return(FormulaTreeFactory.CreateInclinationXNode());
}
public static FormulaNodeNotEquals CreateNotEqualsToken()
{
return(FormulaTreeFactory.CreateNotEqualsNode(null, null));
}
public static FormulaNodeBrightness CreateBrightnessToken()
{
return(FormulaTreeFactory.CreateBrightnessNode());
}
public static FormulaNodeNumber CreateDigitToken(int value)
{
return(FormulaTreeFactory.CreateNumberNode(value));
}
public static FormulaNodeLayer CreateLayerToken()
{
return(FormulaTreeFactory.CreateLayerNode());
}
public static FormulaNodeAnd CreateAndToken()
{
return(FormulaTreeFactory.CreateAndNode(null, null));
}
public static FormulaNodePositionY CreatePositionYToken()
{
return(FormulaTreeFactory.CreatePositionYNode());
}
