/// <summary>
/// Gets the Value of the function as applied to the given String Literal and Argument
/// </summary>
/// <param name="stringLit">Simple/String typed Literal</param>
/// <param name="arg">Argument</param>
/// <returns></returns>
public override IValuedNode ValueInternal(ILiteralNode stringLit, ILiteralNode arg)
{
if (stringLit.Value.Equals(string.Empty))
{
if (arg.Value.Equals(string.Empty))
{
//The Empty String starts with the Empty String
return new BooleanNode(null, true);
}
else
{
//Empty String doesn't start with a non-empty string
return new BooleanNode(null, false);
}
}
else if (arg.Value.Equals(string.Empty))
{
//Any non-empty string starts with the empty string
return new BooleanNode(null, true);
}
else
{
//Otherwise evalute the StartsWith
return new BooleanNode(null, stringLit.Value.StartsWith(arg.Value));
}
}
/// <summary>
/// Gets the Value of the function as applied to the given String Literal
/// </summary>
/// <param name="stringLit">Simple/String typed Literal</param>
/// <returns></returns>
protected override IValuedNode ValueInternal(ILiteralNode stringLit)
{
string temp = stringLit.Value.Trim();
Regex normalizeSpace = new Regex("\\s{2,}");
temp = normalizeSpace.Replace(temp, " ");
return new StringNode(null, temp, UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeString));
}
/// <summary>
/// Converts the given String Literal to upper case
/// </summary>
/// <param name="stringLit">String Literal</param>
/// <returns></returns>
protected override IValuedNode ValueInternal(ILiteralNode stringLit)
{
if (stringLit.DataType != null)
{
return new StringNode(null, stringLit.Value.ToUpper(), stringLit.DataType);
}
else
{
return new StringNode(null, stringLit.Value.ToUpper(), stringLit.Language);
}
}
/// <summary>
/// Formats Literals for CSV output
/// </summary>
/// <param name="l">Literal</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected override string FormatLiteralNode(ILiteralNode l, TripleSegment? segment)
{
String value = l.Value;
if (value.Contains('"') || value.Contains(',') || value.Contains('\n') || value.Contains('\r'))
{
return '"' + value.Replace("\"", "\"\"") + '"';
}
else
{
return value;
}
}
/// <summary>
/// Gets the Value of the function as applied to the given String Literal and Argument
/// </summary>
/// <param name="stringLit">Simple/String typed Literal</param>
/// <param name="arg">Argument</param>
/// <returns></returns>
public override IValuedNode ValueInternal(ILiteralNode stringLit, ILiteralNode arg)
{
if (stringLit.Value.Equals(string.Empty))
{
//Empty string cannot contain anything
return new BooleanNode(null, false);
}
else if (arg.Value.Equals(string.Empty))
{
//Any non-empty string contains the empty string
return new BooleanNode(null, true);
}
else
{
//Evalute the Contains
return new BooleanNode(null, stringLit.Value.Contains(arg.Value));
}
}
/// <summary>
/// Gets the Value of the function as applied to the given String Literal and Argument.
/// </summary>
/// <param name="stringLit">Simple/String typed Literal.</param>
/// <param name="arg">Argument.</param>
/// <returns></returns>
public override IValuedNode ValueInternal(ILiteralNode stringLit, ILiteralNode arg)
{
if (stringLit.Value.Equals(string.Empty))
{
// Empty string cannot contain anything
return(new BooleanNode(null, false));
}
else if (arg.Value.Equals(string.Empty))
{
// Any non-empty string contains the empty string
return(new BooleanNode(null, true));
}
else
{
// Evalute the Contains
return(new BooleanNode(null, stringLit.Value.Contains(arg.Value)));
}
}
public LiteralNodeControl(ILiteralNode n, INodeFormatter formatter)
{
InitializeComponent();
String data = formatter.Format(n);
if (data.Contains("\"^^"))
{
String value = data.Substring(0, data.IndexOf("\"^^") + 3);
String dt = data.Substring(data.IndexOf("\"^^") + 4);
this.txtValue.Content = value;
this.lnkDatatypeUri.Text = dt;
this._u = n.DataType;
}
else
{
this.txtValue.Content = data;
}
}
/// <summary>
/// Returns an Integer indicating the Ordering of this Node compared to another Node
/// </summary>
/// <param name="other">Node to test against</param>
/// <returns></returns>
public override int CompareTo(ILiteralNode other)
{
if (ReferenceEquals(this, other))
{
return(0);
}
if (other == null)
{
//Variables are considered greater than null
return(1);
}
else
{
//Variable Nodes are less than everything else
return(-1);
}
}
private static bool IsIllformed(ILiteralNode literal)
{
var type = literal.DataType.AbsoluteUri.Replace(XmlSpecsHelper.NamespaceXmlSchema, string.Empty);
var schemas = GenerateSchema(type);
var isIllformed = false;
void handler(object sender, ValidationEventArgs e)
{
isIllformed = true;
}
var doc = new XDocument(new XElement(Root, literal.Value));
doc.Validate(schemas, handler);
return(isIllformed);
}
public void HelloWorld()
{
//Fill in the code shown on this page here to build your hello world application
Graph g = new Graph();
IUriNode dotNetRDF = g.CreateUriNode(UriFactory.Create("http://www.dotnetrdf.org"));
IUriNode says = g.CreateUriNode(UriFactory.Create("http://example.org/says"));
ILiteralNode helloWorld = g.CreateLiteralNode("Hello World");
ILiteralNode bonjourMonde = g.CreateLiteralNode("Bonjour tout le Monde", "fr");
g.Assert(new Triple(dotNetRDF, says, helloWorld));
g.Assert(new Triple(dotNetRDF, says, bonjourMonde));
Console.WriteLine();
Console.WriteLine("Raw Output");
Console.WriteLine();
foreach (Triple t in g.Triples)
{
Console.WriteLine(t.ToString());
}
// RDF is written out using one of the Writer types.
// Use the Save method on the graph to serialise the triples in
// the specified format to the provided write.
Console.WriteLine();
Console.WriteLine("NTriples");
Console.WriteLine();
NTriplesWriter ntwriter = new NTriplesWriter();
var sw = new System.IO.StringWriter();
ntwriter.Save(g, sw);
Console.WriteLine(sw.ToString());
Console.WriteLine();
Console.WriteLine("RDF XML");
Console.WriteLine();
RdfXmlWriter rdfxmlwriter = new RdfXmlWriter();
sw = new System.IO.StringWriter();
rdfxmlwriter.Save(g, sw);
Console.WriteLine(sw.ToString());
// view the Test Results output to see the different serialisations.
}
/// <summary>
/// Gets the Data Type Uri of the given Node if it has a supported type
/// </summary>
/// <param name="n">Node</param>
/// <returns></returns>
/// <remarks>
/// <para>
/// Only <see cref="ILiteralNode">ILiteralNode</see>'s can have a Data Type
/// </para>
/// <para>
/// The function only returns the Data Type Uri (as a String) if the Data Type of the Literal is one of the supported Data Types
/// </para>
/// </remarks>
public static String GetSupportedDataType(INode n)
{
if (n == null)
{
throw new RdfException("Data Type cannot be determined for Nulls");
}
switch (n.NodeType)
{
case NodeType.Blank:
case NodeType.GraphLiteral:
case NodeType.Uri:
throw new RdfException("Data Type cannot be determined for non-Literal Nodes");
case NodeType.Literal:
ILiteralNode l = (ILiteralNode)n;
if (l.DataType == null)
{
if (!l.Language.Equals(String.Empty))
{
throw new RdfException("Literals with Language Specifiers do not have a Data Type");
}
else
{
return(XmlSchemaDataTypeString);
}
}
else
{
String type = l.DataType.ToString();
if (XmlSpecsHelper.IsSupportedType(type))
{
return(type);
}
else
{
return(String.Empty);
}
}
default:
throw new RdfException("Data Type cannot be determined for unknown Node types");
}
}
protected void UnitTestaddRDFTriple()
{
var list = (List <string[]>)Session["PersonalList"];
Graph g = (Graph)Session["ggraph"];
g.NamespaceMap.AddNamespace("foaf", new Uri("http://xmlns.com/foaf/0.1/"));
g.NamespaceMap.AddNamespace("rdfs", new Uri("http://www.w3.org/2000/01/rdf-schema#"));
IUriNode personID = g.CreateUriNode(UriFactory.Create("http://unittest.com/"));
IUriNode Title = g.CreateUriNode("foaf:title");
IUriNode Name = g.CreateUriNode("foaf:name");
IUriNode Surname = g.CreateUriNode("foaf:familyName");
IUriNode Email = g.CreateUriNode("foaf:mbox");
IUriNode Phone = g.CreateUriNode("foaf:phone");
IUriNode Faculty = g.CreateUriNode("rdfs:label");
IUriNode Comments = g.CreateUriNode("rdfs:comment");
IUriNode rdftype = g.CreateUriNode("rdf:type"); //FOAFPERSON
IUriNode foafPerson = g.CreateUriNode("foaf:Person"); //FOAFPERSON
ILiteralNode NTitle = g.CreateLiteralNode("title");
ILiteralNode NName = g.CreateLiteralNode("name");
ILiteralNode NSurname = g.CreateLiteralNode("surname");
IUriNode NPhone = g.CreateUriNode(UriFactory.Create("tel:" + "+442380123456"));
IUriNode NEmail = g.CreateUriNode(UriFactory.Create("mailto:" + "*****@*****.**"));
ILiteralNode NFaculty = g.CreateLiteralNode("Sfaculty");
ILiteralNode NComments = g.CreateLiteralNode("Comment");
g.Assert(personID, Title, NTitle);
g.Assert(personID, Name, NName);
g.Assert(personID, Surname, NSurname);
g.Assert(personID, Email, NEmail);
g.Assert(personID, Phone, NPhone);
g.Assert(personID, Faculty, NFaculty);
g.Assert(personID, Comments, NComments);
g.Assert(personID, rdftype, foafPerson); //FOAFPERSON
RdfXmlWriter rdfxmlwriter = new RdfXmlWriter();
rdfxmlwriter.Save(g, path_user + Session["UserId"].ToString() + ".rdf");
LoadPersonalData();
}
/// <summary>
/// Returns the value of the Expression as evaluated for a given Binding as a Literal Node
/// </summary>
/// <param name="context">Evaluation Context</param>
/// <param name="bindingID">Binding ID</param>
/// <returns></returns>
public IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID)
{
ILiteralNode input = this.CheckArgument(this._stringExpr, context, bindingID);
ILiteralNode starts = this.CheckArgument(this._startsExpr, context, bindingID);
if (!this.IsValidArgumentPair(input, starts))
{
throw new RdfQueryException("The Literals provided as arguments to this SPARQL String function are not of valid forms (see SPARQL spec for acceptable combinations)");
}
Uri datatype = (input.DataType != null ? input.DataType : starts.DataType);
string lang = (!input.Language.Equals(string.Empty) ? input.Language : starts.Language);
if (input.Value.Contains(starts.Value))
{
int startIndex = input.Value.IndexOf(starts.Value) + starts.Value.Length;
string resultValue = (startIndex >= input.Value.Length ? string.Empty : input.Value.Substring(startIndex));
if (datatype != null)
{
return(new StringNode(null, resultValue, datatype));
}
else if (!lang.Equals(string.Empty))
{
return(new StringNode(null, resultValue, lang));
}
else
{
return(new StringNode(null, resultValue));
}
}
else
{
if (datatype != null)
{
return(new StringNode(null, string.Empty, datatype));
}
else
{
return(new StringNode(null, string.Empty, lang));
}
}
}
public void WritingStringIsFullyEscaped()
{
String test = "Ends with a \"";
Console.WriteLine("Original Value - " + test);
Assert.IsFalse(test.IsFullyEscaped(this._ntripleEscapes, new char[] { '"', '\n', '\r', '\t' }));
NodeFactory factory = new NodeFactory();
ILiteralNode n = factory.CreateLiteralNode(test);
NTriplesFormatter formatter = new NTriplesFormatter();
String result = formatter.Format(n);
Console.WriteLine("Formatted Value - " + result);
result = result.Substring(1, result.Length - 2);
Console.WriteLine("Formatted Value with surrounding quotes removed - " + result);
Assert.IsTrue(result.IsFullyEscaped(this._ntripleEscapes, new char[] { '"', '\n', '\r', '\t' }));
}
/// <summary>
/// Returns the value of the Expression as evaluated for a given Binding as a Literal Node
/// </summary>
/// <param name="context">Evaluation Context</param>
/// <param name="bindingID">Binding ID</param>
/// <returns></returns>
public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID)
{
IValuedNode result = this._expr.Evaluate(context, bindingID);
if (result == null)
{
throw new RdfQueryException("Cannot create an IRI from a null");
}
else
{
switch (result.NodeType)
{
case NodeType.Literal:
ILiteralNode lit = (ILiteralNode)result;
string baseUri = string.Empty;
if (context.Query != null) baseUri = context.Query.BaseUri.ToSafeString();
string uri;
if (lit.DataType == null)
{
uri = Tools.ResolveUri(lit.Value, baseUri);
return new UriNode(null, UriFactory.Create(uri));
}
else
{
string dt = lit.DataType.AbsoluteUri;
if (dt.Equals(XmlSpecsHelper.XmlSchemaDataTypeString, StringComparison.Ordinal))
{
uri = Tools.ResolveUri(lit.Value, baseUri);
return new UriNode(null, UriFactory.Create(uri));
}
else
{
throw new RdfQueryException("Cannot create an IRI from a non-string typed literal");
}
}
case NodeType.Uri:
//Already a URI so nothing to do
return result;
default:
throw new RdfQueryException("Cannot create an IRI from a non-URI/String literal");
}
}
}
public LiteralNodeControl(ILiteralNode n, INodeFormatter formatter)
{
InitializeComponent();
String data = formatter.Format(n);
if (data.Contains("\"^^"))
{
String value = data.Substring(0, data.IndexOf("\"^^") + 3);
String dt = data.Substring(data.IndexOf("\"^^") + 4);
this.txtValue.Content = value;
this.lnkDatatypeUri.Text = dt;
this._u = n.DataType;
}
else
{
this.txtValue.Content = data;
}
}
private static void PerformanceTestWith2Triples()
{
Stopwatch sw = new Stopwatch();
sw.Start();
IGraph g = new Graph();
IUriNode dotNetRDF = g.CreateUriNode(UriFactory.Create("http://www.dotnetrdf.org"));
IUriNode says = g.CreateUriNode(UriFactory.Create("http://example.org/says"));
ILiteralNode helloWorld = g.CreateLiteralNode("Hello World");
ILiteralNode bonjourMonde = g.CreateLiteralNode("Bonjour tout le Monde", "fr");
g.Assert(new Triple(dotNetRDF, says, helloWorld));
g.Assert(new Triple(dotNetRDF, says, bonjourMonde));
sw.Stop();
Console.WriteLine("Execution time: " + sw.ElapsedMilliseconds + " ms");
}
public static RDFNode ToJenaNode(INode n, JenaMapping mapping)
{
switch (n.NodeType)
{
case NodeType.Uri:
return(mapping.Model.createResource(n.ToString()));
case NodeType.Blank:
if (mapping.OutputMapping.ContainsKey(n))
{
return(mapping.OutputMapping[n]);
}
else
{
AnonId id = new AnonId(((IBlankNode)n).InternalID);
Resource bnode = mapping.Model.createResource(id);
mapping.OutputMapping.Add(n, bnode);
if (!mapping.InputMapping.ContainsKey(bnode))
{
mapping.InputMapping.Add(bnode, n);
}
return(bnode);
}
case NodeType.Literal:
ILiteralNode lit = (ILiteralNode)n;
if (lit.DataType != null)
{
return(mapping.Model.createTypedLiteral(lit.Value, TypeMapper.getInstance().getSafeTypeByName(lit.DataType.ToString())));
}
else if (!lit.Language.Equals(String.Empty))
{
return(mapping.Model.createLiteral(lit.Value, lit.Language));
}
else
{
return(mapping.Model.createLiteral(lit.Value));
}
default:
throw new RdfException("Only URI/Blank/Literal Nodes can be converted to Jena Nodes");
}
}
/// <summary>
/// Returns an Integer indicating the Ordering of this Node compared to another Node.
/// </summary>
/// <param name="other">Node to test against.</param>
/// <returns></returns>
public override int CompareTo(ILiteralNode other)
{
if (ReferenceEquals(this, other))
{
return(0);
}
if (other == null)
{
// Everything is greater than a null
// Return a 1 to indicate this
return(1);
}
else
{
// URI Nodes are less than Literal Nodes
return(-1);
}
}
public IGraph CreateGraph1()
{
IGraph g = new Graph();
g.BaseUri = new Uri("http://example1.org/");
//Define the Namespaces we want to use
g.NamespaceMap.AddNamespace("ex", new Uri("http://example1.org"));
IUriNode philippe = g.CreateUriNode("ex:Philippe");
IUriNode says = g.CreateUriNode(UriFactory.Create("http://example.org/says"));
ILiteralNode helloWorld = g.CreateLiteralNode("Hello World");
ILiteralNode bonjourMonde = g.CreateLiteralNode("Bonjour tout le Monde", "fr");
g.Assert(new Triple(philippe, says, helloWorld));
g.Assert(new Triple(philippe, says, bonjourMonde));
return(g);
}
/// <summary>
/// Gets the numeric 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>
public override object NumericValue(SparqlEvaluationContext context, int bindingID)
{
INode temp = this._expr.Value(context, bindingID);
if (temp != null)
{
if (temp.NodeType == NodeType.Literal)
{
ILiteralNode lit = (ILiteralNode)temp;
if (lit.DataType != null)
{
if (lit.DataType.ToString().Equals(XmlSpecsHelper.XmlSchemaDataTypeDateTime) || lit.DataType.ToString().Equals(XmlSpecsHelper.XmlSchemaDataTypeDate))
{
DateTimeOffset dt;
if (DateTimeOffset.TryParse(lit.Value, out dt))
{
return(this.NumericValueInternal(dt));
}
else
{
throw new RdfQueryException("Unable to evaluate an XPath Date Time function as the value of the Date Time typed literal couldn't be parsed as a Date Time");
}
}
else
{
throw new RdfQueryException("Unable to evaluate an XPath Date Time function on a typed literal which is not a Date Time");
}
}
else
{
throw new RdfQueryException("Unable to evaluate an XPath Date Time function on an untyped literal argument");
}
}
else
{
throw new RdfQueryException("Unable to evaluate an XPath Date Time function on a non-literal argument");
}
}
else
{
throw new RdfQueryException("Unable to evaluate an XPath Date Time function on a null argument");
}
}
public IGraph CreateGraph2()
{
IGraph g = new Graph();
g.BaseUri = new Uri("http://example1.org/");
//Define the Namespaces we want to use
g.NamespaceMap.AddNamespace("ex", new Uri("http://example1.org"));
IUriNode marina = g.CreateUriNode("ex:Marina");
IUriNode says = g.CreateUriNode(UriFactory.Create("http://example.org/says"));
ILiteralNode helloWorld = g.CreateLiteralNode("Hello World");
ILiteralNode bonjourMonde = g.CreateLiteralNode("Привет мир", "ru");
g.Assert(new Triple(marina, says, helloWorld));
g.Assert(new Triple(marina, says, bonjourMonde));
return(g);
}
/// <summary>
/// Gets the Value of the function as applied to the given String Literal and Argument
/// </summary>
/// <param name="stringLit">Simple/String typed Literal</param>
/// <param name="arg">Argument</param>
/// <returns></returns>
public override IValuedNode ValueInternal(ILiteralNode stringLit, ILiteralNode arg)
{
if (arg == null)
{
return(ValueInternal(stringLit));
}
else
{
string normalized = stringLit.Value;
switch (arg.Value)
{
case XPathFunctionFactory.XPathUnicodeNormalizationFormC:
normalized = normalized.Normalize();
break;
case XPathFunctionFactory.XPathUnicodeNormalizationFormD:
normalized = normalized.Normalize(NormalizationForm.FormD);
break;
case XPathFunctionFactory.XPathUnicodeNormalizationFormFull:
throw new RdfQueryException(".Net does not support Fully Normalized Unicode Form");
case XPathFunctionFactory.XPathUnicodeNormalizationFormKC:
normalized = normalized.Normalize(NormalizationForm.FormKC);
break;
case XPathFunctionFactory.XPathUnicodeNormalizationFormKD:
normalized = normalized.Normalize(NormalizationForm.FormKD);
break;
case "":
// No Normalization
break;
default:
throw new RdfQueryException("'" + arg.Value + "' is not a valid Normalization Form as defined by the XPath specification");
}
return(new StringNode(null, normalized, UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeString)));
}
}
/// <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 a node can copy itself then let it do it
var selfcopyable_original = original as Storage.Virtualisation.ICanCopy;
if (selfcopyable_original != null) return selfcopyable_original.CopyNode(target);
// if it doesn't, copy it's values:
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");
}
}
DateTime GetPublishedDate()
{
if (_publishedDate == DateTime.MinValue)
{
INode subject = _catalogItem.CreateUriNode(_catalogUri);
var pubTriple = _catalogItem.GetTriplesWithSubjectPredicate(subject, _catalogItem.CreateUriNode(Schema.Predicates.Published)).SingleOrDefault();
if (pubTriple != null)
{
ILiteralNode node = pubTriple.Object as ILiteralNode;
if (node != null)
{
_publishedDate = DateTime.ParseExact(node.Value, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
}
}
}
return(_publishedDate);
}
public void NodeCompareToEquivalentLiterals3()
{
Graph g = new Graph();
ILiteralNode canonical = (1d).ToLiteral(g);
ILiteralNode alternate = g.CreateLiteralNode("1.00000", UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeDouble));
List <INode> ns = new List <INode>()
{
canonical,
alternate
};
Assert.NotEqual(canonical, alternate);
Assert.Equal(0, canonical.CompareTo(alternate));
this.ShowOrdering(ns);
this.CheckCombinations(ns);
this.CheckCombinations <ILiteralNode>(ns.OfType <ILiteralNode>().ToList());
this.CheckCombinations(ns, new FastNodeComparer());
}
public void NodeCompareToEquivalentLiterals2()
{
Graph g = new Graph();
ILiteralNode canonical = (true).ToLiteral(g);
ILiteralNode alternate = g.CreateLiteralNode("TRUE", UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeBoolean));
List<INode> ns = new List<INode>()
{
canonical,
alternate
};
Assert.AreNotEqual(canonical, alternate, "Alternate lexical forms should not be equal");
Assert.AreEqual(0, canonical.CompareTo(alternate), "Comparison should compare alternate lexical forms as equal");
this.ShowOrdering(ns);
this.CheckCombinations(ns);
this.CheckCombinations<ILiteralNode>(ns.OfType<ILiteralNode>().ToList());
this.CheckCombinations(ns, new FastNodeComparer());
}
public virtual void SaveToGraph(VDS.RDF.IGraph target, VDS.RDF.IUriNode provCreatingAction)
{
createLocationNode(target);
//assert that it is a location
target.Assert(locationNode, UriNodeExt.RdfType(target), target.CreateUriNode(Properties.Settings.Default.Location));
//assert that it is a tiploc location
target.Assert(locationNode, UriNodeExt.RdfType(target), target.CreateUriNode(Properties.Settings.Default.TiplocLocation));
//link to the tiploc code
ILiteralNode tiplockCodeNode = target.CreateLiteralNode(Tiploc);
IUriNode tiplockUriNode = target.CreateUriNode(Properties.Settings.Default.tiplocCode);
target.Assert(locationNode, tiplockUriNode, tiplockCodeNode);
//set the id
locationNode.IdentifyNode(tiplockCodeNode);
//lastly, do the prov
if (provCreatingAction != null)
{
locationNode.AssertResponibility(provCreatingAction);
}
}
public void IndexingNodesInMultiDictionary1()
{
Graph g = new Graph();
ILiteralNode canonical = (1).ToLiteral(g);
ILiteralNode alternate = g.CreateLiteralNode("01", UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeInteger));
//Use a dud hash function to put everything into a single bucket
MultiDictionary <INode, int> dictionary = new MultiDictionary <INode, int>(n => 1, false);
dictionary.Add(canonical, 1);
Assert.Equal(1, dictionary[canonical]);
dictionary[alternate] = 2;
//With everything in a single bucket the keys should be considered
//equal by the default comparer hence the key count will only be one
//and retrieving with either 2 gives the value from the second Add()
Assert.Single(dictionary);
Assert.Equal(2, dictionary[alternate]);
Assert.Equal(2, dictionary[canonical]);
}
public void ProcessHeader(System.IO.StreamReader inStream, ref VDS.RDF.IGraph targetGraph, VDS.RDF.IUriNode generationActivity, string fileName)
{
string firstLine = inStream.ReadLine();
if (!firstLine.StartsWith("HD"))//header record type is HD
{
throw new ImportFileFormatException(fileName,
"File must include a header, denoted HD",
0,
0
);
}
string mainframe_id = firstLine.Substring(2, 20);
DateTime date_extract = DateTime.ParseExact(firstLine.Substring(22, 10), dtFormat, ProgramState.Provider);
string curr_file_ref = firstLine.Substring(32, 7);
string last_file_ref = firstLine.Substring(39, 7);
// char update_type = firstLine[46];//not going to use this
DateTime extract_start = DateTime.ParseExact(firstLine.Substring(48, 6), dateFormat, ProgramState.Provider);
DateTime extract_end = DateTime.ParseExact(firstLine.Substring(54, 6), dateFormat, ProgramState.Provider);
//Now put that in the graph
string sourceFileUri = Common.ImportFileUriBaseString + "#" + DateTime.Now.ToString("o") + "SourceFile_" + fileName;
IUriNode sourceFileNode = targetGraph.CreateUriNode(UriFactory.Create(sourceFileUri));
targetGraph.Assert(sourceFileNode, UriNodeExt.RdfType(targetGraph), targetGraph.CreateUriNode("prov:Entity"));
if (generationActivity != null)
{
targetGraph.Assert(generationActivity, targetGraph.CreateUriNode(Properties.Settings.Default.provUsed), sourceFileNode);
}
ILiteralNode sourceID = targetGraph.CreateLiteralNode(mainframe_id);
sourceFileNode.IdentifyNode(sourceID);
//IUriNode idNode = targetGraph.CreateUriNode(Properties.Settings.Default.ID);
//targetGraph.Assert(sourceFileNode, idNode, sourceID);
targetGraph.Assert(sourceFileNode, targetGraph.CreateUriNode(UriFactory.Create(Properties.Settings.Default.provGeneratedTime)),
targetGraph.CreateLiteralNode(date_extract.ToString(XmlSpecsHelper.XmlSchemaDateTimeFormat), UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeDateTime)));
IUriNode invalidatedNote = targetGraph.CreateUriNode(Properties.Settings.Default.provInvalidAtTime);
ILiteralNode timeInvalid = targetGraph.CreateLiteralNode(extract_end.ToString(XmlSpecsHelper.XmlSchemaDateTimeFormat), UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeDateTime));
targetGraph.Assert(sourceFileNode, invalidatedNote, timeInvalid);
}
private ILiteralNode CheckArgument(ISparqlExpression expr, SparqlEvaluationContext context, int bindingID, Func <Uri, bool> argumentTypeValidator)
{
INode temp = expr.Evaluate(context, bindingID);
if (temp != null)
{
if (temp.NodeType == NodeType.Literal)
{
ILiteralNode lit = (ILiteralNode)temp;
if (lit.DataType != null)
{
if (argumentTypeValidator(lit.DataType))
{
// Appropriately typed literals are fine
return(lit);
}
else
{
throw new RdfQueryException("Unable to evaluate as one of the argument expressions returned a typed literal with an invalid type");
}
}
else if (argumentTypeValidator(UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeString)))
{
// Untyped Literals are treated as Strings and may be returned when the argument allows strings
return(lit);
}
else
{
throw new RdfQueryException("Unable to evalaute as one of the argument expressions returned an untyped literal");
}
}
else
{
throw new RdfQueryException("Unable to evaluate as one of the argument expressions returned a non-literal");
}
}
else
{
throw new RdfQueryException("Unable to evaluate as one of the argument expressions evaluated to null");
}
}
public static IGraph CreateGraph()
{
IGraph g = new Graph();
g.BaseUri = new Uri("http://example.org/");
IUriNode dotNetRDF = g.CreateUriNode(UriFactory.Create("http://www.dotnetrdf.org"));
IUriNode says = g.CreateUriNode(UriFactory.Create("http://example.org/says"));
ILiteralNode helloWorld = g.CreateLiteralNode("Hello World");
ILiteralNode bonjourMonde = g.CreateLiteralNode("Bonjour tout le Monde", "fr");
g.Assert(new Triple(dotNetRDF, says, helloWorld));
g.Assert(new Triple(dotNetRDF, says, bonjourMonde));
foreach (Triple t in g.Triples)
{
Console.WriteLine(t.ToString());
}
return(g);
}
public String SayHello()
{
logger.LogFunction("SayHello");
var result = "";
Graph g = new Graph();
IUriNode dotNetRDF = g.CreateUriNode(UriFactory.Create("http://www.dotnetrdf.org"));
IUriNode says = g.CreateUriNode(UriFactory.Create("http://example.org/says"));
ILiteralNode helloWorld = g.CreateLiteralNode("Hello World");
ILiteralNode bonjourMonde = g.CreateLiteralNode("Bonjour tout le Monde", "fr");
g.Assert(new Triple(dotNetRDF, says, helloWorld));
g.Assert(new Triple(dotNetRDF, says, bonjourMonde));
foreach (Triple t in g.Triples)
{
result += t.ToString() + "\n";
}
return(result);
}
public ExpansionLinkset(IGraph expansionDescription, INode linksetSubj)
: base(expansionDescription, linksetSubj)
{
this._subject = linksetSubj;
//Check for aat:ignoreLinkset
IEnumerable <Triple> ts = expansionDescription.GetTriplesWithSubjectPredicate(linksetSubj, expansionDescription.CreateUriNode("aat:ignoreDataset"));
Triple t = ts.FirstOrDefault();
if (t != null)
{
if (t.Object.NodeType == NodeType.Literal)
{
ILiteralNode l = (ILiteralNode)t.Object;
if (l.DataType != null && l.DataType.ToString().Equals(XmlSpecsHelper.XmlSchemaDataTypeBoolean))
{
this._ignore = Boolean.Parse(l.Value);
}
}
}
}
DateTime GetPublishedDate()
{
if (_publishedDate == DateTime.MinValue)
{
INode subject = _catalogItem.CreateUriNode(_catalogUri);
var pubTriple = _catalogItem.GetTriplesWithSubjectPredicate(subject, _catalogItem.CreateUriNode(Schema.Predicates.Published)).SingleOrDefault();
if (pubTriple != null)
{
ILiteralNode node = pubTriple.Object as ILiteralNode;
if (node != null)
{
_publishedDate = DateTime.Parse(node.Value);
}
}
}
_publishedDate = _publishedDate.ToUniversalTime();
_listed = (_publishedDate.Year == 1900) ? false : true;
return(_publishedDate);
}
/// <summary>
/// Copies a Node using another Node Factory.
/// </summary>
/// <param name="original">Node to copy.</param>
/// <param name="target">Factory 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 Factories is done.
/// </para>
/// </remarks>
public static INode CopyNode(INode original, INodeFactory target)
{
if (ReferenceEquals(original.Graph, target))
{
return(original);
}
switch (original.NodeType)
{
case NodeType.Blank:
return(target.CreateBlankNode(((IBlankNode)original).InternalID));
case NodeType.GraphLiteral:
return(target.CreateGraphLiteralNode(((IGraphLiteralNode)original).SubGraph));
case NodeType.Literal:
ILiteralNode lit = (ILiteralNode)original;
if (lit.DataType != null)
{
return(target.CreateLiteralNode(lit.Value, lit.DataType));
}
else if (!lit.Language.Equals(String.Empty))
{
return(target.CreateLiteralNode(lit.Value, lit.Language));
}
else
{
return(target.CreateLiteralNode(lit.Value));
}
case NodeType.Uri:
return(target.CreateUriNode(((IUriNode)original).Uri));
case NodeType.Variable:
return(target.CreateVariableNode(((IVariableNode)original).VariableName));
default:
throw new RdfException("Unable to Copy '" + original.GetType().ToString() + "' Nodes between Node Factories");
}
}
/// <summary>
/// Gets the Value of the function as applied to the given String Literal and Argument
/// </summary>
/// <param name="stringLit">Simple/String typed Literal</param>
/// <param name="arg">Argument</param>
/// <returns></returns>
public override IValuedNode ValueInternal(ILiteralNode stringLit, ILiteralNode arg)
{
if (arg.Value.Equals(string.Empty))
{
//The substring after the empty string is the input string
return new StringNode(null, stringLit.Value, UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeString));
}
else
{
//Does the String contain the search string?
if (stringLit.Value.Contains(arg.Value))
{
string result = stringLit.Value.Substring(stringLit.Value.IndexOf(arg.Value) + arg.Value.Length);
return new StringNode(null, result, UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeString));
}
else
{
//If it doesn't contain the search string the empty string is returned
return new StringNode(null, string.Empty, UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeString));
}
}
}
/// <summary>
/// Determines whether two Literals are equal
/// </summary>
/// <param name="a">First Literal</param>
/// <param name="b">Second Literal</param>
/// <returns></returns>
public static bool AreLiteralsEqual(ILiteralNode a, ILiteralNode b)
{
if (ReferenceEquals(a, b)) return true;
if (a == null)
{
if (b == null) return true;
return false;
}
else if (b == null)
{
return false;
}
//Language Tags must be equal (if present)
//If they don't have language tags then they'll both be set to String.Empty which will give true
if (a.Language.Equals(b.Language, StringComparison.OrdinalIgnoreCase))
{
//Datatypes must be equal (if present)
//If they don't have Data Types then they'll both be null
//Otherwise the URIs must be equal
if (a.DataType == null && b.DataType == null)
{
//Use String equality to get the result
return a.Value.Equals(b.Value, StringComparison.Ordinal);
}
else if (a.DataType == null)
{
//We have a Null DataType but the other Node doesn't so can't be equal
return false;
}
else if (b.DataType == null)
{
//The other Node has a Null DataType but we don't so can't be equal
return false;
}
else if (EqualityHelper.AreUrisEqual(a.DataType, b.DataType))
{
//We have equal DataTypes so use String Equality to evaluate
if (Options.LiteralEqualityMode == LiteralEqualityMode.Strict)
{
//Strict Equality Mode uses Ordinal Lexical Comparison for Equality as per W3C RDF Spec
return a.Value.Equals(b.Value, StringComparison.Ordinal);
}
else
{
//Loose Equality Mode uses Value Based Comparison for Equality of Typed Nodes
return (a.CompareTo(b) == 0);
}
}
else
{
//Data Types didn't match
return false;
}
}
else
{
//Language Tags didn't match
return false;
}
}
static JObject MakeLiteralObject(ILiteralNode node)
{
if (node.DataType == null)
{
return new JObject { { "@value", node.Value } };
}
else
{
string dataType = node.DataType.ToString();
switch (dataType)
{
case "http://www.w3.org/2001/XMLSchema#integer":
return new JObject { { "@value", int.Parse(node.Value) } };
case "http://www.w3.org/2001/XMLSchema#boolean":
return new JObject { { "@value", bool.Parse(node.Value) } };
case "http://www.w3.org/2001/XMLSchema#decimal":
return new JObject { { "@value", decimal.Parse(node.Value) } };
case "http://www.w3.org/2001/XMLSchema#long":
return new JObject { { "@value", long.Parse(node.Value) } };
case "http://www.w3.org/2001/XMLSchema#short":
return new JObject { { "@value", short.Parse(node.Value) } };
case "http://www.w3.org/2001/XMLSchema#float":
return new JObject { { "@value", float.Parse(node.Value) } };
case "http://www.w3.org/2001/XMLSchema#double":
return new JObject { { "@value", double.Parse(node.Value) } };
default:
return new JObject
{
{ "@value", node.Value },
{ "@type", dataType }
};
}
}
}
/// <summary>
/// Compares two Literal Nodes
/// </summary>
/// <param name="a">First Literal Node</param>
/// <param name="b">Second Literal Node</param>
/// <returns></returns>
public static int CompareLiterals(ILiteralNode a, ILiteralNode b)
{
if (ReferenceEquals(a, b)) return 0;
if (a == null)
{
if (b == null) return 0;
return -1;
}
else if (b == null)
{
return 1;
}
//Literal Nodes are ordered based on Type and lexical form
if (a.DataType == null && b.DataType != null)
{
//Untyped Literals are less than Typed Literals
//Return a -1 to indicate this
return -1;
}
else if (a.DataType != null && b.DataType == null)
{
//Typed Literals are greater than Untyped Literals
//Return a 1 to indicate this
return 1;
}
else if (a.DataType == null && b.DataType == null)
{
//If neither are typed use Lexical Ordering on the value
return a.Value.CompareTo(b.Value);
}
else if (EqualityHelper.AreUrisEqual(a.DataType, b.DataType))
{
//Are we using a known and orderable DataType?
String type = a.DataType.ToString();
if (!XmlSpecsHelper.IsSupportedType(type))
{
//Don't know how to order so use lexical order on the value
return a.Value.CompareTo(b.Value);
}
else
{
try
{
switch (type)
{
case XmlSpecsHelper.XmlSchemaDataTypeBoolean:
//Can use Lexical ordering for this
return a.Value.ToLower().CompareTo(b.Value.ToLower());
case XmlSpecsHelper.XmlSchemaDataTypeByte:
//Remember that xsd:byte is actually equivalent to SByte in .Net
//Extract the Byte Values and compare
sbyte aSByte, bSByte;
if (SByte.TryParse(a.Value, out aSByte))
{
if (SByte.TryParse(b.Value, out bSByte))
{
return aSByte.CompareTo(bSByte);
}
else
{
return -1;
}
}
else
{
if (SByte.TryParse(b.Value, out bSByte))
{
return 1;
}
else
{
return a.Value.CompareTo(b.Value);
}
}
case XmlSpecsHelper.XmlSchemaDataTypeUnsignedByte:
//Remember that xsd:unsignedByte is equivalent to Byte in .Net
//Extract the Byte Values and compare
byte aByte, bByte;
if (Byte.TryParse(a.Value, out aByte))
{
if (Byte.TryParse(b.Value, out bByte))
{
return aByte.CompareTo(bByte);
}
else
{
return -1;
}
}
else
{
if (Byte.TryParse(b.Value, out bByte))
{
return 1;
}
else
{
return a.Value.CompareTo(b.Value);
}
}
case XmlSpecsHelper.XmlSchemaDataTypeInt:
case XmlSpecsHelper.XmlSchemaDataTypeInteger:
case XmlSpecsHelper.XmlSchemaDataTypeLong:
case XmlSpecsHelper.XmlSchemaDataTypeShort:
//Extract the Integer Values and compare
long aInt64, bInt64;
if (Int64.TryParse(a.Value, out aInt64))
{
if (Int64.TryParse(b.Value, out bInt64))
{
return aInt64.CompareTo(bInt64);
}
else
{
return -1;
}
}
else
{
if (Int64.TryParse(b.Value, out bInt64))
{
return 1;
}
else
{
return a.Value.CompareTo(b.Value);
}
}
case XmlSpecsHelper.XmlSchemaDataTypeNegativeInteger:
case XmlSpecsHelper.XmlSchemaDataTypeNonPositiveInteger:
//Extract the Integer Values, ensure negative and compare
long aNegInt, bNegInt;
if (Int64.TryParse(a.Value, out aNegInt))
{
if (Int64.TryParse(b.Value, out bNegInt))
{
if (aNegInt >= 0)
{
if (bNegInt >= 0)
{
return a.Value.CompareTo(b.Value);
}
else
{
return 1;
}
}
else if (bNegInt >= 0)
{
return -1;
}
else
{
return aNegInt.CompareTo(bNegInt);
}
}
else if (aNegInt >= 0)
{
return a.Value.CompareTo(b.Value);
}
else
{
return -1;
}
}
else
{
if (Int64.TryParse(b.Value, out bNegInt))
{
if (bNegInt >= 0)
{
return a.Value.CompareTo(b.Value);
}
else
{
return 1;
}
}
else
{
return a.Value.CompareTo(b.Value);
}
}
case XmlSpecsHelper.XmlSchemaDataTypeUnsignedInt:
case XmlSpecsHelper.XmlSchemaDataTypeUnsignedLong:
case XmlSpecsHelper.XmlSchemaDataTypeUnsignedShort:
case XmlSpecsHelper.XmlSchemaDataTypeNonNegativeInteger:
case XmlSpecsHelper.XmlSchemaDataTypePositiveInteger:
//Unsigned Integers
//Note that for NonNegativeInteger and PositiveInteger we don't need to do the
//same checking we have to do for their inverse types since parsing into an
//Unsigned Long ensures that they must be positive
ulong aUInt64, bUInt64;
if (UInt64.TryParse(a.Value, out aUInt64))
{
if (UInt64.TryParse(b.Value, out bUInt64))
{
return aUInt64.CompareTo(bUInt64);
}
else
{
return -1;
}
}
else
{
if (UInt64.TryParse(b.Value, out bUInt64))
{
return 1;
}
else
{
return a.Value.CompareTo(b.Value);
}
}
case XmlSpecsHelper.XmlSchemaDataTypeDouble:
//Extract the Double Values and compare
double aDouble, bDouble;
if (Double.TryParse(a.Value, out aDouble))
{
if (Double.TryParse(b.Value, out bDouble))
{
return aDouble.CompareTo(bDouble);
}
else
{
return -1;
}
}
else
{
if (Double.TryParse(b.Value, out bDouble))
{
return 1;
}
else
{
return a.Value.CompareTo(b.Value);
}
}
case XmlSpecsHelper.XmlSchemaDataTypeFloat:
//Extract the Float Values and compare
float aFloat, bFloat;
if (Single.TryParse(a.Value, out aFloat))
{
if (Single.TryParse(b.Value, out bFloat))
{
return aFloat.CompareTo(bFloat);
}
else
{
return -1;
}
}
else
{
if (Single.TryParse(b.Value, out bFloat))
{
return 1;
}
else
{
return a.Value.CompareTo(b.Value);
}
}
case XmlSpecsHelper.XmlSchemaDataTypeHexBinary:
//Extract the numeric value of the Hex encoded Binary and compare
long aHex, bHex;
if (Int64.TryParse(a.Value, System.Globalization.NumberStyles.HexNumber, null, out aHex))
{
if (Int64.TryParse(b.Value, System.Globalization.NumberStyles.HexNumber, null, out bHex))
{
return aHex.CompareTo(bHex);
}
else
{
return -1;
}
}
else
{
if (Int64.TryParse(b.Value, System.Globalization.NumberStyles.HexNumber, null, out bHex))
{
return 1;
}
else
{
return a.Value.CompareTo(b.Value);
}
}
case XmlSpecsHelper.XmlSchemaDataTypeBase64Binary:
//Extract the numeric value of the Base 64 encoded Binary and compare
byte[] aBin, bBin;
try
{
aBin = Convert.FromBase64String(a.Value);
try
{
bBin = Convert.FromBase64String(b.Value);
if (aBin.Length > bBin.Length)
{
return 1;
}
else if (aBin.Length < bBin.Length)
{
return -1;
}
else
{
for (int i = 0; i < aBin.Length; i++)
{
if (aBin[i] != bBin[i])
{
return aBin[i].CompareTo(bBin[i]);
}
}
return 0;
}
}
catch
{
return -1;
}
}
catch
{
try
{
bBin = Convert.FromBase64String(b.Value);
return 1;
}
catch
{
return a.Value.CompareTo(b.Value);
}
}
case XmlSpecsHelper.XmlSchemaDataTypeString:
//String Type
//Can use Lexical Ordering for this
return a.Value.CompareTo(b.Value);
case XmlSpecsHelper.XmlSchemaDataTypeAnyUri:
//Uri Type
//Try and convert to a URI and use lexical ordering
Uri aUri, bUri;
try
{
aUri = new Uri(a.Value);
try
{
bUri = new Uri(b.Value);
return ComparisonHelper.CompareUris(aUri, bUri);
}
catch
{
return -1;
}
}
catch
{
try
{
bUri = new Uri(b.Value);
return 1;
}
catch
{
return a.Value.CompareTo(b.Value);
}
}
case XmlSpecsHelper.XmlSchemaDataTypeDate:
case XmlSpecsHelper.XmlSchemaDataTypeDateTime:
//Extract the Date Times and compare
DateTimeOffset aDateTimeOffset, bDateTimeOffset;
if (DateTimeOffset.TryParse(a.Value, out aDateTimeOffset))
{
if (DateTimeOffset.TryParse(b.Value, out bDateTimeOffset))
{
return aDateTimeOffset.CompareTo(bDateTimeOffset);
}
else
{
return -1;
}
}
else
{
if (DateTimeOffset.TryParse(b.Value, out bDateTimeOffset))
{
return 1;
}
else
{
return a.Value.CompareTo(b.Value);
}
}
default:
//Don't know how to order so use lexical order
return a.Value.CompareTo(b.Value);
}
}
catch
{
//There was some error suggesting a non-valid value for a type
//e.g. "example"^^xsd:integer
//In this case just use Lexical Ordering
return a.Value.CompareTo(b.Value);
}
}
}
else
{
//No way of ordering by value if the Data Types are different
//Order by Data Type Uri
//This is required or the Value ordering between types won't occur correctly
return ComparisonHelper.CompareUris(a.DataType, b.DataType);
}
}
/// <summary>
/// Formats a Literal Node as a String
/// </summary>
/// <param name="l">Literal Node</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected override string FormatLiteralNode(ILiteralNode l, TripleSegment? segment)
{
StringBuilder output = new StringBuilder();
String value, qname;
bool longlit = false, plainlit = false;
longlit = TurtleSpecsHelper.IsLongLiteral(l.Value);
plainlit = TurtleSpecsHelper.IsValidPlainLiteral(l.Value, l.DataType);
if (plainlit)
{
if (TurtleSpecsHelper.IsValidDecimal(l.Value) && l.Value.EndsWith("."))
{
//Ensure we strip the trailing dot of any xsd:decimal and add a datatype definition
output.Append('"');
output.Append(l.Value.Substring(0, l.Value.Length - 1));
output.Append("\"^^<");
output.Append(this.FormatUri(XmlSpecsHelper.XmlSchemaDataTypeDecimal));
output.Append('>');
}
else
{
//Otherwise just write out the value
output.Append(l.Value);
}
//For integers ensure we insert a space after the literal to ensure it can't ever be confused with a decimal
if (TurtleSpecsHelper.IsValidInteger(l.Value))
{
output.Append(' ');
}
}
else
{
output.Append('"');
if (longlit) output.Append("\"\"");
value = l.Value;
bool fullyEscaped = (longlit) ? value.IsFullyEscaped(this._validEscapes, this._longLitMustEscape) : value.IsFullyEscaped(this._validEscapes, this._litMustEscape);
if (!fullyEscaped)
{
//This first replace escapes all back slashes for good measure
value = value.EscapeBackslashes(this._validEscapes);
//Then remove null character since it doesn't change the meaning of the Literal
value = value.Replace("\0", "");
//Don't need all the other escapes for long literals as the characters that would be escaped are permitted in long literals
//Need to escape " still
value = value.Escape('"');
if (!longlit)
{
//Then if we're not a long literal we'll escape tabs
value = value.Replace("\t", "\\t");
}
}
output.Append(value);
output.Append('"');
if (longlit) output.Append("\"\"");
if (!l.Language.Equals(String.Empty))
{
output.Append('@');
output.Append(l.Language.ToLower());
}
else if (l.DataType != null)
{
output.Append("^^");
if (this._qnameMapper.ReduceToQName(l.DataType.ToString(), out qname))
{
if (TurtleSpecsHelper.IsValidQName(qname))
{
output.Append(qname);
}
else
{
output.Append('<');
output.Append(this.FormatUri(l.DataType));
output.Append('>');
}
}
else
{
output.Append('<');
output.Append(this.FormatUri(l.DataType));
output.Append('>');
}
}
}
return output.ToString();
}
/// <summary>
/// Determines whether the Arguments are valid
/// </summary>
/// <param name="stringLit">String Literal</param>
/// <param name="argLit">Argument Literal</param>
/// <returns></returns>
protected bool IsValidArgumentPair(ILiteralNode stringLit, ILiteralNode argLit)
{
if (stringLit.DataType != null)
{
//If 1st argument has a DataType must be an xsd:string or not valid
if (!stringLit.DataType.ToString().Equals(XmlSpecsHelper.XmlSchemaDataTypeString)) return false;
if (argLit.DataType != null)
{
//If 2nd argument also has a DataType must also be an xsd:string or not valid
if (!argLit.DataType.ToString().Equals(XmlSpecsHelper.XmlSchemaDataTypeString)) return false;
return true;
}
else if (argLit.Language.Equals(string.Empty))
{
//If 2nd argument does not have a DataType but 1st does then 2nd argument must have no
//Language Tag
return true;
}
else
{
//2nd argument does not have a DataType but 1st does BUT 2nd has a Language Tag so invalid
return false;
}
}
else if (!stringLit.Language.Equals(string.Empty))
{
if (argLit.DataType != null)
{
//If 1st argument has a Language Tag and 2nd Argument is typed then must be xsd:string
//to be valid
return argLit.DataType.ToString().Equals(XmlSpecsHelper.XmlSchemaDataTypeString);
}
else if (argLit.Language.Equals(string.Empty) || stringLit.Language.Equals(argLit.Language))
{
//If 1st argument has a Language Tag then 2nd Argument must have same Language Tag
//or no Language Tag in order to be valid
return true;
}
else
{
//Otherwise Invalid
return false;
}
}
else
{
if (argLit.DataType != null)
{
//If 1st argument is plain literal then 2nd argument must be xsd:string if typed
return argLit.DataType.ToString().Equals(XmlSpecsHelper.XmlSchemaDataTypeString);
}
else if (argLit.Language.Equals(string.Empty))
{
//If 1st argument is plain literal then 2nd literal cannot have a language tag to be valid
return true;
}
else
{
//If 1st argument is plain literal and 2nd has language tag then invalid
return false;
}
}
}
/// <summary>
/// Formats a Literal Node
/// </summary>
/// <param name="l">Literal Node</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected override string FormatLiteralNode(ILiteralNode l, TripleSegment? segment)
{
StringBuilder output = new StringBuilder();
String value;
output.Append('"');
value = l.Value;
if (!value.IsFullyEscaped(this._validEscapes, this._litEscapes))
{
//This first replace escapes all back slashes for good measure
value = value.EscapeBackslashes(this._validEscapes);
//Then these escape characters that can't occur in a NTriples literal
value = value.Replace("\n", "\\n");
value = value.Replace("\r", "\\r");
value = value.Replace("\t", "\\t");
value = value.Escape('"');
//Then remove null character since it doesn't change the meaning of the Literal
value = value.Replace("\0", "");
}
foreach (char c in value.ToCharArray())
{
output.Append(this.FormatChar(c));
}
output.Append('"');
if (!l.Language.Equals(String.Empty))
{
output.Append('@');
output.Append(l.Language.ToLower());
}
else if (l.DataType != null)
{
output.Append("^^<");
foreach (char c in this.FormatUri(l.DataType))
{
output.Append(this.FormatChar(c));
}
output.Append('>');
}
return output.ToString();
}
/// <summary>
/// Determines the Length of the given String Literal
/// </summary>
/// <param name = "stringLit">String Literal</param>
/// <returns></returns>
protected override INode ValueInternal(ILiteralNode stringLit)
{
return new LiteralNode(null, stringLit.Value.Length.ToString(),
new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger));
}
/// <summary>
/// Formats a Literal Node
/// </summary>
/// <param name="lit">Literal Node</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected override string FormatLiteralNode(ILiteralNode lit, TripleSegment? segment)
{
StringBuilder output = new StringBuilder();
if (TurtleSpecsHelper.IsValidPlainLiteral(lit.Value, lit.DataType))
{
output.Append(lit.Value);
}
else
{
String value = lit.Value;
if (TurtleSpecsHelper.IsLongLiteral(value))
{
value = value.Replace("\n", "\\n");
value = value.Replace("\r", "\\r");
value = value.Escape('"');
value = value.Replace("\t", "\\t");
//If there are no wrapper characters then we must escape the deliminator
if (value.Contains(this._deliminatorChar))
{
if (this._literalWrapperChar == null && this._longLiteralWrapperChar == null)
{
//Replace the deliminator
value = value.Replace(new String(new char[] { this._deliminatorChar }), new String(new char[] { this._escapeChar, this._deliminatorChar }));
}
}
//Apply appropriate wrapper characters
if (this._longLiteralWrapperChar != null)
{
output.Append(this._longLiteralWrapperChar + value + this._longLiteralWrapperChar);
}
else if (this._literalWrapperChar != null)
{
output.Append(this._literalWrapperChar + value + this._literalWrapperChar);
}
else
{
output.Append(value);
}
}
else
{
//Replace the deliminator
value = value.Replace(new String(new char[] { this._deliminatorChar }), new String(new char[] { this._escapeChar, this._deliminatorChar }));
//Apply appropriate wrapper characters
if (this._literalWrapperChar != null)
{
output.Append(this._literalWrapperChar + value + this._literalWrapperChar);
}
else
{
output.Append(value);
}
}
if (this._fullLiteralOutput)
{
if (!lit.Language.Equals(String.Empty))
{
output.Append("@" + lit.Language.ToLower());
}
else if (lit.DataType != null)
{
output.Append("^^");
if (this._uriStartChar != null) output.Append(this._uriStartChar);
if (this._uriEndChar != null)
{
output.Append(this.FormatUri(lit.DataType));
output.Append(this._uriEndChar);
}
else
{
output.Append(this.FormatUri(lit.DataType));
}
}
}
}
return output.ToString();
}
/// <summary>
/// Converts a Literal Node to a Float
/// </summary>
/// <param name="n">Literal Node</param>
/// <returns></returns>
public static Single ToFloat(ILiteralNode n)
{
if (n.DataType == null) throw new RdfQueryException("Cannot convert an untyped Literal to a Float");
return Single.Parse(n.Value);
}
/// <summary>
/// Converts a Literal Node to an Integer
/// </summary>
/// <param name="n">Literal Node</param>
/// <returns></returns>
public static Int64 ToInteger(ILiteralNode n)
{
if (n.DataType == null) throw new RdfQueryException("Cannot convert an untyped Literal to an Integer");
return Int64.Parse(n.Value);
}
/// <summary>
/// Converts a Literal Node to a Double
/// </summary>
/// <param name="n">Literal Node</param>
/// <returns></returns>
public static Double ToDouble(ILiteralNode n)
{
if (n.DataType == null) throw new RdfQueryException("Cannot convert an untyped Literal to a Double");
return Double.Parse(n.Value);
}
/// <summary>
/// Converts a Literal Node to a Decimal
/// </summary>
/// <param name="n">Literal Node</param>
/// <returns></returns>
public static Decimal ToDecimal(ILiteralNode n)
{
if (n.DataType == null) throw new RdfQueryException("Cannot convert an untyped Literal to a Decimal");
return Decimal.Parse(n.Value);
}
/// <summary>
/// Gets the Value of the function as applied to the given String Literal
/// </summary>
/// <param name="stringLit">Simple/String typed Literal</param>
/// <returns></returns>
protected override IValuedNode ValueInternal(ILiteralNode stringLit)
{
return new StringNode(null, stringLit.Value.ToUpper(), UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeString));
}
/// <summary>
/// Determines whether the given String Literal starts with the given Argument Literal
/// </summary>
/// <param name = "stringLit">String Literal</param>
/// <param name = "argLit">Argument Literal</param>
/// <returns></returns>
protected override bool ValueInternal(ILiteralNode stringLit, ILiteralNode argLit)
{
return stringLit.Value.StartsWith(argLit.Value);
}
/// <summary>
/// Gets the Value of the function as applied to the given String Literal
/// </summary>
/// <param name = "stringLit">Simple/String typed Literal</param>
/// <returns></returns>
protected override INode ValueInternal(ILiteralNode stringLit)
{
return new LiteralNode(null, Uri.EscapeUriString(stringLit.Value));
}
/// <summary>
/// Gets the Value of the function as applied to the given String Literal and Argument
/// </summary>
/// <param name = "stringLit">Simple/String typed Literal</param>
/// <param name = "arg">Argument</param>
/// <returns></returns>
public override INode ValueInternal(ILiteralNode stringLit, ILiteralNode arg)
{
if (arg.Value.Equals(String.Empty))
{
//The substring before the empty string is the empty string
return new LiteralNode(null, String.Empty, new Uri(XmlSpecsHelper.XmlSchemaDataTypeString));
}
else
{
//Does the String contain the search string?
if (stringLit.Value.Contains(arg.Value))
{
String result = stringLit.Value.Substring(0, stringLit.Value.IndexOf(arg.Value));
return new LiteralNode(null, result, new Uri(XmlSpecsHelper.XmlSchemaDataTypeString));
}
else
{
//If it doesn't contain the search string the empty string is returned
return new LiteralNode(null, String.Empty, new Uri(XmlSpecsHelper.XmlSchemaDataTypeString));
}
}
}
/// <summary>
/// Converts the given String Literal to upper case
/// </summary>
/// <param name = "stringLit">String Literal</param>
/// <returns></returns>
protected override INode ValueInternal(ILiteralNode stringLit)
{
return stringLit.DataType != null
? new LiteralNode(null, stringLit.Value.ToUpper(), stringLit.DataType)
: new LiteralNode(null, stringLit.Value.ToUpper(), stringLit.Language);
}
/// <summary>
/// Converts a Literal Node to a Date Time Offset
/// </summary>
/// <param name="n">Literal Node</param>
/// <returns></returns>
public static DateTimeOffset ToDateTimeOffset(ILiteralNode n)
{
if (n.DataType == null) throw new RdfQueryException("Cannot convert an untyped Literal to a Date Time");
return DateTimeOffset.Parse(n.Value, null, System.Globalization.DateTimeStyles.AssumeUniversal);
}
/// <summary> /// Abstract method that child classes must implement to /// </summary> /// <param name = "stringLit"></param> /// <param name = "argLit"></param> /// <returns></returns> protected abstract bool ValueInternal(ILiteralNode stringLit, ILiteralNode argLit);
/// <summary> /// Formats a Literal Node using QName compression for the datatype if possible /// </summary> /// <param name="l">Literal Node</param> /// <param name="segment">Triple Segment</param> /// <returns></returns> protected abstract override string FormatLiteralNode(ILiteralNode l, TripleSegment? segment);
/// <summary>
/// Converts a Literal Node to a Time Span
/// </summary>
/// <param name="n">Literal Node</param>
/// <returns></returns>
public static TimeSpan ToTimeSpan(ILiteralNode n)
{
if (n.DataType == null) throw new RdfQueryException("Cannot convert an untyped Literal to a Time Span");
return TimeSpan.Parse(n.Value);
}
/// <summary>
/// Determines whether the String contains the given Argument
/// </summary>
/// <param name="stringLit">String Literal</param>
/// <param name="argLit">Argument Literal</param>
/// <returns></returns>
protected override bool ValueInternal(ILiteralNode stringLit, ILiteralNode argLit)
{
return stringLit.Value.Contains(argLit.Value);
}
/// <summary>
/// Determines whether the Arguments are valid
/// </summary>
/// <param name = "stringLit">String Literal</param>
/// <param name = "argLit">Argument Literal</param>
/// <returns></returns>
private bool IsValidArgumentPair(ILiteralNode stringLit, ILiteralNode argLit)
{
if (stringLit.DataType != null)
{
//If 1st argument has a DataType must be an xsd:string or not valid
if (!stringLit.DataType.ToString().Equals(XmlSpecsHelper.XmlSchemaDataTypeString)) return false;
if (argLit.DataType != null)
{
//If 2nd argument also has a DataType must also be an xsd:string or not valid
if (!argLit.DataType.ToString().Equals(XmlSpecsHelper.XmlSchemaDataTypeString)) return false;
return true;
}
return argLit.Language.Equals(String.Empty);
}
if (!stringLit.Language.Equals(String.Empty))
{
if (argLit.DataType != null)
{
//If 1st argument has a Language Tag and 2nd Argument is typed then must be xsd:string
//to be valid
return argLit.DataType.ToString().Equals(XmlSpecsHelper.XmlSchemaDataTypeString);
}
return argLit.Language.Equals(String.Empty) || stringLit.Language.Equals(argLit.Language);
}
if (argLit.DataType != null)
{
//If 1st argument is plain literal then 2nd argument must be xsd:string if typed
return argLit.DataType.ToString().Equals(XmlSpecsHelper.XmlSchemaDataTypeString);
}
return argLit.Language.Equals(String.Empty);
}
