private bool Compare(double a, double b, ParserParts parserParts)
{
if (parserParts == ParserParts.EqualsPred)
{
return(Math.Abs(a - b) < Tolerance);
}
if (parserParts == ParserParts.LessPred)
{
return(a < b);
}
if (parserParts == ParserParts.LessEqualPred)
{
return(a <= b);
}
if (parserParts == ParserParts.MorePred)
{
return(a > b);
}
if (parserParts == ParserParts.MoreEqualPred)
{
return(a >= b);
}
throw new InvalidOperationException();
}
private bool Compare(int a, int b, ParserParts parserParts)
{
if (parserParts == ParserParts.EqualsPred)
{
return(a == b);
}
if (parserParts == ParserParts.LessPred)
{
return(a > b);
}
if (parserParts == ParserParts.LessEqualPred)
{
return(a >= b);
}
if (parserParts == ParserParts.MorePred)
{
return(a < b);
}
if (parserParts == ParserParts.MoreEqualPred)
{
return(a < b);
}
throw new InvalidOperationException();
}
protected virtual void OnParsed(ParserParts parsePart, string currentToken = "")
{
var e = new PartParsedEventArgs(parsePart, currentToken);
//Console.WriteLine(e.ToString());
PartParsed?.Invoke(this, e);
}
private bool TestFloatValue(QLPart part, Node secondNode, ParserParts parserParts)
{
var floatValue = (secondNode as CFloatNode).FloatValue;
//int schema to float query
if (part.QLNumber != null)
{
var intPropValue = part.QLNumber.Value;
if (Compare(intPropValue, floatValue, parserParts))
{
return(true);
}
}
//float schema to float query
if (part.QLFloat != null)
{
var floatPropValue = part.QLFloat.Value;
if (Compare(floatPropValue, floatValue, parserParts))
{
return(true);
}
}
return(false);
}
public override void AddNode(string value, ParserParts parserPart)
{
switch (parserPart)
{
case ParserParts.EqualsPred:
compare = parserPart;
break;
case ParserParts.MorePred:
compare = parserPart;
break;
case ParserParts.MoreEqualPred:
compare = parserPart;
break;
case ParserParts.LessPred:
compare = parserPart;
break;
case ParserParts.LessEqualPred:
compare = parserPart;
break;
case ParserParts.Number:
cNumberNode = new CNumberNode(value);
break;
default:
throw new InvalidOperationException();
}
}
public override void AddNode(string value, ParserParts parserPart)
{
if (parserPart != ParserParts.Operator)
{
throw new ArgumentOutOfRangeException(nameof(parserPart), parserPart, null);
}
ParentFuncNode.LastStatement.SetOperator(value);
}
public override void AddNode(string value, ParserParts parserPart)
{
switch (parserPart)
{
case ParserParts.SetRelVar:
primeVariable = value;
break;
case ParserParts.RelAttStr:
secondaryVariable.Add(value);
break;
case ParserParts.EmptyRelAtt:
secondaryVariable.Add(EmptyRelAtts);
break;
default:
throw new InvalidOperationException();
}
}
public PartParsedEventArgs(ParserParts parsePart, string currentToken = "")
{
CurrentToken = currentToken;
ParsePart = parsePart;
}
public PredicateNode(Node firstNode, ParserParts compare, Node secondNode)
{
FirstNode = firstNode;
Compare = compare;
SecondNode = secondNode;
}
public override void AddNode(string value, ParserParts parserPart)
{
switch (parserPart)
{
case ParserParts.SetRelArg:
PrimeVariable = value;
break;
case ParserParts.RelAttStr:
PromoteSetArgument();
SecondaryVariable = GetIndexOfAttribute(value);
break;
case ParserParts.RelAttIndex:
PromoteSetArgument();
SecondaryVariable = FromAttIndexToNetIndex(value);
break;
case ParserParts.ExAtt:
AddArgument(DoExAtt(value));
break;
//Type Predicate
case ParserParts.ExType:
TypePredNode typePredNode = null;
if (PrimeVariable != null && !SecondaryVariable.HasValue)
{
typePredNode = new TypePredNode(new SetNode(PrimeVariable), value);
}
else if (SecondaryVariable.HasValue)
{
var relAttNode = new RelAttNode(SecondaryVariable.Value, PrimeVariable);
typePredNode = new TypePredNode(relAttNode, value);
}
AddArgument(typePredNode);
PrimeVariable = null;
SecondaryVariable = null;
break;
//constants
case ParserParts.String:
ParentFuncNode.LastStatement.AddArgument(new CStringNode(value));
break;
case ParserParts.Number:
ParentFuncNode.LastStatement.AddArgument(new CNumberNode(value));
break;
case ParserParts.Float:
ParentFuncNode.LastStatement.AddArgument(new CFloatNode(value));
break;
case ParserParts.Bool:
ParentFuncNode.LastStatement.AddArgument(new CBoolNode(value));
break;
default:
throw new InvalidOperationException();
}
}
public override void AddNode(string value, ParserParts parserPart)
{
switch (parserPart)
{
case ParserParts.EqualsPred:
Compare = parserPart;
return;
case ParserParts.InPred:
Compare = parserPart;
return;
case ParserParts.MorePred:
Compare = parserPart;
return;
case ParserParts.MoreEqualPred:
Compare = parserPart;
return;
case ParserParts.LessPred:
Compare = parserPart;
return;
case ParserParts.LessEqualPred:
Compare = parserPart;
return;
case ParserParts.String:
AttributeAccessNodeEnd = new CStringNode(value);
return;
case ParserParts.Number:
AttributeAccessNodeEnd = new CNumberNode(value);
return;
case ParserParts.Float:
AttributeAccessNodeEnd = new CFloatNode(value);
return;
case ParserParts.Bool:
AttributeAccessNodeEnd = new CBoolNode(value);
return;
case ParserParts.SetRelArg:
PrimeVariable = value;
break;
case ParserParts.RelAttStr:
SecondaryVariable = GetIndexOfAttribute(value);
break;
case ParserParts.RelAttIndex:
SecondaryVariable = FromAttIndexToNetIndex(value);
break;
case ParserParts.ExAtt:
AttributeAccessNodeEnd = DoExAtt(value);
break;
}
}
public override void AddNode(string value, ParserParts parserPart)
{
ParentFuncNode.AddStatement(new StatementNode());
}
public override void AddNode(string value, ParserParts parserPart)
{
switch (parserPart)
{
case ParserParts.DefOp:
if (GlobalFunctionId == value)
{
astBuilder.globalFunctionNode = new FunctionNode(value);
astBuilder.currentFunctionNode = astBuilder.globalFunctionNode;
}
else
{
var userFuncNode = new UserFunctionNode(value);
astBuilder.globalFunctionNode.UserFunctions.Add(userFuncNode);
astBuilder.currentFunctionNode = userFuncNode;
}
break;
case ParserParts.DefAlias:
if (!value.StartsWith(":"))
{
throw new ArgumentException("Alias does not start with :");
}
((UserFunctionNode)astBuilder.currentFunctionNode).Alias = value.Substring(1, value.Length - 1);
break;
case ParserParts.SetRelFormalArg:
//((UserFunctionNode)astBuilder.currentFunctionNode).AddArguement(); = value;
break;
case ParserParts.SetRelArg:
primeVariable = value;
break;
case ParserParts.RelAttStr:
var strInt = new StrInt(value, null);
secondaryVariable.Add(strInt);
break;
case ParserParts.RelAttIndex:
var strInt2 = new StrInt(null, int.Parse(value) - 1);
secondaryVariable.Add(strInt2);
break;
case ParserParts.SetRelFormalArgEnd:
if (secondaryVariable.Count == 0)
{
((UserFunctionNode)astBuilder.currentFunctionNode).AddArguement(new SetNode(primeVariable));
}
else
{
var relation = new RelationNode(primeVariable); //todo numeric index bzw empty args
relation.Attributes = secondaryVariable.Select(t => t.Item1).ToList();
((UserFunctionNode)astBuilder.currentFunctionNode).AddArguement(relation);
}
primeVariable = null;
secondaryVariable.Clear();
break;
default:
throw new InvalidOperationException();
}
}
public abstract void AddNode(string value, ParserParts parserPart);
