| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.jena.iri; |
| |
| import java.io.UnsupportedEncodingException; |
| |
| import org.apache.jena.iri.impl.IRIFactoryImpl ; |
| |
| |
| /** |
| * An IRIFactory is the entry point to this module. |
| * It allows: |
| * <ul> |
| * <li>The setting of conformance levels, |
| * particularly identifying which standard(s) to enforce |
| * <li>The creation of IRI objects, checking |
| * them against the selected standard(s) |
| * <li>The setting of optional behaviours, as |
| * specified in the various standard(s) |
| * </ul> |
| * <p> |
| * Any configuration of the factory to implement |
| * particular standards, or to treat particular |
| * violations as warnings or errors, must be |
| * completed before using the construct or create methods. |
| * </p> |
| * <p>The easiest way to use this class is to use |
| * one of the preconfigured factories: |
| * {@link #semanticWebImplementation()} |
| * {@link #iriImplementation()}, |
| * or |
| * {@link #uriImplementation()}. |
| * If none of these meets your application needs |
| * then you have to configure your own factory. |
| * </p> |
| * |
| * <p> |
| * When initializing a factory, the initialization |
| * methods should be used in the following order: |
| * </p> |
| * <ol> |
| * <li>Any of: |
| * <ul> |
| * <li>{@link #securityViolation(boolean, boolean)} |
| * <li> |
| * {@link #dnsViolation(boolean, boolean)} |
| * <li>{@link #shouldViolation(boolean, boolean)} |
| * <li>{@link #mintingViolation(boolean, boolean)} |
| * </ul> |
| * <li>One or more of (note the effect is cumulative, |
| * all the used specifications will be enforced): |
| * <ul> |
| * <li>{@link #useSpecificationIRI(boolean)} |
| * <li>{@link #useSpecificationRDF(boolean)} |
| * <li>{@link #useSpecificationURI(boolean)} |
| * <li>{@link #useSpecificationXLink(boolean)} |
| * <li>{@link #useSpecificationXMLSchema(boolean)} |
| * <li>{@link #useSpecificationXMLSystemID(boolean)} |
| * </ul> |
| <li>Any of the methods that invoke optional behaviour |
| <ul> |
| <li>{@link #allowUnwiseCharacters()} |
| <li>{@link #setEncoding(String)} |
| <li>{@link #setSameSchemeRelativeReferences(String)} |
| </ul> |
| <li>Any scheme specific initialization |
| <ul> |
| <li>{@link #useSchemeSpecificRules(String,boolean)} |
| </ul> |
| * <li>Finally calls to |
| * <ul> |
| * <li>{@link #setIsError(int, boolean)} |
| * <li>{@link #setIsWarning(int, boolean)} |
| * </ul> |
| * </ol> |
| * |
| * <p> |
| * It is possible to make these calls in different |
| * orders, but the resultant behaviour is likely |
| * to be more confusing, and may change in future releases. |
| * </p> |
| * <p>The other initialization methods (probably) do not |
| * have order dependencies.</p> |
| */ |
| |
| public class IRIFactory extends IRIFactoryImpl |
| implements |
| IRIFactoryI { |
| |
| static { |
| // call static initializers |
| new ViolationCodes.Initialize(); |
| } |
| |
| static private IRIFactory jenaFactory; |
| static private IRIFactory theSemWebFactory; |
| static private IRIFactory theURIFactory; |
| static private IRIFactory theIRIFactory; |
| /** |
| * This factory implements RFC 3987 |
| * <a href="http://www.apps.ietf.org/rfc/rfc3987.html"> |
| * Internationalized Resource Identifiers (IRIs) |
| * </a>. |
| * @return An implementation of RFC 3987 |
| */ |
| static public IRIFactory iriImplementation() { |
| return theIRIFactory; |
| } |
| |
| |
| /** |
| * This factory implements RFC 3986 |
| * <a href="http://www.apps.ietf.org/rfc/rfc3986.html"> |
| * Uniform Resource Identifier (URI): Generic Syntax |
| * </a>. |
| * @return An implementation of RFC 3986 |
| */ |
| static public IRIFactory uriImplementation() { |
| return theURIFactory; |
| } |
| |
| |
| /** |
| * This factory is a conservative implementation |
| * appropriate for Semantic Web applications. |
| * It implements: |
| * RDF URI Reference (essential), |
| * IRI (needed for SPARQL) and |
| * XLink locator (ensures that only legal XML characters are |
| * included, allowing RDF/XML usage). |
| * In addition, {@link ViolationCodes#NON_INITIAL_DOT_SEGMENT} |
| * is treated as an error (since |
| * any IRI with this condition cannot be |
| * serialized in RDF/XML, which resolves |
| * all IRIs against the inscope base, and hence uses |
| * the remove_dot_segments algorithm). |
| * This should ensure that any IRI that is |
| * not in error, can be used |
| * interoperably in RDF/XML, SPARQL, N3 |
| * and N-Triple. |
| * <p> |
| * This is the support for RDF 1.0 / RDF 2004 which includes "RDF URI References" |
| * (they are very broad and allow spaces, for example; the IRI RFC was not finalized |
| * when the RDF 1.1 specs were published). |
| * Nowadays, IRIs are strongly preferred by the semantic web standards. |
| |
| * @return A factory suitable for Semantic Web applications. |
| * @deprecated Use {@link #iriImplementation()} |
| */ |
| @Deprecated |
| static public IRIFactory semanticWebImplementation() { |
| return theSemWebFactory; |
| } |
| /** |
| * For use by Jena intenal use only. |
| * <p> |
| * This is the support for RDF 1.0 / RDF 2004 which includes "RDF URI References" |
| * (they are very broad and allow spaces, for example; the IRI RFC was not finalized |
| * when the RDF 1.1 specs were published). |
| * Nowadays, IRIs are strongly preferred by the semantic web standards. |
| * @return A factory suitable for Jena. |
| * @deprecated Use {@link #iriImplementation()} |
| */ |
| @Deprecated |
| static public IRIFactory jenaImplementation() { |
| return jenaFactory; |
| } |
| private boolean usingSpecXMLSchema = false; |
| |
| /** |
| * Create a new IRIFactory without |
| * any conformance settings. |
| * To check for errors, you must call one or more |
| * of {@link #useSpecificationIRI(boolean)}, |
| * {@link #useSpecificationRDF(boolean)}, |
| * {@link #useSpecificationURI(boolean)}, |
| * {@link #useSpecificationXMLSchema(boolean)}, |
| * {@link #useSpecificationXLink(boolean)} |
| * or |
| * {@link #useSpecificationXMLSystemID(boolean)}. |
| * |
| */ |
| public IRIFactory() { |
| /* |
| * Resets this factory to: |
| * <ul> |
| * <li>ignore all errors, |
| * <li>have no scheme specific rules, |
| * </ul> |
| * */ |
| // TODO copy port numbers into violations.xml |
| // registerScheme("ftp",21); //,H,Q); |
| // registerScheme("http",80); // ,H,U); |
| // registerScheme("gopher",70); |
| // registerScheme("mailto",OPAQUE); |
| // registerScheme("news",OPAQUE); |
| // registerScheme("nntp",119); |
| // registerScheme("telnet",23); |
| // registerScheme("wais",210); |
| // registerScheme("file",GENERIC_NO_PORT); //,H,Q|P|U); |
| // registerScheme("prospero",1525); |
| // registerScheme("z39.50s",210); // 210 |
| // registerScheme("z39.50r",210); |
| // registerScheme("cid",UNKNOWN_SYNTAX); |
| // registerScheme("mid",UNKNOWN_SYNTAX); |
| // registerScheme("vemmi",575); |
| // registerScheme("service",UNKNOWN_SYNTAX); |
| // registerScheme("imap",143); |
| // registerScheme("nfs",UNKNOWN_SYNTAX); |
| // registerScheme("acap",UNKNOWN_SYNTAX); |
| // registerScheme("rtsp",UNKNOWN_SYNTAX); |
| // registerScheme("tip",UNKNOWN_SYNTAX); |
| // registerScheme("pop",UNKNOWN_SYNTAX); |
| // registerScheme("data",UNKNOWN_SYNTAX); |
| // registerScheme("dav",UNKNOWN_SYNTAX); |
| // registerScheme("opaquelocktoken",UNKNOWN_SYNTAX); |
| // registerScheme("sip",UNKNOWN_SYNTAX); |
| // registerScheme("sips",UNKNOWN_SYNTAX); |
| // registerScheme("tel",UNKNOWN_SYNTAX); |
| // registerScheme("fax",UNKNOWN_SYNTAX); |
| // registerScheme("modem",UNKNOWN_SYNTAX); |
| // registerScheme("ldap",UNKNOWN_SYNTAX); |
| // registerScheme("https",443); |
| // registerScheme("soap.beep",605); |
| // registerScheme("soap.beeps",UNKNOWN_SYNTAX); |
| // registerScheme("xmlrpc.beep",602); |
| // registerScheme("xmlrpc.beeps",UNKNOWN_SYNTAX); |
| // registerScheme("urn",OPAQUE); |
| // registerScheme("go",UNKNOWN_SYNTAX); |
| // registerScheme("h323",UNKNOWN_SYNTAX); |
| // registerScheme("ipp",UNKNOWN_SYNTAX); |
| // registerScheme("tftp",69); |
| // registerScheme("mupdate",UNKNOWN_SYNTAX); |
| // registerScheme("pres",UNKNOWN_SYNTAX); |
| // registerScheme("im",UNKNOWN_SYNTAX); |
| // registerScheme("mtqp",UNKNOWN_SYNTAX); |
| // registerScheme("iris.beep",UNKNOWN_SYNTAX); |
| // registerScheme("dict",UNKNOWN_SYNTAX); |
| // registerScheme("snmp",161); |
| // registerScheme("crid",UNKNOWN_SYNTAX); |
| // registerScheme("tag",UNKNOWN_SYNTAX); |
| // registerScheme("dns",UNKNOWN_SYNTAX); |
| // registerScheme("info",UNKNOWN_SYNTAX); |
| // registerScheme("afs",UNKNOWN_SYNTAX); |
| // registerScheme("tn3270",UNKNOWN_SYNTAX); |
| // registerScheme("mailserver",UNKNOWN_SYNTAX); |
| |
| |
| } |
| /** |
| * Create a new IRIFactory with |
| * the same conformance settings as the |
| * template factory. |
| * These can then be modified before using |
| * the new factory. |
| * |
| */ |
| public IRIFactory(IRIFactory template) { |
| super(template); |
| this.usingSpecXMLSchema = template.usingSpecXMLSchema; |
| } |
| // /** |
| // * Create a new IRIFactory with user specified |
| // * conformance behaviour. |
| // * |
| // */ |
| // public IRIFactory(int recsExceptions, int recsWarnings) { |
| //// setConformance(recsExceptions, recsWarnings); |
| //// setExceptionMask(exceptions,warnings); |
| // } |
| |
| // static final private IRIFactory theFactory = new IRIFactory(); |
| // static public IRIFactory defaultFactory() { |
| // return theFactory; |
| // } |
| // public void setConformance(int recsForExceptions, |
| // int recsForWarnings) { |
| // exceptions = recsToMask(recsForExceptions); |
| // warnings = recsToMask(recsForWarnings); |
| // } |
| // public void setExceptionMask(long exceptions_, long warnings_) { |
| // exceptions = exceptions_; |
| // warnings = warnings_; |
| // } |
| |
| // choice point: IRIs are heavy weight objects |
| // use String s for long term storage, and reparse them |
| // public void setCompact(boolean compact) { |
| // |
| // } |
| // public void setComponentCaching(boolean caching){ |
| // |
| // } |
| |
| |
| // public IRI emptyIRI() { |
| // return new IRIImpl(this); |
| // } |
| |
| /** |
| * Allows scheme:relative-path as a relative |
| * reference against a base URI from the same scheme. |
| * |
| * <p> |
| * Sets the behaviour of the relative |
| * reference resolution algorithm to be the |
| * backward compatible mode described |
| * in the URI specification: |
| * </p> |
| * <blockquote> |
| <pre> |
| -- A non-strict parser may ignore a scheme in the reference |
| -- if it is identical to the base URI's scheme. |
| -- |
| if ((not strict) and (R.scheme == Base.scheme)) then |
| undefine(R.scheme); |
| endif; |
| </pre> |
| * |
| * </blockquote> |
| * @param scheme The scheme to enable this behaviour for, or "*" for all schemes |
| */ |
| @Override |
| public void setSameSchemeRelativeReferences(String scheme) { |
| super.setSameSchemeRelativeReferences(scheme); |
| } |
| /** |
| * Allows the unwise characters as optionally |
| * permitted by RFC 3987 (IRI). |
| * <blockquote> |
| Systems accepting IRIs MAY also deal with the |
| printable characters in US-ASCII that are not allowed |
| in URIs, namely "<", ">", '"', space, "{", "}", "|", |
| "\", "^", and "`", in step 2 above. If these characters |
| are found but are not converted, then the conversion |
| SHOULD fail. Please note that the number sign ("#"), |
| the percent sign ("%"), and the square bracket |
| characters ("[", "]") are not part of the above list |
| * </blockquote> |
| *<p>This method is intended to be used |
| *with factories that are using the IRI |
| *specification. |
| *The unwise characters are treated as minting |
| *warnings after this method is called. |
| *This method does not override any setting |
| *from {@link #useSpecificationXMLSchema(boolean)} |
| *concerning {@link ViolationCodes#DOUBLE_WHITESPACE}. |
| *</p> |
| */ |
| public void allowUnwiseCharacters() { |
| boolean warning = getAsErrors(MINTING)||getAsWarnings(MINTING); |
| setIsError(UNWISE_CHARACTER,false); |
| setIsError(WHITESPACE,false); |
| setIsWarning(UNWISE_CHARACTER,warning); |
| setIsWarning(WHITESPACE,warning); |
| if (!usingSpecXMLSchema ) { |
| setIsError(DOUBLE_WHITESPACE,false); |
| setIsWarning(DOUBLE_WHITESPACE,warning); |
| } |
| } |
| |
| /** |
| * The character constraints on the query component |
| * of an IRI are weaker than on other components. |
| * It is not clear how much weaker. |
| * Calling this method with <code>restrict=false</code> |
| * removes (all?) restrictions, calling this method |
| * with <code>restrict=true</code> adds restrictions, |
| * specifically disallowing private use codepoints. |
| * @param restrict True to make the query component checking stricter, false to make the query component checking more lenient |
| */ |
| public void setQueryCharacterRestrictions(boolean restrict){ |
| // TODO setQueryCharacterRestrictions |
| throw new UnsupportedOperationException("unimplemented"); |
| } |
| /** |
| * Sets the character encoding to use |
| * for decoding and encoding to percent escape sequences. |
| * UTF-8 is always used for the hostname. |
| * <p> |
| * Using this method does not conform with |
| * the IRI specification, or XLink, XML system identifiers, |
| * RDF URI references, or XML Schema anyURI. |
| * This method is conformant with the URI specification. |
| *</p> |
| * |
| *@throws IllegalStateException If this factory has already been used to create an IRI. |
| @throws UnsupportedEncodingException If the encoding is not supported. |
| */ |
| @Override |
| public void setEncoding(String enc) throws UnsupportedEncodingException { |
| super.setEncoding(enc); |
| } |
| |
| |
| /** |
| * Create an IRI from the given components. |
| * Performs whatever percent escaping |
| * or punycode encoding is necessary |
| * to make this IRI legal for this factory |
| * (if possible). |
| * Omitted components are passed as null. |
| * |
| * @param scheme Schema |
| * @param userInfo User Info |
| * @param host Will be encoded using punycode, if necessary. |
| * @param port May be 0 for no port. |
| * @param path May not be null |
| * @param query Query string |
| * @param fragment Fragment |
| * @return An IRI with the given components. |
| @see #setEncoding(String) |
| */ |
| |
| public IRI create( |
| String scheme, |
| String userInfo, |
| String host, |
| int port, |
| String path, |
| String query, |
| String fragment |
| ) { |
| // TODO create/7 |
| return null; |
| } |
| |
| |
| /** |
| * Create an IRI from the given components. |
| * Performs whatever percent escaping is necessary |
| * to make this IRI legal for this factory |
| * (if possible). |
| * Omitted components are passed as null. |
| * Use {@link #create(String, String, String, int, String, String, String)} |
| * when the authority is a DNS hostname, even if |
| * both the user information and the port are unspecified; |
| * this version uses percent escaping as opposed to punycode |
| * for the authority. DNS hostnames should be |
| * escaped in punycode (if necessary). |
| * @param scheme Scheme |
| * @param authority Will be percent escaped if necessary |
| * @param path May not be null |
| * @param query Query |
| * @param fragment Fragment |
| * @return An IRI with the given components. |
| @see #setEncoding(String) |
| */ |
| public IRI create( |
| String scheme, |
| String authority, |
| String path, |
| String query, |
| String fragment |
| ) { |
| // TODO create/5 |
| return null; |
| } |
| |
| /** |
| * Create an IRI from the given components. |
| * Performs whatever percent escaping |
| * or punycode encoding is necessary |
| * to make this IRI legal for this factory |
| * (if possible). |
| * Omitted components are passed as null. |
| * @param scheme Scheme |
| * @param userInfo user info |
| * @param host Will be encoded using punycode, if necessary. |
| * @param port May be 0 for no port. |
| * @param path May not be null |
| * @param query Query string |
| * @param fragment Fragment |
| * @return An IRI with the given components. |
| * * @throws IRIException If the resulting IRI |
| * has unfixable errors, e.g. non-ascii chars in the scheme name |
| |
| @see #setEncoding(String) |
| */ |
| public IRI construct( |
| String scheme, |
| String userInfo, |
| String host, |
| int port, |
| String path, |
| String query, |
| String fragment |
| ) throws IRIException { |
| return throwAnyErrors(create( scheme, |
| userInfo, |
| host, |
| port, |
| path, |
| query, |
| fragment |
| )); |
| } |
| |
| /** |
| * Create an IRI from the given components. |
| * Performs whatever percent escaping is necessary |
| * to make this IRI legal for this factory |
| * (if possible). |
| * Omitted components are passed as null. |
| * Use {@link #construct(String, String, String, int, String, String, String)} |
| * when the authority is a DNS hostname, even if |
| * both the user information and the port are unspecified; |
| * this version uses percent escaping as opposed to punycode |
| * for the authority. DNS hostnames should be |
| * escaped in punycode (if necessary). |
| * @param scheme Scheme |
| * @param authority Will be percent escaped if necessary |
| * @param path May not be null |
| * @param query Query string |
| * @param fragment Fragment |
| * @return An IRI with the given components. |
| |
| * @throws IRIException If the resulting IRI |
| * has unfixable errors, e.g. non-ascii chars in the scheme name |
| |
| @see #setEncoding(String) |
| */ |
| public IRI construct( |
| String scheme, |
| String authority, |
| String path, |
| String query, |
| String fragment |
| ) throws IRIException { |
| return throwAnyErrors(create( scheme, |
| authority, |
| path, |
| query, |
| fragment |
| )); |
| } |
| |
| /** |
| * Is condition #<code>code</code> being treated as an error. |
| * @param code A condition code from {@link ViolationCodes}. |
| * |
| */ |
| public boolean isError(int code) { |
| return (errors & (1l<<code))!=0; |
| } |
| |
| /** |
| * Is condition #<code>code</code> |
| * being treated as a warning. |
| * @param code A condition code from {@link ViolationCodes}. |
| */ |
| public boolean isWarning(int code) { |
| return (warnings & (1l<<code))!=0; |
| } |
| |
| /** |
| * Set condition #<code>code</code> |
| * to be treated as an error; or clear it as an error condition. |
| * <p> |
| * Care must be taken when using this to clear the error behaviour |
| * on a code documented |
| * in {@link ViolationCodes} |
| * as having SHOULD force: |
| * see the documentation at {@link #shouldViolation(boolean, boolean)}, |
| * concerning the necessary steps. |
| * Using this method with <code>code</code> |
| * being one that is documented as having MUST force |
| * will result in non-conformant behaviour. |
| * </p> |
| * @param code A condition code from {@link ViolationCodes}. |
| * @param set True to set this as an error, false to clear. |
| * @throws IllegalStateException If this factory has already been used to create an IRI. |
| */ |
| public void setIsError(int code, boolean set) { |
| |
| initializing(); |
| if (set) { |
| errors |= (1l<<code); |
| setIsWarning(code,false); |
| } else |
| errors &= ~(1l<<code); |
| } |
| |
| /** |
| * Set condition #<code>code</code> |
| * to be treated as a warning; |
| * or clear it as a warning condition. |
| * Setting a code to be a warning, clears it from |
| * being an error. Care must be taken |
| * if the <code>code</code> is one that is documented |
| * in {@link ViolationCodes} has having SHOULD or MUST |
| * force, since ignoring any resulting warning may |
| * result in a nonconformant application. |
| * @param code A condition code from {@link ViolationCodes}. |
| * @param set True to set this as a warning, false to clear. |
| |
| * @throws IllegalStateException If this factory has already been used to create an IRI. |
| */ |
| public void setIsWarning(int code, boolean set) { |
| |
| initializing(); |
| |
| if (set) { |
| warnings |= (1l<<code); |
| setIsError(code,false); |
| } else |
| warnings &= ~(1l<<code); |
| } |
| |
| /** |
| * Is condition #<code>code</code> being ignored. |
| * @param code A condition code from {@link ViolationCodes}. |
| */ |
| public boolean ignoring(int code) { |
| return !(isError(code)||isWarning(code)); |
| } |
| |
| |
| |
| /** |
| * The factory will check for violations of RFC 3986, URI. |
| * Non-ascii input will result in warnings or errors. |
| * @param asErrors If true, then violations are treated as errors; if false violations are treated as warnings. |
| |
| * @throws IllegalStateException If this factory has already been used to create an IRI. |
| */ |
| public void useSpecificationURI(boolean asErrors){ |
| useSpec("URI",asErrors); |
| } |
| /** |
| * The factory will check for violations of RFC 3987, IRI. |
| * @param asErrors If true, then violations are treated as errors; if false violations are treated as warnings. |
| |
| * @throws IllegalStateException If this factory has already been used to create an IRI. |
| */ |
| public void useSpecificationIRI(boolean asErrors){ |
| useSpec("IRI",asErrors); |
| } |
| |
| /** |
| * The factory will check for violations of RDF URI Reference. |
| * Note: relative IRIs are prohibited. |
| * @param asErrors If true, then violations are treated as errors; if false violations are treated as warnings. |
| |
| * @throws IllegalStateException If this factory has already been used to create an IRI. |
| */ |
| public void useSpecificationRDF(boolean asErrors){ |
| useSpec("RDF",asErrors); |
| } |
| |
| |
| /** |
| * The factory will check for violations of XML Schema anyURI. |
| * @param asErrors If true, then violations are treated as errors; if false violations are treated as warnings. |
| |
| * @throws IllegalStateException If this factory has already been used to create an IRI. |
| |
| */ |
| public void useSpecificationXMLSchema(boolean asErrors){ |
| usingSpecXMLSchema = true; |
| |
| useSpec("Schema",asErrors); |
| } |
| |
| /** |
| * The factory will check for violations of XML constraints on system ID. |
| * Note: fragments are prohibited. |
| * @param asErrors If true, then violations are treated as errors; if false violations are treated as warnings. |
| |
| * @throws IllegalStateException If this factory has already been used to create an IRI. |
| */ |
| public void useSpecificationXMLSystemID(boolean asErrors){ |
| |
| useSpec("XML",asErrors); |
| } |
| /** |
| * The factory will check for violations of XLink locator: <code>href</code> value. |
| * @param asErrors If true, then violations are treated as errors; if false violations are treated as warnings. |
| |
| * @throws IllegalStateException If this factory has already been used to create an IRI. |
| */ |
| public void useSpecificationXLink(boolean asErrors){ |
| useSpec("XLink",asErrors); |
| } |
| /** |
| * The factory will treat |
| * violations of "SHOULD" force statements |
| * from the specifications it is enforcing as errors, |
| * or warnings, or not at all. (Default is error) |
| * |
| * <p> |
| * From <a href="http://www.apps.ietf.org/rfc/rfc2119.html#sec-3">RFC 2119</a> |
| * <em>the full implications must be understood and carefully weighed before</em> |
| * calling this method with <code>isError=false</code>. |
| * Thus, you MUST have read and understood |
| * the specifications that you are configuring the factory |
| * to use, before switching SHOULDs to warnings or to be |
| * ignored. |
| * An easier path, is to understand a specific error code, |
| * with SHOULD force, |
| * and then use {@link #setIsError(int, boolean)}, and |
| * {@link #setIsWarning(int, boolean)} to modify the behaviour |
| * of that error code only. The prerequisite for modifiying a |
| * single error code to be ignored, or to be treated as a warning |
| * is to have understood the full implications of that condition, |
| * rather than of all the SHOULD force statements within all |
| * the specifications being used. |
| * </p> |
| * |
| * |
| * @param isError If true, treat violations of SHOULDs as errors. |
| * @param isWarning If true, treat violations of SHOULDs as warnings. |
| * @throws IllegalArgumentException if <code>isError && isWarning</code>. |
| |
| * @throws IllegalStateException If this factory has already been used to create an IRI. |
| */ |
| public void shouldViolation(boolean isError,boolean isWarning){ |
| setViolation(SHOULD,isError,isWarning); |
| } |
| /** |
| * The factory will treat |
| * violations of statements |
| * from the specifications |
| * flagged as security issues, |
| * including weak heuristical suggestions, |
| * it is enforcing as errors, |
| * or warnings, or not at all. (Default is error) |
| * @param isError If true, treat security violations as errors. |
| * @param isWarning If true, treat security violations as warnings. |
| * @throws IllegalArgumentException if <code>isError && isWarning</code>. |
| */ |
| public void securityViolation(boolean isError,boolean isWarning){ |
| setViolation(SECURITY,isError,isWarning); |
| } |
| /** |
| * The factory will treat |
| * violations of statements |
| * from the implemented scheme specifications |
| * it is enforcing as errors, |
| * or warnings, or not at all. (Default is error) |
| * You must also call {@link #useSchemeSpecificRules(String)} |
| * to enable particular enforcement of particular schemes. |
| * This method primarily permits the scheme specific rules |
| * to be treated as warnings. |
| * @param isError If true, treat scheme violations as errors. |
| * @param isWarning If true, treat scheme violations as warnings. |
| * @throws IllegalArgumentException if <code>isError && isWarning</code>. |
| */ |
| // public void schemeViolation(boolean isError,boolean isWarning){ |
| // setViolation(SCHEME_SPECIFIC,isError,isWarning); |
| // } |
| /** |
| * The factory will treat |
| * violations of statements |
| * from the specifications |
| * flagged as DNS issues, |
| * including Internationalized Domain Name issues, |
| * it is enforcing as errors, |
| * or warnings, or not at all. (Default is error) |
| * |
| * |
| * @param isError If true, treat DNS violations as errors. |
| * @param isWarning If true, treat DNS violations as warnings. |
| * @throws IllegalArgumentException if <code>isError && isWarning</code>. |
| */ |
| public void dnsViolation(boolean isError,boolean isWarning){ |
| setViolation(DNS,isError,isWarning); |
| } |
| /** |
| * The factory will treat |
| * violations of statements |
| * from the specifications concerning |
| * creating new IRIs it is enforcing as errors, |
| * or warnings, or not at all. (Default is warning). |
| * A sample phrase indicating the intent is this one |
| * from RFC 3986: |
| * <blockquote> |
| * An implementation should accept uppercase letters as equivalent to lowercase in scheme names (e.g., allow "HTTP" as well as |
| * "http") for the sake of robustness but |
| * should only produce lowercase scheme names for |
| * consistency. |
| * </blockquote> |
| * @param isError If true, treat violations of minting force statements as errors. |
| * @param isWarning If true, treat violations of minting force statements as warnings. |
| * @throws IllegalArgumentException if <code>isError && isWarning</code>. |
| * @throws IllegalStateException If this factory has already been used to create an IRI. |
| |
| */ |
| public void mintingViolation(boolean isError,boolean isWarning){ |
| setViolation(MINTING,isError,isWarning); |
| } |
| |
| // |
| /* * |
| * Adds a scheme to the list of known schemes. |
| * The <code>port</code> argument either |
| * associates this scheme with a default port number, |
| * and hence with the generic syntax; |
| * or is one of the constants |
| * {@link #GENERIC_NO_PORT}, |
| * {@link #GENERIC_UNKNOWN_PORT}, |
| * {@link #OPAQUE}, |
| * {@link #UNKNOWN_SYNTAX} |
| * to indicate what restrictions if any should |
| * be used. |
| * @param scheme The scheme name to register |
| * @param port The port associated with the scheme, or an appropriate constant. |
| * @throws IllegalStateException If this factory has already been used to create an IRI. |
| */ |
| // public void registerScheme(String scheme, int port){ |
| // |
| // } |
| /** |
| * Use the rules for a given scheme, |
| * or use all known scheme specific rules. |
| * Only a few sets of scheme specific rules are implemented. |
| * In the table below: |
| * <dl> |
| * <dt> |
| * Partial |
| * </dt> |
| * <dd>indicates that some but not all |
| * of the |
| * scheme specific restrictions on the IRI are implemented. |
| * </dd> |
| * <dt> |
| * component |
| * </dt> |
| * <dd>means that the scheme prohibits or requires |
| * one or more components of the IRI; and only |
| * these checks are performed.</dd> |
| * </dl> |
| * </table> |
| * <p>The currently implemented schemes are:</p> |
| * <table> |
| * <tr><th>Scheme</th><th>Level of implementation</th></tr> |
| * <tr><td>none</td><td></td></tr> |
| * </table> |
| * @param scheme The scheme name or "*" to use all implemented scheme specific rules. |
| * @param asErrors If true, then violations are treated as errors; if false violations are treated as warnings. |
| * @throws IllegalStateException If this factory has already been used to create an IRI. |
| */ |
| @Override |
| public void useSchemeSpecificRules(String scheme, boolean asErrors){ |
| super.useSchemeSpecificRules(scheme,asErrors); |
| } |
| |
| static { |
| theIRIFactory = new IRIFactory(); |
| theIRIFactory.useSpecificationIRI(true); |
| theIRIFactory.useSchemeSpecificRules("*",true); |
| theIRIFactory.create(""); |
| |
| jenaFactory = new IRIFactory(); |
| // jenaFactory.dnsViolation(false,false); |
| // jenaFactory.setSameSchemeRelativeReferences("file"); |
| jenaFactory.shouldViolation(false,false); |
| jenaFactory.securityViolation(false,false); |
| jenaFactory.useSpecificationRDF(false); |
| jenaFactory.setIsError(UNREGISTERED_IANA_SCHEME,false); |
| jenaFactory.setIsWarning(UNREGISTERED_IANA_SCHEME,false); |
| jenaFactory.setIsError(CONTROL_CHARACTER,false); |
| jenaFactory.setIsWarning(CONTROL_CHARACTER,false); |
| // jenaFactory.setIsError(PORT_SHOULD_NOT_BE_WELL_KNOWN,false); |
| // jenaFactory.setIsWarning(PORT_SHOULD_NOT_BE_WELL_KNOWN,false); |
| jenaFactory.useSchemeSpecificRules("http",true); |
| jenaFactory.create(""); |
| |
| theURIFactory = new IRIFactory(); |
| theURIFactory.useSpecificationURI(true); |
| theURIFactory.useSchemeSpecificRules("*",true); |
| theURIFactory.create(""); |
| |
| theSemWebFactory = new IRIFactory(); |
| theSemWebFactory.useSpecificationRDF(true); |
| theSemWebFactory.useSpecificationIRI(true); |
| theSemWebFactory.useSpecificationXLink(true); |
| theSemWebFactory.useSchemeSpecificRules("*",true); |
| theSemWebFactory.setIsError(NON_INITIAL_DOT_SEGMENT,true); |
| theSemWebFactory.create(""); |
| |
| } |
| |
| /** |
| * This <em>globally</em> sets the {@link #jenaImplementation}; use with care. |
| * This should be used before any calls to {@link #jenaImplementation}; |
| * it does not modify the factory returned by any previous calls, but subsequent |
| * calls to {@link #jenaImplementation} will return the new value. |
| * @param jf The new Jena Factory |
| */ |
| public static void setJenaImplementation(IRIFactory jf) { |
| jenaFactory = jf; |
| } |
| /** |
| * This <em>globally</em> sets the {@link #iriImplementation}; use with care. |
| * This should be used before any calls to {@link #iriImplementation}; |
| * it does not modify the factory returned by any previous calls, but subsequent |
| * calls to {@link #iriImplementation} will return the new value. |
| * @param iriF The new IRI Factory |
| */ |
| public static void setIriImplementation(IRIFactory iriF) { |
| theIRIFactory = iriF; |
| } |
| /** |
| * This <em>globally</em> sets the {@link #uriImplementation}; use with care. |
| * This should be used before any calls to {@link #uriImplementation}; |
| * it does not modify the factory returned by any previous calls, but subsequent |
| * calls to {@link #uriImplementation} will return the new value. |
| * @param uriF The new URI Factory |
| */ |
| public static void setUriImplementation(IRIFactory uriF) { |
| theURIFactory = uriF; |
| } |
| /** |
| * This <em>globally</em> sets the {@link #semanticWebImplementation}; use with care. |
| * This should be used before any calls to {@link #semanticWebImplementation}; |
| * it does not modify the factory returned by any previous calls, but subsequent |
| * calls to {@link #semanticWebImplementation} will return the new value. |
| * @param sw The new IRI Factory |
| */ |
| public static void setSemanticWebImplementation(IRIFactory sw) { |
| theSemWebFactory = sw; |
| } |
| |
| } |
