public class AddressParser extends Parser implements Address
URI = (absoluteURI | relativeURI) absoluteURI = scheme ":" ("//" netpath | relativeURI) relativeURI = path ["?" querypart] netpath = domain [":" port] relativeURI path = *("/" segment) segment = *pchar *( ";" param )This implements the
Address
interface and provides
methods that access the various parts of the URI. The parameters
in the path segments of the uniform resource identifier are
stored in name value pairs. If parameter names are not unique
across the path segments then only the deepest parameter will be
stored from the path segment. For example if the URI represented
was http://domain/path1;x=y/path2;x=z
the value for
the parameter named x
would be z
.
This will normalize the path part of the uniform resource identifier. A normalized path is one that contains no back references like "./" and "../". The normalized path will not contain the path parameters.
The setPath
method is used to reset the path this
uniform resource identifier has, it also resets the parameters.
The parameters are extracted from the new path given.
Constructor and Description |
---|
AddressParser()
Default constructor will create a
AddressParser
that contains no specifics. |
AddressParser(String text)
This is primarily a convenience constructor.
|
Modifier and Type | Method and Description |
---|---|
String |
getDomain()
This is used to retrieve the domain of this URI.
|
KeyMap<String> |
getParameters()
This extracts the parameter values from the uniform resource
identifier represented by this object.
|
Path |
getPath()
This is used to retrieve the path of this URI.
|
int |
getPort()
This is used to retrieve the port of the uniform resource
identifier.
|
Query |
getQuery()
This is used to retrieve the query of this URI.
|
String |
getScheme()
This allows the scheme of the URL given to be returned.
|
protected void |
init()
This will empty each tokens cache.
|
protected void |
parse()
This will check to see what type of URI this is if it is an
absoluteURI or a relativeURI . |
void |
setDomain(String value)
This will set the domain to whatever value is in the
string parameter.
|
void |
setPath(Path path)
This will set the path to whatever value it is given.
|
void |
setPath(String text)
This will set the path to whatever value it is given.
|
void |
setPort(int port)
This will set the port to whatever value it is given.
|
void |
setQuery(Query query)
This will set the query to whatever value it is given.
|
void |
setQuery(String value)
This will set the query to whatever value it is given.
|
void |
setScheme(String value)
This allows the scheme for the URI to be specified.
|
String |
toString()
This is used to convert this URI object into a
String
object. |
public AddressParser()
AddressParser
that contains no specifics. The instance will return
null
for all the get methods. The parsers
get methods are populated by using the parse
method.public AddressParser(String text)
String
given to extract the specifics. This
could be achieved by calling the default no-arg constructor
and then using the instance to invoke the parse
method on that String
to extract the parts.text
- a String
containing a URI valuepublic String getScheme()
gopher://domain/path
is
a URI that is intended for the gopher protocol. The
scheme is the string gopher
.public String getDomain()
http://domain/path?querypart
. This will
return the value of the domain part. If there is no
domain part then this will return null otherwise the
domain value found in the uniform resource identifier.public Path getPath()
/
to indicate the root.
The Path
object returned by this will contain
no path parameters. The path parameters are available using
the Address
methods. The reason that this does not
contain any of the path parameters is so that if the path is
needed to be converted into an OS specific path then the path
parameters will not need to be separately parsed out.
public Query getQuery()
Query
object. The query is
an optional member of a URI and comes after the path part, it
is preceded by a question mark, ?
character.
For example the following URI contains query
for
its query part, http://host:port/path?query
.
This returns a org.simpleframework.http.Query
object that can be used to interact directly with the query
values. The Query
object is a read-only interface
to the query parameters, and so will not affect the URI.
public int getPort()
http://host:port/path?querypart
. This
will return the value of the port. If there is no port then
this will return -1
because this represents
an impossible uniform resource identifier port. The port
is an optional part.public KeyMap<String> getParameters()
Map
instance.
This will produce unique name and value parameters. Thus if the
URI contains several path segments with similar parameter names
this will return the deepest parameter. For example if the URI
represented was http://domain/path1;x=y/path2;x=z
the value for the parameter named x
would be
z
.
getParameters
in interface Address
public void setScheme(String value)
://
identifier
to ensure that the Address.toString
will
produce the correct syntax.
Caution must be taken to ensure that the port and
the scheme are consistent. So if the original URI
was http://domain:80/path
and the scheme
was changed to ftp
the port number that
remains is the standard HTTP port not the FTP port.
value
- this specifies the protocol this URI
is intended forpublic void setDomain(String value)
toString
method will not contain
the domain. The result of the toString
method will be /path/path?query
. If the
path is non-null this URI will contain the path.value
- this will be the new domain of this
uniform resource identifier, if it is not nullpublic void setPort(int port)
toString
will
will not contain the optional port. If port number is above
0 then the toString
method will produce a URI
like http://host:123/path
but only if there is
a valid domain.port
- the port value that this URI is to havepublic void setPath(String text)
Address.toString
method will
not contain the path, that is if path is null then it will be
interpreted as /
.
This will reset the parameters this URI has. If the value
given to this method has embedded parameters these will form
the parameters of this URI. The value given may not be the
same value that the getPath
produces. The path
will have all back references and parameters stripped.
text
- the path that this URI is to be set withpublic void setPath(Path path)
Address.toString
method
will not contain the path, that is if path is null then it will
be interpreted as /
.
This will reset the parameters this URI has. If the value
given to this method has embedded parameters these will form
the parameters of this URI. The value given may not be the
same value that the getPath
produces. The path
will have all back references and parameters stripped.
path
- the path that this URI is to be set withpublic void setQuery(String value)
Address.toString
method
will not contain the query. If the query was abc
then the toString
method would produce a string
like http://host:port/path?abc
. If the query is
null this URI would have no query part. The query must not
contain the ?
character.value
- the query that this uniform resource identifier
is to be set to if it is non-nullpublic void setQuery(Query query)
Address.toString
method
will not contain the query. If the Query.toString
returns null then the query will be empty. This is basically
the setQuery(String)
method with the string value
from the issued Query.toString
method.query
- a Query
object that contains
the name value parameters for the queryprotected void parse()
absoluteURI
or a relativeURI
. To
see the definition of a URI see RFC 2616 for the definition
of a URL and for more specifics see RFC 2396 for the
expressions.protected void init()
toString
method has been called. Thus when the toString
method is called then the token depends on the value of the
cache alone in further calls to toString
.
However if a URI has just been parsed and that method has
not been invoked then the cache is created from the buf if
its length is greater than zero.public String toString()
String
object. This will only convert the parts of the URI that exist, so
the URI may not contain the domain or the query part and it will
not contain the path parameters. If the URI contains all these
parts then it will return somthing like
scheme://host:port/path/path?querypart
It can return /path/path?querypart
style relative
URI's. If any of the parts are set to null then that part will be
missing, for example if setDomain
method is invoked
with a null parameter then the domain and port will be missing
from the resulting URI. If the path part is set to null using the
setPath
then the path will be /
. An
example URI with the path part of null would be
scheme://host:port/?querypart
Copyright © 2018. All rights reserved.