private bool IsCurie(String value) { if (value.Contains(':')) { String prefix = value.Substring(0, value.IndexOf(':')); String reference = (prefix.Length + 1 < value.Length ? value.Substring(value.IndexOf(':') + 1) : String.Empty); if (XmlSpecsHelper.IsNCName(prefix)) { if (reference.Equals(String.Empty)) { return(true); } else if (IriSpecsHelper.IsIrelativeRef(reference)) { return(true); } else { return(false); } } else { return(false); } } else { return(value.Equals(String.Empty) || IriSpecsHelper.IsIrelativeRef(value)); } }
/// <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"); } }
/// <summary> /// Determines whether a QName is valid for use in RDF/XML. /// </summary> /// <param name="qname">QName.</param> /// <returns></returns> public static bool IsValidQName(String qname) { if (qname.Contains(":")) { String[] parts = qname.Split(':'); if (parts[0].Length == 0) { // Empty Prefix is permitted return(XmlSpecsHelper.IsNCName(parts[1])); } else { return(XmlSpecsHelper.IsNCName(parts[0]) && XmlSpecsHelper.IsNCName(parts[1])); } } else { return(XmlSpecsHelper.IsNCName(qname)); } }
/// <summary> /// Validates that an ID is a valid NCName /// </summary> /// <param name="value">ID Value to Test</param> /// <returns>True if the ID is valid</returns> /// <remarks>Actual Validation conditions on IDs are stricter than this and this is handled separately by the <see cref="ValidateID()">ValidateID</see> method</remarks> public static bool IsRdfID(String value) { //Must be a valid NCName as defined in the XML Namespace Specification //Which is itself defined in terms of the XML Specification return(XmlSpecsHelper.IsNCName(value)); }
/// <summary> /// Determines whether a given String is a valid QName /// </summary> /// <param name="value">String to test</param> /// <returns></returns> public static bool IsValidQName(String value) { if (value.Contains(':')) { String ns, localname; ns = value.Substring(0, value.IndexOf(':')); localname = value.Substring(value.IndexOf(':') + 1); //Namespace Validation if (!ns.Equals(String.Empty)) { //Allowed empty Namespace if (ns.StartsWith("-")) { //Can't start with a - return(false); } else { char[] nchars = ns.ToCharArray(); if (XmlSpecsHelper.IsNameStartChar(nchars[0]) && nchars[0] != '_') { if (nchars.Length > 1) { for (int i = 1; i < nchars.Length; i++) { //Not a valid Name Char if (!XmlSpecsHelper.IsNameChar(nchars[i])) { return(false); } if (nchars[i] == '.') { return(false); } } //If we reach here the Namespace is OK } else { //Only 1 Character which was valid so OK } } else { //Doesn't start with a valid Name Start Char return(false); } } } //Local Name Validation if (!localname.Equals(String.Empty)) { //Allowed empty Local Name char[] lchars = localname.ToCharArray(); if (XmlSpecsHelper.IsNameStartChar(lchars[0])) { if (lchars.Length > 1) { for (int i = 1; i < lchars.Length; i++) { //Not a valid Name Char if (!XmlSpecsHelper.IsNameChar(lchars[i])) { return(false); } if (lchars[i] == '.') { return(false); } } //If we reach here the Local Name is OK } else { //Only 1 Character which was valid so OK } } else { //Not a valid Name Start Char return(false); } } //If we reach here then it's all valid return(true); } else { //Must contain a colon return(false); } }
private Uri ParseUri(RdfACoreParserContext context, String value, RdfACurieMode mode) { switch (mode) { case RdfACurieMode.Uri: //Resolve as a URI which may be relative return(this.ResolveUri(context, value)); case RdfACurieMode.SafeCurieOrCurieOrUri: if (this.IsSafeCurie(value)) { //If a Safe CURIE must resolve as a CURIE ignoring if not resolvable return(this.ResolveSafeCurie(context, value)); } else { //Otherwise try resolving as a CURIE and if not resolvable try as a URI Uri u = this.ResolveCurie(context, value); if (u == null) { //Try resolving as a URI return(this.ResolveUri(context, value)); } else { //Resolved as a CURIE return(u); } } case RdfACurieMode.TermOrCurieOrAbsUri: if (XmlSpecsHelper.IsNCName(value)) { //If a Term try resolving as a term and ignore if not resolvable return(this.ResolveTerm(context, value)); } else if (this.IsCurie(value)) { //If a CURIE try resolving as a CURIE first Uri u = this.ResolveCurie(context, value); if (u == null) { //If not resolvable as a CURIE try as an absolute URI return(this.ResolveAbsoluteUri(value)); } else { //Resolved as a CURIE return(u); } } else { //Try resolving as an absolute URI return(this.ResolveAbsoluteUri(value)); } default: return(null); } }
private bool ParseProfileAttribute(RdfACoreParserContext context, IRdfAEvent evt) { foreach (Uri u in this.ParseUris(context, evt["profile"])) { try { Graph g = new Graph(); #if !SILVERLIGHT UriLoader.Load(g, u); #else throw new PlatformNotSupportedException("The @profile attribute is not currently supported under Silverlight/Windows Phone 7"); #endif String prefixQuery = "PREFIX rdfa: <" + RdfAParser.RdfANamespace + "> SELECT SAMPLE(?prefix) AS ?NamespacePrefix SAMPLE(?uri) AS ?NamespaceURI WHERE { ?s rdfa:prefix ?prefix ; rdfa:uri ?uri } GROUP BY ?s HAVING (COUNT(?prefix) = 1 && COUNT(?uri) = 1)"; String termQuery = "PREFIX rdfa: <" + RdfAParser.RdfANamespace + "> SELECT SAMPLE(?term) AS ?Term SAMPLE(?uri) AS ?URI WHERE {?s rdfa:term ?term ; rdfa:uri ?uri } GROUP BY ?s HAVING (COUNT(?term) = 1 && COUNT(?uri) = 1)"; //Namespace Mappings Object results = g.ExecuteQuery(prefixQuery); if (results is SparqlResultSet) { SparqlResultSet rset = (SparqlResultSet)results; foreach (SparqlResult r in rset.Results) { INode prefixNode = r["NamespacePrefix"]; INode nsNode = r["NamespaceURI"]; if (prefixNode.NodeType == NodeType.Literal && nsNode.NodeType == NodeType.Literal) { String prefix = ((ILiteralNode)prefixNode).Value.ToLower(); String ns = ((ILiteralNode)nsNode).Value; context.Namespaces.AddNamespace(prefix, new Uri(ns)); } } } //Term Mappings results = g.ExecuteQuery(termQuery); if (results is SparqlResultSet) { SparqlResultSet rset = (SparqlResultSet)results; foreach (SparqlResult r in rset.Results) { INode termNode = r["Term"]; INode uriNode = r["URI"]; if (termNode.NodeType == NodeType.Literal && uriNode.NodeType == NodeType.Literal) { String term = ((ILiteralNode)termNode).Value; String uri = ((ILiteralNode)uriNode).Value; if (XmlSpecsHelper.IsNCName(term)) { context.Terms.AddNamespace(term, new Uri(uri)); } } } } //Vocabulary Setting INode vocabNode = g.GetTriplesWithPredicate(g.CreateUriNode(new Uri(RdfAParser.RdfANamespace + "vocabulary"))).Select(t => t.Object).FirstOrDefault(); if (vocabNode != null) { if (vocabNode.NodeType == NodeType.Literal) { context.DefaultVocabularyUri = new Uri(((ILiteralNode)vocabNode).Value); } else if (vocabNode.NodeType == NodeType.Uri) { context.DefaultVocabularyUri = ((IUriNode)vocabNode).Uri; } } } catch { return(false); } } return(true); }