public SIndexedNode(IParseTreeRule <TokenType, ParserRuleType> node)
{
this.variableHandlers = node.Elements
.Cast <IParseTreeRule <TokenType, ParserRuleType> >()
.Select(o => new VariableHandler(o))
.ToList();
}
public NodeUpdater(
IParseTreeRule <TokenType, ParserRuleType> node,
NodeUpdaterBase next)
: base(node)
{
this.next = next;
}
protected NodeUpdaterBase(IParseTreeRule <TokenType, ParserRuleType> node)
{
// Handle property name
if (node.RuleType == ParserRuleType.TNode)
{
// The property name is defined in the first element
this.propertyName = new KnownPropertyName(node.Elements[0].Token().Value);
}
else if (node.RuleType == ParserRuleType.TIndexedNode)
{
// The property name is defined as a series of
// tokens where some or all are variables
this.propertyName = new IndexedPropertyName(
node.Elements
.OfType <IParseTreeRule <TokenType, ParserRuleType> >()
.Where(o => o.RuleType == ParserRuleType.TIndexedNodeContent)
.Select(o => o.Token())
.ToList());
}
// Find whether this should be an array node
this.IsArray = node.Elements
.Any(
o => o is IParseTreeToken <TokenType, ParserRuleType> token &&
token.Token.Type == TokenType.Array);
// Handle property value assignment
var assignments = node.Rule(ParserRuleType.TPropertyValue);
if (assignments != null)
{
this.propertySetters = new List <PropertyValueUpdaterBase>();
foreach (IParseTreeRule <TokenType, ParserRuleType> assignment in assignments.Elements)
{
var path = ((IParseTreeRule <TokenType, ParserRuleType>)assignment.Elements[0]).Elements;
PropertyValueUpdaterBase setter = new PropertyValueUpdater(
path.Last().Token(),
assignment.Elements[1].Token());
for (int i = path.Count - 2; i >= 0; --i)
{
setter = new PropertyValueNodeUpdater(path[i].Token(), setter);
}
this.propertySetters.Add(setter);
}
}
// Handle conditional modifier
var conditionalModifier = node.Rule(ParserRuleType.TConditionalModifier);
this.when = conditionalModifier == null
? Conditional.Always
: conditionalModifier.Token().Type == TokenType.ExclaimationMark
? Conditional.IfNotExists
: Conditional.IfExists;
}
public SFilterValue(IParseTreeRule <TokenType, ParserRuleType> filterValueNode)
{
var tokens = filterValueNode.Tokens().ToList();
this.negate = tokens[0].Type == TokenType.ExclaimationMark;
this.exactStart = tokens[this.negate ? 1 : 0].Type != TokenType.WildCard;
this.exactEnd = tokens.Last().Type != TokenType.WildCard;
this.matchParts = tokens
.Skip(this.negate ? 1 : 0)
.Where(o => o.Type != TokenType.WildCard)
.Select(o => o.Value)
.ToList();
}
private static INodeExtractor MapNode(
IParseTreeRule <TokenType, ParserRuleType> node)
{
switch (node.RuleType)
{
case ParserRuleType.SNode:
return(new SNode(node));
case ParserRuleType.SIndexedNode:
return(new SIndexedNode(node));
default:
throw new ApplicationException($"Source node type {node.RuleType} is not supported.");
}
}
private static IFilter BuildFilter(IParseTreeRule <TokenType, ParserRuleType> filterElementNode)
{
if (filterElementNode.RuleType == ParserRuleType.SFilterValue)
{
return(new SFilterValue(filterElementNode));
}
var subFilters = filterElementNode.Elements
.Cast <IParseTreeRule <TokenType, ParserRuleType> >()
.Select(BuildFilter);
if (filterElementNode.RuleType == ParserRuleType.SFilterExpressionAnd)
{
return(new SFilterExpressionAnd(subFilters));
}
if (filterElementNode.RuleType == ParserRuleType.SFilterExpressionOr)
{
return(new SFilterExpressionOr(subFilters));
}
throw new ApplicationException(
$"The node type '{filterElementNode.RuleType}' was not expected in a filter.");
}
public VariableHandler(IParseTreeRule <TokenType, ParserRuleType> indexedNode)
{
this.variableName = indexedNode.Elements[0].Token().Value;
var valueCapture = indexedNode.Rule(ParserRuleType.SPropertyValueCapture);
if (valueCapture != null)
{
this.valueCapturePath = valueCapture.Elements.Select(o => o.Token().Value).ToList();
this.variableCapture = this.ValueCapture;
}
else
{
this.variableCapture = NameCapture;
}
var filterNode = indexedNode.Rule(ParserRuleType.SFilter);
if (filterNode != null)
{
this.filter = BuildFilter(
(IParseTreeRule <TokenType, ParserRuleType>)filterNode.Elements.Single());
}
}
public FinalNodeUpdater(
IParseTreeRule <TokenType, ParserRuleType> node)
: base(node)
{
}
public SNode(IParseTreeRule <TokenType, ParserRuleType> node) => this.nodeName = node.Token().Value;
