public static bool TryCreate(Scanner scanner, ILogger logger, out CommandletParserBase parser)
{
var anchor = scanner.MakeAnchor();
if (!scanner.Expect('+'))
{
logger.Report(LogLevel.Error, scanner.Pointer.AsRange(scanner.Source), Messages.Error_InstructionExpected);
parser = null;
return(false);
}
scanner.SkipWhitespaces();
var name = scanner.Read(c => char.IsLetterOrDigit(c) || c == '-');
Type parserType;
if (!CommandletParsers.TryGetValue(name.ToLowerInvariant(), out parserType))
{
logger.Report(LogLevel.Error, scanner.Pointer.AsRange(scanner.Source), Messages.Error_UnknownInstruction);
parser = null;
return(false);
}
var nameNode = new LiteralNode <string>($"+{name}", anchor.Range);
parser = (CommandletParserBase)Activator.CreateInstance(parserType);
parser.CommandletNameNode = nameNode;
return(true);
}
public void LiteralNodeTest()
{
int a = 1;
LiteralNode n = new LiteralNode(a);
Assert.Equal(a, n.Value);
}
public void CreateMainMethod()
{
mainMethod = new MethodGraph("Main")
{
Class = cls,
Modifiers = MethodModifiers.Static
};
MethodSpecifier stringLengthSpecifier = new MethodSpecifier("StringLength", new MethodParameter[0], new List <TypeSpecifier>()
{
TypeSpecifier.FromType <int>()
},
MethodModifiers.None, MemberVisibility.Public, TypeSpecifier.FromType <string>(), Array.Empty <BaseType>());
//MethodSpecifier writeConsoleSpecifier = typeof(Console).GetMethods().Single(m => m.Name == "WriteLine" && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType == typeof(string));
TypeSpecifier stringType = TypeSpecifier.FromType <string>();
MethodSpecifier writeConsoleSpecifier = new MethodSpecifier("WriteLine", new MethodParameter[] { new MethodParameter("argName", stringType, MethodParameterPassType.Default, false, null) }, new BaseType[0],
MethodModifiers.None, MemberVisibility.Public, TypeSpecifier.FromType(typeof(Console)), new BaseType[0]);
// Create nodes
LiteralNode stringLiteralNode = LiteralNode.WithValue(mainMethod, "Hello World");
VariableSetterNode setStringNode = new VariableSetterNode(mainMethod, new VariableSpecifier("testVariable", TypeSpecifier.FromType <string>(), MemberVisibility.Public, MemberVisibility.Public, cls.Type, VariableModifiers.None));
CallMethodNode getStringLengthNode = new CallMethodNode(mainMethod, stringLengthSpecifier);
CallMethodNode writeConsoleNode = new CallMethodNode(mainMethod, writeConsoleSpecifier);
// Connect node execs
GraphUtil.ConnectExecPins(mainMethod.EntryNode.InitialExecutionPin, setStringNode.InputExecPins[0]);
GraphUtil.ConnectExecPins(setStringNode.OutputExecPins[0], getStringLengthNode.InputExecPins[0]);
GraphUtil.ConnectExecPins(getStringLengthNode.OutputExecPins[0], writeConsoleNode.InputExecPins[0]);
GraphUtil.ConnectExecPins(writeConsoleNode.OutputExecPins[0], mainMethod.ReturnNodes.First().InputExecPins[0]);
// Connect node data
GraphUtil.ConnectDataPins(stringLiteralNode.ValuePin, setStringNode.NewValuePin);
GraphUtil.ConnectDataPins(getStringLengthNode.OutputDataPins[0], writeConsoleNode.ArgumentPins[0]);
}
public IHtmlNode Build()
{
IHtmlNode datagrid = null;
IHtmlNode div = new HtmlElement("div")
.Attribute("id", Component.Id)
.Attributes(Component.HtmlAttributes);
IHtmlNode script = new HtmlElement("script");
StringBuilder builder = new StringBuilder();
builder.AppendFormat("$('#{0}').datagrid(", Component.Id);
if (Component.Options.Count > 0 ||
Component.FrozenColumns.Count > 0 ||
Component.Columns.Count > 0 ||
Component.ToolBar.Count > 0)
{
builder.Append("{ ");
builder.Append(string.Format("{0}, {1}{2}{3}",
Component.Options.ToDataOptionsString(),
ConvertColumnsString(Component.FrozenColumns, "frozenColumns"),
ConvertColumnsString(Component.Columns, "columns"),
ConvertToolbarString(Component.ToolBar)).TrimStart(',').Trim().TrimEnd(','));
builder.Append(" }");
}
builder.Append(");");
script.Html(builder.ToString());
datagrid = new LiteralNode(string.Format("{0}\r\n{1}", div.ToString(), script.ToString()));
return datagrid;
}
private Node Literal()
{
Token t = _tokens.Current;
_tokens.MoveNext();
Node n = null;
if (t is LeftParenthesis)
{
n = expression();
if (_tokens.Current is RightParenthesis)
{
// ignore right parenthesis
_tokens.MoveNext();
}
else
{
throw new Exception(string.Format("Malformed expression: expected ')' found {0}", _tokens.Current));
}
}
else if (t is Literal)
{
_variables.Add(t.value);
n = new LiteralNode(t);
}
else
{
throw new Exception(string.Format("Malformed expression: parsing literal found {0}", _tokens.Current));
}
return(n);
}
public void GetStatementResultTypeMoneyAndDoubleTest()
{
var lhs = new LiteralNode(Location.Empty, "10.0", QValueType.Money);
var rhs = new LiteralNode(Location.Empty, "5.0", QValueType.Double);
Assert.AreEqual(QValueType.Money, StatementTypeEvaluator.GetStatementResultType(lhs, rhs));
}
public static LiteralNode GetLiteral(JToken jToken, string name, JsonSerializer serializer)
{
LiteralNode literalNode = Literal(name, false, null);
serializer.Populate(jToken.CreateReader(), literalNode);
return(literalNode);
}
public object Visit(LiteralNode node)
{
switch (node.Token.Type)
{
case TokenType.IntLiteral:
return(Convert.ToInt64(node.Token.Value));
case TokenType.BinLiteral:
return(Convert.ToInt64(node.Token.Value, 2));
case TokenType.OctLiteral:
return(Convert.ToInt64(node.Token.Value, 8));
case TokenType.HexLiteral:
return(Convert.ToInt64(node.Token.Value, 16));
case TokenType.DoubleLiteral:
return(Convert.ToDouble(node.Token.Value));
case TokenType.BoolLiteral:
return(Convert.ToBoolean(node.Token.Value));
default:
return(null);
}
}
public void CreateIfElseMethod()
{
List <TypeSpecifier> argumentTypes = new List <TypeSpecifier>()
{
TypeSpecifier.FromType <int>(),
TypeSpecifier.FromType <bool>(),
};
List <TypeSpecifier> returnTypes = new List <TypeSpecifier>()
{
TypeSpecifier.FromType <int>(),
};
// Create method
ifElseMethod = new Method("IfElse")
{
Modifiers = MethodModifiers.Public
};
ifElseMethod.ArgumentTypes.AddRange(argumentTypes);
ifElseMethod.ReturnTypes.AddRange(returnTypes);
// Create nodes
IfElseNode ifElseNode = new IfElseNode(ifElseMethod);
LiteralNode literalNode = LiteralNode.WithValue(ifElseMethod, 123);
// Connect exec nodes
GraphUtil.ConnectExecPins(ifElseMethod.EntryNode.InitialExecutionPin, ifElseNode.ExecutionPin);
GraphUtil.ConnectExecPins(ifElseNode.TruePin, ifElseMethod.ReturnNodes.First().ReturnPin);
GraphUtil.ConnectExecPins(ifElseNode.FalsePin, ifElseMethod.ReturnNodes.First().ReturnPin);
// Connect node data
GraphUtil.ConnectDataPins(ifElseMethod.EntryNode.OutputDataPins[1], ifElseNode.ConditionPin);
GraphUtil.ConnectDataPins(ifElseMethod.EntryNode.OutputDataPins[0], ifElseMethod.ReturnNodes.First().InputDataPins[0]);
GraphUtil.ConnectDataPins(literalNode.ValuePin, ifElseMethod.ReturnNodes.First().InputDataPins[0]);
}
/// <summary>
/// Counts the results
/// </summary>
/// <param name="context">Evaluation Context</param>
/// <param name="bindingIDs">Binding IDs over which the Aggregate applies</param>
/// <returns></returns>
public override INode Apply(SparqlEvaluationContext context, IEnumerable <int> bindingIDs)
{
//Just Count the number of results
int c = bindingIDs.Count();
LiteralNode count = new LiteralNode(null, c.ToString(), new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger));
return(count);
}
public void ExpressionNodeResultTypeDoubleAndIntTest()
{
var lhs = new LiteralNode(Location.Empty, "10.0", QValueType.Double);
var rhs = new LiteralNode(Location.Empty, "5.0", QValueType.Integer);
var expression = new ArthimetricExpressionNode(Location.Empty, lhs, ArthimetricOperator.Mult, rhs);
Assert.AreEqual(QValueType.Double, expression.GetQValueType());
}
/// <summary>
/// Counts the results
/// </summary>
/// <param name="context">Evaluation Context</param>
/// <param name="bindingIDs">Binding IDs over which the Aggregate applies</param>
/// <returns></returns>
public override INode Apply(SparqlEvaluationContext context, IEnumerable <int> bindingIDs)
{
int c = context.InputMultiset.Sets.Distinct().Count();
LiteralNode count = new LiteralNode(null, c.ToString(), new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger));
return(count);
}
private static Triple MakeVdsTriple(Model.Triple triple)
{
if (triple.IsLiteral)
{
LiteralNode literalNode = BrightstarLiteralNode.Create(triple.Object, triple.DataType, triple.LangCode);
return(new Triple(MakeVdsNode(triple.Subject), MakeVdsNode(triple.Predicate), literalNode));
}
return(new Triple(MakeVdsNode(triple.Subject), MakeVdsNode(triple.Predicate), MakeVdsNode(triple.Object)));
}
public void Parse_NegatedLiterals()
{
ASTNode root = ExpressionParser.Parse("-6");
Assert.IsInstanceOf <LiteralNode>(root);
LiteralNode node = (LiteralNode)root;
Assert.AreEqual("-6", node.rawValue);
}
override public Node Visit(LiteralNode node)
{
if (_literalNodeExpectations.Count > 0)
{
_literalNodeExpectations.Dequeue().Invoke(node);
}
return(VisitChildren(node));
}
private void button1_Click(object sender, RoutedEventArgs e)
{
/* Connect To DBPedia
* //First define a SPARQL Endpoint for DBPedia
* SparqlRemoteEndpoint endpoint = new SparqlRemoteEndpoint(new Uri("http://dbpedia.org/sparql"));
*
* //Next define our query
* //We're going to ask DBPedia to describe the first thing it finds which is a Person
* String query = "DESCRIBE ?person WHERE {?person a <http://dbpedia.org/ontology/Person>} LIMIT 1";
*
* //Get the result
* Graph g = endpoint.QueryWithResultGraph(query);
*
* FastRdfXmlWriter rxtw = new FastRdfXmlWriter();
* rxtw.Save(g, "dbp.txt");*/
Graph g = new Graph();
UriNode omid = g.CreateUriNode(new Uri("http://www.omidey.co.cc"));
UriNode says = g.CreateUriNode(new Uri("http://www.sample.com/says"));
LiteralNode hello = g.CreateLiteralNode("Hello World!!!");
LiteralNode sallam = g.CreateLiteralNode("Sallam 2nyaaa!!!", "fa");
g.Assert(new Triple(omid, says, hello));
g.Assert(new Triple(omid, says, sallam));
//foreach (Triple t in g.Triples)
//{
// MessageBox.Show(t.ToString());
//}
String query = "SELECT ?n ?p WHERE {?n ?p 'Hello World!!!'}"; // like select * => "SELECT ?n ?p ?m WHERE {?n ?p ?m}"
SparqlResultSet res = (SparqlResultSet)g.ExecuteQuery(query);
foreach (SparqlResult r in res)
{
MessageBox.Show(r.ToString());
}
FastRdfXmlWriter rxtw = new FastRdfXmlWriter();
rxtw.Save(g, "omid.txt");
//TripleStore ts = new TripleStore();
//Object res = ts.ExecuteQuery("SELECT * WHERE {?s ?p ?o}");
//if (res is SparqlResultSet)
//{
// SparqlResultSet results = (SparqlResultSet)res;
// foreach (SparqlResult sr in results)
// {
// Console.WriteLine(sr.ToString());
// }
//}
}
private EbiValueBase Evaluate(EbiScope scope, ExpressionNode expr)
{
return(expr switch
{
LiteralNode l => l.Value,
IdentifierNode id => scope[id.Name]?.Value ?? throw new RuntimeException($"No such identifier named '{id.Name}'"),
CallExpressionNode call => Evaluate(scope, call),
UnaryExpressionNode un => Evaluate(scope, un),
BinaryExpressionNode bin => Evaluate(scope, bin),
_ => new EbiNull(),
});
public void InValidBoolComparisonTest()
{
SymbolTable.Add("TestBool", QValueType.Boolean);
var left = new IdentifierNode(new Location(0, 0), "TestBool");
var right = new LiteralNode(new Location(0, 0), "false", QValueType.Integer);
var comparisonNode = new LogicalExpressionNode(new Location(0, 0), left, LogicalOperator.Or, right);
var analyser = new StatementTypeAnalyser();
var result = analyser.Analyse(comparisonNode);
Assert.IsFalse(result);
}
private LiteralNode GetTypeCoercionNode(int index)
{
LiteralNode node = FindCoercionType(index);
// we can't find a literal or predicate to drive the coercion, use defaults
if (node == null)
{
node = GetDefaultCoercionType();
}
return(node);
}
private Expression CreateDereferenceExpression(ParameterExpression param, int index)
{
NodeWithId idNode = FindChild <NodeWithId>(index);
if (idNode != null)
{
LiteralNode node = GetTypeCoercionNode(index); // this is used to coerce the value to the correct type for comparison
return(ExpressionFactory.CreateReadPropertyExpression(param, idNode.EvaluationId, node.ValueType));
}
return(null);
}
public void ValidArthimetricComparisonTest()
{
SymbolTable.Add("x", QValueType.DOUBLE);
var x = new IdentifierNode(new Location(0, 0), "x");
var five = new LiteralNode(new Location(0, 0), "5", QValueType.INTEGER);
var arthimetricNode = new ArthimetricExpressionNode(new Location(0, 0), x, ArthimetricOperator.MULT, five);
var analyser = new StatementTypeAnalyser();
var result = analyser.Analyse(arthimetricNode);
Assert.IsTrue(result);
}
public void IntAndDoubleMultiplicationTest()
{
SymbolTable.Add("x", QValueType.Integer);
var x = new IdentifierNode(new Location(0, 0), "x");
var five = new LiteralNode(new Location(0, 0), "5.0", QValueType.Double);
var arthimetricNode = new ArthimetricExpressionNode(new Location(0, 0), x, ArthimetricOperator.Mult, five);
var analyser = new StatementTypeAnalyser();
var result = analyser.Analyse(arthimetricNode);
Assert.IsTrue(result);
}
public void InValidArthimetricComparisonTest()
{
SymbolTable.Add("blah blah", QValueType.Text);
var x = new IdentifierNode(new Location(0, 0), "x");
var five = new LiteralNode(new Location(0, 0), "5", QValueType.Integer);
var arthimetricNode = new ArthimetricExpressionNode(new Location(0, 0), x, ArthimetricOperator.Mult, five);
var analyser = new StatementTypeAnalyser();
var result = analyser.Analyse(arthimetricNode);
Assert.IsFalse(result);
}
public static bool TryReadNoteRepetition(Scanner scanner, ILogger logger,
out LiteralNode <NoteRepetition> ornament)
{
switch (scanner.ReadAnyPatternOf("tremolo"))
{
case "tremolo":
ornament = new LiteralNode <NoteRepetition>(NoteRepetition.Tremolo, scanner.LastReadRange);
return(true);
}
ornament = null;
return(false);
}
public static bool TryReadInteger(Scanner scanner, out LiteralNode <int> node)
{
int value;
if (!scanner.TryReadInteger(out value))
{
node = null;
return(false);
}
node = new LiteralNode <int>(value, scanner.LastReadRange);
return(true);
}
/// <summary>
/// Counts the results
/// </summary>
/// <param name="context">Evaluation Context</param>
/// <param name="bindingIDs">Binding IDs over which the Aggregate applies</param>
/// <returns></returns>
public override INode Apply(SparqlEvaluationContext context, IEnumerable <int> bindingIDs)
{
int c;
List <INode> values = new List <INode>();
if (this._varname != null)
{
//Ensure the COUNTed variable is in the Variables of the Results
if (!context.Binder.Variables.Contains(this._varname))
{
throw new RdfQueryException("Cannot use the Variable " + this._expr.ToString() + " in a COUNT Aggregate since the Variable does not occur in a Graph Pattern");
}
//Just Count the number of results where the variable is bound
VariableExpressionTerm varExpr = (VariableExpressionTerm)this._expr;
foreach (int id in bindingIDs)
{
INode temp = varExpr.Value(context, id);
if (temp != null)
{
values.Add(temp);
}
}
c = values.Distinct().Count();
}
else
{
//Count the distinct non-null results
foreach (int id in bindingIDs)
{
try
{
INode temp = this._expr.Value(context, id);
if (temp != null)
{
values.Add(temp);
}
}
catch
{
//Ignore errors
}
}
c = values.Distinct().Count();
}
LiteralNode count = new LiteralNode(null, c.ToString(), new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger));
return(count);
}
private static LiteralNode FoldTheDreadedAddition(LiteralNode op1, LiteralNode op2)
{
Interval interval = new Interval(op1.Interval.a, op2.Interval.b);
//Aye.
IntegerLiteralNode int1 = op1 as IntegerLiteralNode;
IntegerLiteralNode int2 = op2 as IntegerLiteralNode;
RealLiteralNode rea1 = op1 as RealLiteralNode;
RealLiteralNode rea2 = op2 as RealLiteralNode;
StringLiteralNode str1 = op1 as StringLiteralNode;
StringLiteralNode str2 = op2 as StringLiteralNode;
if (int1 != null && int2 != null)
{
int result = int1.Value + int2.Value;
return(CrawlSyntaxNode.IntegerLiteral(interval, CrawlSimpleType.Tal, result));
}
if (str1 != null && str2 != null)
{
string result = str1.Value + str2.Value;
return(CrawlSyntaxNode.StringLiteral(interval, CrawlSimpleType.Tekst, result));
}
if (rea1 != null && rea2 != null)
{
double result = rea1.Value + rea2.Value;
return(CrawlSyntaxNode.RealLiteral(interval, CrawlSimpleType.Kommatal, result));
}
//Hvis de er forskellige, se om a kan tildeles til b, hvis ja, konverter a til b's type
//Hvis stadig ikke se om b kan tildeles til a, hvis ja, konverter b til a's type
if (str1 != null)
{
string result = str1.Value + (int2?.Value.ToString() ?? rea2?.Value.ToString(CultureInfo.GetCultureInfo("en-GB")));
return(CrawlSyntaxNode.StringLiteral(interval, CrawlSimpleType.Tekst, result));
}
if (str2 != null)
{
string result = (int1?.Value.ToString() ?? rea1?.Value.ToString(CultureInfo.GetCultureInfo("en-GB"))) + str2.Value;
return(CrawlSyntaxNode.StringLiteral(interval, CrawlSimpleType.Tekst, result));
}
if (rea1 != null)
{
double result = rea1.Value + int2.Value;
return(CrawlSyntaxNode.RealLiteral(interval, CrawlSimpleType.Kommatal, result));
}
if (rea2 != null)
{
double result = int1.Value + rea2.Value;
return(CrawlSyntaxNode.RealLiteral(interval, CrawlSimpleType.Kommatal, result));
}
throw new NullReferenceException();
}
private static void Walk([NotNull] Agent agent, [NotNull] LiteralNode literal, bool isStrict)
{
if (isStrict && literal.Value.IsDouble && octalRegex.IsMatch(literal.Raw))
{
throw agent.CreateSyntaxError();
}
if (isStrict && literal.Value.IsString)
{
for (var i = 0; i < literal.Raw.Length; i++)
{
var c = literal.Raw[i];
if (c == '\\')
{
var next = literal.Raw[i + 1];
switch (next)
{
case 'n':
case 'r':
case 'x':
case 'u':
case 't':
case 'b':
case 'v':
case 'f':
case '\n':
case '\r':
i++;
break;
default:
if (next >= 48 && next <= 55)
{
var nextNext = literal.Raw[i + 2];
if (next == '0' && !char.IsDigit(nextNext))
{
i++;
break;
}
throw agent.CreateSyntaxError();
}
i++;
break;
}
}
}
}
}
//Lot of swithces here. You want to have an editor that can collapse stuff.
private static double GetNumber(LiteralNode node)
{
switch (node.Type)
{
case NodeType.IntegerLiteral:
return(((IntegerLiteralNode)node).Value);
case NodeType.RealLiteral:
return(((RealLiteralNode)node).Value);
default:
throw new Exception("Type error where no type error should be.");
}
}
private bool?evalBooleanOperation(Node operation, Node lValue, Node rValue)
{
if (operation is FinalNode)
{
string opType = ((FinalNode)operation).dataString();
string lvalueString;
switch (opType)
{
case "==":
if (lValue is FinalNode)
{
lvalueString = ((FinalNode)lValue).dataString();
}
else if (lValue is LiteralNode)
{
LiteralNode literalNode = (LiteralNode)lValue.Instructions[0];
// lvalueString = (LiteralNode)literalNode.getInstructions().get( 0 );
}
break;
case ">=":
break;
case "<=":
break;
case "&&":
if (lValue is FinalNode)
{
lvalueString = ((FinalNode)lValue).dataString();
}
else if (lValue is LiteralNode)
{
LiteralNode literalNode = (LiteralNode)lValue.Instructions[0];
// lvalueString = (LiteralNode)literalNode.getInstructions().get( 0 );
}
//if ( )
break;
case "||":
break;
}
}
return(false);
}
public static bool TryReadStaffType(Scanner scanner, ILogger logger, out LiteralNode <StaffType> staffTypeNode)
{
StaffType staffType;
switch (scanner.ReadToLineEnd().Trim().ToLowerInvariant())
{
case "guitar":
case "acoustic guitar":
staffType = StaffType.Guitar; break;
case "steel":
case "steel guitar":
staffType = StaffType.SteelGuitar; break;
case "nylon":
case "nylon guitar":
case "classical":
case "classical guitar":
staffType = StaffType.NylonGuitar; break;
case "electric guitar":
staffType = StaffType.ElectricGuitar; break;
case "bass":
staffType = StaffType.Bass; break;
case "acoustic bass":
staffType = StaffType.AcousticBass; break;
case "electric bass":
staffType = StaffType.ElectricBass; break;
case "ukulele":
case "uku":
staffType = StaffType.Ukulele; break;
case "mandolin":
staffType = StaffType.Mandolin; break;
case "vocal":
staffType = StaffType.Vocal; break;
default:
staffTypeNode = null;
return(false);
}
staffTypeNode = new LiteralNode <StaffType>(staffType, scanner.LastReadRange);
return(true);
}
protected override IHtmlNode BuildCore()
{
var div = new HtmlTag("div")
.AddClass("t-page-i-of-n");
var page = new LiteralNode(localization.Page);
page.AppendTo(div);
var input = new HtmlTag("input")
.Attribute("type", "text")
.Attribute("value", Value);
input.AppendTo(div);
var of = new LiteralNode(string.Format(localization.PageOf, TotalPages));
of.AppendTo(div);
return div;
}
public IHtmlNode Create(GridPagerData section)
{
var div = new HtmlElement("div")
.AddClass("t-page-i-of-n");
var page = new LiteralNode(section.PageText);
page.AppendTo(div);
var input = new HtmlElement("input", TagRenderMode.SelfClosing)
.Attribute("type", "text")
.Attribute("value", section.CurrentPage.ToString());
input.AppendTo(div);
var of = new LiteralNode(string.Format(section.PageOfText, section.PageCount));
of.AppendTo(div);
return div;
}
public IHtmlNode Create(GridPagerData section)
{
var span = new HtmlElement("span")
.AddClass("k-pager-input", "k-label");
var page = new LiteralNode(section.Messages.Page);
page.AppendTo(span);
var input = new HtmlElement("input", TagRenderMode.SelfClosing)
.Attribute("type", "text")
.AddClass("k-textbox")
.Attribute("value", section.Page.ToString());
input.AppendTo(span);
var of = new LiteralNode(string.Format(section.Messages.Of, section.TotalPages));
of.AppendTo(span);
return span;
}
/// <summary>
/// Counts the results
/// </summary>
/// <param name="context">Evaluation Context</param>
/// <param name="bindingIDs">Binding IDs over which the Aggregate applies</param>
/// <returns></returns>
public override INode Apply(SparqlEvaluationContext context, IEnumerable<int> bindingIDs)
{
int c = context.InputMultiset.Sets.Distinct().Count();
LiteralNode count = new LiteralNode(null, c.ToString(), new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger));
return count;
}
/// <summary>
/// Gets the value of the function in the given Evaluation Context for the given Binding ID
/// </summary>
/// <param name = "context">Evaluation Context</param>
/// <param name = "bindingID">Binding ID</param>
/// <returns>
/// Returns a constant Literal Node which is a Date Time typed Literal
/// </returns>
public override INode Value(SparqlEvaluationContext context, int bindingID)
{
if (_currQuery == null)
{
_currQuery = context.Query;
}
if (_node == null || !ReferenceEquals(_currQuery, context.Query))
{
_node = new LiteralNode(null, DateTime.Now.ToString(XmlSpecsHelper.XmlSchemaDateTimeFormat),
new Uri(XmlSpecsHelper.XmlSchemaDataTypeDateTime));
_ebv = false;
}
return _node;
}
private Node Literal()
{
Token t = _tokens.Current;
_tokens.MoveNext();
Node n = null;
if (t is LeftParenthesis)
{
n = expression();
if (_tokens.Current is RightParenthesis)
{
// ignore right parenthesis
_tokens.MoveNext();
}
else
{
throw new Exception(string.Format("Malformed expression: expected ')' found {0}",_tokens.Current));
}
}
else if (t is Literal)
{
_variables.Add(t.value);
n = new LiteralNode(t);
}
else
{
throw new Exception(string.Format("Malformed expression: parsing literal found {0}",_tokens.Current));
}
return n;
}
public void Apply(IHtmlNode parent)
{
var text = new LiteralNode(button.Text);
text.AppendTo(parent);
}
/// <summary>
/// Counts the results
/// </summary>
/// <param name="context">Evaluation Context</param>
/// <param name="bindingIDs">Binding IDs over which the Aggregate applies</param>
/// <returns></returns>
public override INode Apply(SparqlEvaluationContext context, IEnumerable<int> bindingIDs)
{
int c;
List <INode> values = new List<INode>();
if (this._varname != null)
{
//Ensure the COUNTed variable is in the Variables of the Results
if (!context.Binder.Variables.Contains(this._varname))
{
throw new RdfQueryException("Cannot use the Variable " + this._expr.ToString() + " in a COUNT Aggregate since the Variable does not occur in a Graph Pattern");
}
//Just Count the number of results where the variable is bound
VariableExpressionTerm varExpr = (VariableExpressionTerm)this._expr;
foreach (int id in bindingIDs)
{
INode temp = varExpr.Value(context, id);
if (temp != null)
{
values.Add(temp);
}
}
c = values.Distinct().Count();
}
else
{
//Count the distinct non-null results
foreach (int id in bindingIDs)
{
try
{
INode temp = this._expr.Value(context, id);
if (temp != null)
{
values.Add(temp);
}
}
catch
{
//Ignore errors
}
}
c = values.Distinct().Count();
}
LiteralNode count = new LiteralNode(null, c.ToString(), new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger));
return count;
}
/// <summary>
/// Counts the results
/// </summary>
/// <param name="context">Evaluation Context</param>
/// <param name="bindingIDs">Binding IDs over which the Aggregate applies</param>
/// <returns></returns>
public override INode Apply(SparqlEvaluationContext context, IEnumerable<int> bindingIDs)
{
//Just Count the number of results
int c = bindingIDs.Count();
LiteralNode count = new LiteralNode(null, c.ToString(), new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger));
return count;
}
private FormatRenderer CreateLiteral(LiteralNode node)
{
return new LiteralRenderer(node.Literal);
}
private Uri TryParseContext(ITokenQueue tokens)
{
IToken next = tokens.Dequeue();
if (next.TokenType == Token.DOT)
{
return null;
}
else
{
INode context;
switch (next.TokenType)
{
case Token.BLANKNODEWITHID:
context = new BlankNode(null, next.Value.Substring(2));
break;
case Token.URI:
context = new UriNode(null, new Uri(next.Value));
break;
case Token.LITERAL:
//Check for Datatype/Language
IToken temp = tokens.Peek();
if (temp.TokenType == Token.LANGSPEC)
{
tokens.Dequeue();
context = new LiteralNode(null, next.Value, temp.Value);
}
else if (temp.TokenType == Token.DATATYPE)
{
tokens.Dequeue();
context = new LiteralNode(null, next.Value, new Uri(temp.Value.Substring(1, temp.Value.Length - 2)));
}
else
{
context = new LiteralNode(null, next.Value);
}
break;
default:
throw ParserHelper.Error("Unexpected Token '" + next.GetType().ToString() + "' encountered, expected a Blank Node/Literal/URI as the Context of the Triple", next);
}
//Ensure we then see a . to terminate the Quad
next = tokens.Dequeue();
if (next.TokenType != Token.DOT)
{
throw ParserHelper.Error("Unexpected Token '" + next.GetType().ToString() + "' encountered, expected a Dot Token (Line Terminator) to terminate a Triple", next);
}
//Finally return the Context URI
if (context.NodeType == NodeType.Uri)
{
return ((IUriNode)context).Uri;
}
else if (context.NodeType == NodeType.Blank)
{
return new Uri("nquads:bnode:" + context.GetHashCode());
}
else if (context.NodeType == NodeType.Literal)
{
return new Uri("nquads:literal:" + context.GetHashCode());
}
else
{
throw ParserHelper.Error("Cannot turn a Node of type '" + context.GetType().ToString() + "' into a Context URI for a Triple", next);
}
}
}
/// <summary>
/// Returns the LiteralNode with the given Value and given Data Type if it exists
/// </summary>
/// <param name="literal">The literal value of the Node to select</param>
/// <param name="datatype">The Uri for the Data Type of the Literal to select</param>
/// <returns>Either the LiteralNode Or null if no Node with the given Value and Data Type exists</returns>
public override ILiteralNode GetLiteralNode(String literal, Uri datatype)
{
ILiteralNode test = new LiteralNode(this, literal, datatype);
IEnumerable<ILiteralNode> ls = from l in this._nodes.LiteralNodes
where l.Equals(test)
select l;
return ls.FirstOrDefault();
}
public OperatorNode(LiteralNode left, LiteralNode right, string operatorString)
{
_left = left;
_right = right;
_operator = operatorString;
}
public LiteralNodeViewModel(LiteralNode graphItemObject, Invert.Core.GraphDesigner.DiagramViewModel diagramViewModel) :
base(graphItemObject, diagramViewModel) {
}
/// <summary>
/// Copies a Node so it can be used in another Graph since by default Triples cannot contain Nodes from more than one Graph
/// </summary>
/// <param name="original">Node to Copy</param>
/// <param name="target">Graph to Copy into</param>
/// <returns></returns>
/// <remarks>
/// <para>
/// <strong>Warning:</strong> Copying Blank Nodes may lead to unforseen circumstances since no remapping of IDs between Graphs is done
/// </para>
/// </remarks>
public static INode CopyNode(INode original, IGraph target)
{
//No need to copy if it's already in the relevant Graph
if (ReferenceEquals(original.Graph, target)) return original;
if (original.NodeType == NodeType.Uri)
{
IUriNode u = (IUriNode)original;
IUriNode u2 = new UriNode(target, u.Uri);
return u2;
}
else if (original.NodeType == NodeType.Literal)
{
ILiteralNode l = (ILiteralNode)original;
ILiteralNode l2;
if (l.Language.Equals(String.Empty))
{
if (!(l.DataType == null))
{
l2 = new LiteralNode(target, l.Value, l.DataType);
}
else
{
l2 = new LiteralNode(target, l.Value);
}
}
else
{
l2 = new LiteralNode(target, l.Value, l.Language);
}
return l2;
}
else if (original.NodeType == NodeType.Blank)
{
IBlankNode b = (IBlankNode)original;
IBlankNode b2;
b2 = new BlankNode(target, b.InternalID);
return b2;
}
else if (original.NodeType == NodeType.Variable)
{
IVariableNode v = (IVariableNode)original;
return new VariableNode(target, v.VariableName);
}
else
{
throw new RdfException("Unable to Copy '" + original.GetType().ToString() + "' Nodes between Graphs");
}
}
