/// <summary> /// Internal Helper method which does the actual loading of the Graph from the Resource /// </summary> /// <param name="handler">RDF Handler to use</param> /// <param name="asm">Assembly to get the resource stream from</param> /// <param name="resource">Full name of the Resource (without the Assembly Name)</param> /// <param name="parser">Parser to use (if null then will be auto-selected)</param> private static void LoadGraphInternal(IRdfHandler handler, Assembly asm, String resource, IRdfReader parser) { //Resource is in the given assembly using (Stream s = asm.GetManifestResourceStream(resource)) { if (s == null) { //Resource did not exist in this assembly throw new RdfParseException("The Embedded Resource '" + resource + "' does not exist inside of " + GetAssemblyName(asm)); } else { //Resource exists //Did we get a defined parser to use? if (parser != null) { parser.Load(handler, new StreamReader(s)); } else { //Need to select a Parser or use StringParser String ext = MimeTypesHelper.GetTrueResourceExtension(resource); MimeTypeDefinition def = MimeTypesHelper.GetDefinitionsByFileExtension(ext).FirstOrDefault(d => d.CanParseRdf); if (def != null) { //Resource has an appropriate file extension and we've found a candidate parser for it parser = def.GetRdfParser(); parser.Load(handler, new StreamReader(s)); } else { //Resource did not have a file extension or we didn't have a parser associated with the extension //Try using StringParser instead String data; using (StreamReader reader = new StreamReader(s)) { data = reader.ReadToEnd(); #if !PORTABLE reader.Close(); #endif } parser = StringParser.GetParser(data); parser.Load(handler, new StringReader(data)); } } } } }
public static void Load(IRdfHandler handler, string filename, Stream inputStream, IRdfReader parser) { if (handler == null) { throw new RdfParseException("Cannot read RDF using a null RDF Handler"); } if (inputStream == null) { throw new RdfParseException("Cannot read RDF from a null Stream"); } if (parser == null) { if (filename != null) { try { String ext = MimeTypesHelper.GetTrueFileExtension(filename); parser = MimeTypesHelper.GetParserByFileExtension(ext); } catch (RdfParserSelectionException) { //If error then we couldn't determine MIME Type from the File Extension RaiseWarning("Unable to select a parser by determining MIME Type from the File Extension"); } } } if (parser == null) { //Unable to determine format from File Extension //Read file in locally and use the StringParser to select a parser RaiseWarning("Attempting to select parser based on analysis of the data file, this requires loading the file into memory"); StreamReader reader = new StreamReader(inputStream); String data = reader.ReadToEnd(); reader.Close(); parser = StringParser.GetParser(data); RaiseWarning("Used the StringParser to guess the parser to use - it guessed " + parser.GetType().Name); parser.Warning += RaiseWarning; parser.Load(handler, new StringReader(data)); } else { //Parser was selected based on File Extension or one was explicitly specified parser.Warning += RaiseWarning; parser.Load(handler, new StreamReader(inputStream)); } }
/// <summary> /// Loads the contents of the given File using a RDF Handler using the given RDF Parser /// </summary> /// <param name="handler">RDF Handler to use</param> /// <param name="filename">File to load from</param> /// <param name="parser">Parser to use</param> public static void Load(IRdfHandler handler, String filename, IRdfReader parser) { if (handler == null) { throw new RdfParseException("Cannot read RDF using a null RDF Handler"); } if (filename == null) { throw new RdfParseException("Cannot read RDF from a null File"); } //Try to get a Parser from the File Extension if one isn't explicitly specified if (parser == null) { try { parser = MimeTypesHelper.GetParser(MimeTypesHelper.GetMimeTypes(Path.GetExtension(filename))); RaiseWarning("Selected Parser " + parser.ToString() + " based on file extension, if this is incorrect consider specifying the parser explicitly"); } catch (RdfParserSelectionException) { //If error then we couldn't determine MIME Type from the File Extension RaiseWarning("Unable to select a parser by determining MIME Type from the File Extension"); } } if (parser == null) { //Unable to determine format from File Extension //Read file in locally and use the StringParser to select a parser RaiseWarning("Attempting to select parser based on analysis of the data file, this requires loading the file into memory"); StreamReader reader = new StreamReader(filename); String data = reader.ReadToEnd(); reader.Close(); parser = StringParser.GetParser(data); RaiseWarning("Used the StringParser to guess the parser to use - it guessed " + parser.GetType().Name); parser.Warning += RaiseWarning; parser.Load(handler, new StringReader(data)); } else { //Parser was selected based on File Extension or one was explicitly specified parser.Warning += RaiseWarning; parser.Load(handler, filename); } }
/// <summary> /// Loads RDF data using an RDF Handler from a data: URI /// </summary> /// <param name="handler">RDF Handler</param> /// <param name="u">URI to load from</param> /// <remarks> /// Invokes the normal <see cref="UriLoader">UriLoader</see> instead if a the URI provided is not a data: URI /// </remarks> /// <exception cref="UriFormatException">Thrown if the metadata portion of the URI which indicates the MIME Type, Character Set and whether Base64 encoding is used is malformed</exception> public static void Load(IRdfHandler handler, Uri u) { if (u == null) { throw new RdfParseException("Cannot load RDF from a null URI"); } if (handler == null) { throw new RdfParseException("Cannot read RDF into a null RDF Handler"); } if (!u.Scheme.Equals("data")) { // Invoke the normal URI Loader if not a data: URI UriLoader.Load(handler, u); return; } String mimetype = "text/plain"; bool mimeSet = false; bool base64 = false; String[] uri = u.AbsolutePath.Split(','); String metadata = uri[0]; String data = uri[1]; // Process the metadata if (metadata.Equals(String.Empty)) { // Nothing to do } else if (metadata.Contains(';')) { if (metadata.StartsWith(";")) { metadata = metadata.Substring(1); } String[] meta = metadata.Split(';'); for (int i = 0; i < meta.Length; i++) { if (meta[i].StartsWith("charset=")) { // OPT: Do we need to process the charset parameter here at all? // String charset = meta[i].Substring(meta[i].IndexOf('=') + 1); } else if (meta[i].Equals("base64")) { base64 = true; } else if (meta[i].Contains('/')) { mimetype = meta[i]; mimeSet = true; } else { throw new UriFormatException("This data: URI appears to be malformed as encountered the parameter value '" + meta[i] + "' in the metadata section of the URI"); } } } else { if (metadata.StartsWith("charset=")) { // OPT: Do we need to process the charset parameter here at all? } else if (metadata.Equals(";base64")) { base64 = true; } else if (metadata.Contains('/')) { mimetype = metadata; mimeSet = true; } else { throw new UriFormatException("This data: URI appears to be malformed as encountered the parameter value '" + metadata + "' in the metadata section of the URI"); } } // Process the data if (base64) { StringWriter temp = new StringWriter(); foreach (byte b in Convert.FromBase64String(data)) { temp.Write((char)((int)b)); } data = temp.ToString(); } else { data = Uri.UnescapeDataString(data); } // Now either select a parser based on the MIME type or let StringParser guess the format try { if (mimeSet) { // If the MIME Type was explicitly set then we'll try and get a parser and use it IRdfReader reader = MimeTypesHelper.GetParser(mimetype); reader.Load(handler, new StringReader(data)); } else { // If the MIME Type was not explicitly set we'll let the StringParser guess the format IRdfReader reader = StringParser.GetParser(data); reader.Load(handler, new StringReader(data)); } } catch (RdfParserSelectionException) { // If we fail to get a parser then we'll let the StringParser guess the format IRdfReader reader = StringParser.GetParser(data); reader.Load(handler, new StringReader(data)); } }