private ISparqlPath TryParsePathSequence(SparqlQueryParserContext context, Queue <IToken> tokens)
{
ISparqlPath path = TryParsePathEltOrInverse(context, tokens);
IToken next;
while (tokens.Count > 0)
{
next = tokens.Peek();
switch (next.TokenType)
{
case Token.DIVIDE:
tokens.Dequeue();
path = new SequencePath(path, TryParsePathEltOrInverse(context, tokens));
break;
case Token.HAT:
tokens.Dequeue();
path = new SequencePath(path, new InversePath(TryParsePathElt(context, tokens)));
break;
default:
return(path);
}
}
return(path);
}
public void SparqlPropertyPathTransformationSequencedAlternatives()
{
INode a = this._factory.CreateUriNode(new Uri("ex:a"));
INode b = this._factory.CreateUriNode(new Uri("ex:b"));
INode c = this._factory.CreateUriNode(new Uri("ex:c"));
INode d = this._factory.CreateUriNode(new Uri("ex:d"));
SequencePath path = new SequencePath(new AlternativePath(new Property(a), new Property(c)), new AlternativePath(new Property(b), new Property(d)));
this.RunTest(path, new String[] { "BGP" });
}
public void SparqlPropertyPathEvaluationSequencedAlternatives()
{
EnsureTestData();
INode a = this._factory.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode b = this._factory.CreateUriNode(new Uri(NamespaceMapper.RDFS + "range"));
SequencePath path = new SequencePath(new AlternativePath(new Property(a), new Property(b)), new AlternativePath(new Property(a), new Property(a)));
ISparqlAlgebra algebra = this.GetAlgebraUntransformed(path);
SparqlEvaluationContext context = new SparqlEvaluationContext(null, this._data);
BaseMultiset results = algebra.Evaluate(context);
TestTools.ShowMultiset(results);
Assert.IsFalse(results.IsEmpty, "Results should not be empty");
}
private void ControlPointsCount(SequencePath path, int pointsCount)
{
if (path == null)
{
return;
}
while (path.LocalPoints.Count < pointsCount)
{
path.LocalPoints.Add(Vector3.zero);
}
while (path.LocalPoints.Count > pointsCount)
{
path.LocalPoints.RemoveAt(path.LocalPoints.Count - 1);
}
}
/// <summary>
/// Formats a SPARQL Property Path
/// </summary>
/// <param name="path">SPARQL Property Path</param>
/// <returns></returns>
protected virtual String FormatPath(ISparqlPath path)
{
StringBuilder output = new StringBuilder();
if (path is AlternativePath)
{
AlternativePath alt = (AlternativePath)path;
output.Append('(');
output.Append(this.FormatPath(alt.LhsPath));
output.Append(" | ");
output.Append(this.FormatPath(alt.RhsPath));
output.Append(')');
}
else if (path is FixedCardinality)
{
FixedCardinality card = (FixedCardinality)path;
if (card.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(card.Path));
if (card.Path is BaseBinaryPath)
{
output.Append(')');
}
output.Append('{');
output.Append(card.MaxCardinality);
output.Append('}');
}
else if (path is InversePath)
{
InversePath inv = (InversePath)path;
output.Append('^');
if (inv.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(inv.Path));
if (inv.Path is BaseBinaryPath)
{
output.Append(')');
}
}
else if (path is NOrMore)
{
NOrMore nOrMore = (NOrMore)path;
if (nOrMore.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(nOrMore.Path));
if (nOrMore.Path is BaseBinaryPath)
{
output.Append(')');
}
output.Append('{');
output.Append(nOrMore.MinCardinality);
output.Append(",}");
}
else if (path is NToM)
{
NToM nToM = (NToM)path;
if (nToM.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(nToM.Path));
if (nToM.Path is BaseBinaryPath)
{
output.Append(')');
}
output.Append('{');
output.Append(nToM.MinCardinality);
output.Append(',');
output.Append(nToM.MaxCardinality);
output.Append('}');
}
else if (path is OneOrMore)
{
OneOrMore oneOrMore = (OneOrMore)path;
if (oneOrMore.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(oneOrMore.Path));
if (oneOrMore.Path is BaseBinaryPath)
{
output.Append(')');
}
output.Append('+');
}
else if (path is Property)
{
Property prop = (Property)path;
output.Append(this.Format(prop.Predicate, TripleSegment.Predicate));
}
else if (path is SequencePath)
{
SequencePath seq = (SequencePath)path;
output.Append(this.FormatPath(seq.LhsPath));
output.Append(" / ");
output.Append(this.FormatPath(seq.RhsPath));
}
else if (path is ZeroOrMore)
{
ZeroOrMore zeroOrMore = (ZeroOrMore)path;
if (zeroOrMore.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(zeroOrMore.Path));
if (zeroOrMore.Path is BaseBinaryPath)
{
output.Append(')');
}
output.Append('*');
}
else if (path is ZeroOrOne)
{
ZeroOrOne zeroOrOne = (ZeroOrOne)path;
if (zeroOrOne.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(zeroOrOne.Path));
if (zeroOrOne.Path is BaseBinaryPath)
{
output.Append(')');
}
output.Append('?');
}
else if (path is ZeroToN)
{
ZeroToN zeroToN = (ZeroToN)path;
if (zeroToN.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(zeroToN.Path));
if (zeroToN.Path is BaseBinaryPath)
{
output.Append(')');
}
output.Append("{,");
output.Append(zeroToN.MaxCardinality);
output.Append('}');
}
else if (path is NegatedSet)
{
NegatedSet negSet = (NegatedSet)path;
output.Append('!');
if (negSet.Properties.Count() + negSet.InverseProperties.Count() > 1)
{
output.Append('(');
}
foreach (Property p in negSet.Properties)
{
output.Append(this.FormatPath(p));
output.Append(" | ");
}
foreach (Property p in negSet.InverseProperties)
{
output.Append(this.FormatPath(p));
output.Append(" | ");
}
output.Remove(output.Length - 3, 3);
if (negSet.Properties.Count() + negSet.InverseProperties.Count() > 1)
{
output.Append(')');
}
}
else
{
throw new RdfOutputException("Unable to Format an unknown ISparqlPath implementations as a String");
}
return(output.ToString());
}
public void SparqlPropertyPathTransformationSequence()
{
SequencePath path = new SequencePath(new Property(this._factory.CreateUriNode(new Uri(RdfSpecsHelper.RdfType))), new Property(this._factory.CreateUriNode(new Uri(NamespaceMapper.RDFS + "subClassOf"))));
this.RunTest(path, new String[] { "BGP" });
}
private void OnEnable()
{
path = target as SequencePath;
selectionInfo = new SelectionInfo();
}
private void Start()
{
path = GetComponent <SequencePath>();
}
protected override void Start()
{
base.Start();
path = GetComponent <SequencePath>();
}
