java.lang.Object
- org.apache.jena.irix.IRIx

Direct Known Subclasses:

IRIProviderJenaIRI.IRIxJena
```
public abstract class IRIx
extends java.lang.Object
```
Support for RFC3986 IRIs.
The class IRIx is an abstraction layer; a provider is needed to give an implementation. A provider is selected at start-up and is not expected to change while the system is running.
Use IRIs.reference(java.lang.String) to check a string is suitable for us in RDF.

See Also:

for resolving relative IRIs against a base., for functions related to IRIs

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`static IRIx`	`create(java.lang.String iri)`	Create an `IRIx` without resolving the iri.
`static IRIx`	`createAny(java.lang.String iri)`	Create an `IRIx` for any string.
`abstract boolean`	`equals(java.lang.Object other)`
`abstract java.lang.Object`	`getImpl()`	Return the implementation object of the provider.
`abstract int`	`hashCode()`
`abstract boolean`	`hasScheme(java.lang.String scheme)`	Test whether the IRI has the given scheme name.
`abstract boolean`	`isAbsolute()`	An absolute URI is one with a URI scheme and without a fragment.
`abstract boolean`	`isReference()`	An RDF Reference is an URI which has scheme.
`abstract boolean`	`isRelative()`	A relative URI one without a scheme, and maybe without some of the other parts.
`abstract IRIx`	`normalize()`	Syntax-based Normalization Normalize an `IRIx`.
`abstract IRIx`	`relativize(IRIx other)`	Return (if possible), an IRI that is relative to the base argument.
`abstract IRIx`	`resolve(java.lang.String other)`	Try to resolve a string against this IRI as base.
`abstract IRIx`	`resolve(IRIx other)`	Try to resolve a string against this IRI as base.
`java.lang.String`	`str()`	Return the URI as string.
`java.lang.String`	`toString()`	User readable form.

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Method Detail
  - create
```
public static IRIx create(java.lang.String iri)
                   throws IRIException
```
    Create an IRIx without resolving the iri. This operation may throw an IRIException.
    See IRIs.resolve(String) to create an absolute IRI, resolving against the system base if necessary.
    See IRIs.check(String) to check a string is an absolute URI and is suitable for use in RDF.
    See IRIs.reference(String) when the string is an absolute URI and should not be resolved against local system base (e.g. it was passed in from outside) to create an IRIx that is suitable for use in RDF.
    
    Throws:
    
    IRIException
  - createAny
```
public static IRIx createAny(java.lang.String iri)
                      throws IRIException
```
    Create an IRIx for any string. It returns a IRIx holder and does no checking whatsoever. Whether the IRI "works" is down to care by the application.
    
    Throws:
    
    IRIException
  - isAbsolute
```
public abstract boolean isAbsolute()
```
    An absolute URI is one with a URI scheme and without a fragment. The other components, host (authority), path, and query, are optional.
    absolute-URI = scheme ":" hier-part [ "?" query ]
    Beware of the meaning : http:abc is an absolute URI - it has only a schema and a path without a root.
    Note that a URI can be both "not absolute" and "not relative", e.g. http://example/path#fragment.
    See isReference() for testing whether a URI is suitable for use in RDF.
  - isRelative
```
public abstract boolean isRelative()
```
    A relative URI one without a scheme, and maybe without some of the other parts.
    Often it is just the path part.
    See isReference() for testing whether a URI is suitable for use in RDF.
    Note that a URI can be both "not absolute" and "not relative", e.g. http://example/path#fragment.
  - hasScheme
```
public abstract boolean hasScheme(java.lang.String scheme)
```
    Test whether the IRI has the given scheme name.
    The scheme name should be lowercase.
  - isReference
```
public abstract boolean isReference()
```
    An RDF Reference is an URI which has scheme. If it is hierarchical, it should have a non-empty host authority. It may have a query component and may have a fragment component. This not a term in RFC 3986 and it is not the same as "absolute URI".
    In RDF data it is a useful concept. It is either an absolute URI, but if it is hierarchical, it must have a host.
    Examples:
    
    http://www.w3.org/
    http://www.w3.org/1999/02/22-rdf-syntax-ns#type
    urn:abc:def
    urn:abc:def#frag
    but not
    
    http:abc -- no host authority; HTTP is a hierarchical URI scheme
    http:// -- the http(s) URI scheme requires the host to be not empty if there is an authority component.
    
    In practical terms:
    
    It has a scheme name.
    It does not have user info ("user:password@")
    It can have a fragment.
    If it is an HTTP URI:
    
    It has a host authority, that is, a "//" section
    It should have a path (starting "/" after the host authority) but this is not required.
    
    If it is a URN (RFC8141), which is a "rootless URI" with no "//" part:
    
    Optionally, it can have a r-component (though this is not advised), a q-component, and a f-component (which is a URI fragment).
  - resolve
```
public abstract IRIx resolve(java.lang.String other)
```
    Try to resolve a string against this IRI as base. This call is "base.resolver(possibleRelativeIRI)". Throw IRIException if the string does not conform to the IRI grammar.
  - resolve
```
public abstract IRIx resolve(IRIx other)
```
    Try to resolve a string against this IRI as base. Throw IRIException if the string does not conform to the IRI grammar. Return the original IRIx if there is no change.
  - normalize
```
public abstract IRIx normalize()
```
    Syntax-based Normalization Normalize an IRIx.
  - relativize
```
public abstract IRIx relativize(IRIx other)
```
    Return (if possible), an IRI that is relative to the base argument. If this IRI is a relative path, this is returned unchanged.
    The base ("this" object) must have a scheme, have no fragment and no query string. Only the path name is made relative.
    If no relative IRI can be found, return null.
  - str
```
public java.lang.String str()
```
    Return the URI as string. This has a stronger contract than "toString". "Object.toString" is a user readable string (e.g. it might add enclosing "<>" or show the parsed structure of the IRI) whereas asString() is by contract the string that comprises the IRI. The string returned may be the normalized form. It is guaranteed to be usable as string in other API calls that expect a IRI in string form if the original input was a legal IRI by the RFC grammar and any additional scheme-specific rules the IRI provider enforces.
  - getImpl
```
public abstract java.lang.Object getImpl()
```
    Return the implementation object of the provider. The class of the object depends on the provider.
  - hashCode
```
public abstract int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - equals
```
public abstract boolean equals(java.lang.Object other)
```
    Overrides:
    
    equals in class java.lang.Object
  - toString
```
public java.lang.String toString()
```
    User readable form. Not guaranteed to be usable as a string in other API calls. Use str() to get a string form that represents the IRI in the RFC grammar.
    
    Overrides:
    
    toString in class java.lang.Object

Class IRIx

Method Summary

Methods inherited from class java.lang.Object

Method Detail

create

createAny

isAbsolute

isRelative

hasScheme

isReference

resolve

resolve

normalize

relativize

str

getImpl

hashCode

equals

toString