class TUri: public TObject

 Constructor that calls SetUri with a complete URI.

 Constructor that calls SetUri with a complete URI.

 TUri copy ctor.

 TUri assignment operator.

 Returns the whole URI -
 an implementation of chapter 5.3 component recomposition.
 The result URI is composed out of the five basic parts.

 URI         = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
 hier-part   = "//" authority path-abempty
             / path-absolute
             / path-rootless
             / path-empty

 This functions implements the "remove_dot_segments" routine
 of chapter 5.2.4 "for interpreting and removing the
 special '.' and '..' complete path segments from a
 referenced path".

 Returns kTRUE if instance qualifies as absolute-URI
 absolute-URI  = scheme ":" hier-part [ "?" query ]
 cf. Appendix A.

 Returns kTRUE if instance qualifies as relative-ref
 relative-ref  = relative-part [ "?" query ] [ "#" fragment ]
 cf. Appendix A.

 Returns kTRUE if instance qualifies as URI
 URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
 cf. Appendix A.

 Returns kTRUE if instance qualifies as URI-reference
 URI-reference = URI / relative-ref
 cf. Appendix A.

 Set scheme component of URI:
 scheme      = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )

 Returns kTRUE if string qualifies as URI scheme:
 scheme      = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )

 Returns the authority part of the instance:
 authority   = [ userinfo "@" ] host [ ":" port ]

 Set query component of URI:
 query       = *( pchar / "/" / "?" )

 Returns kTRUE if string qualifies as URI query:
 query       = *( pchar / "/" / "?" )

 Set authority part of URI:
 authority   = [ userinfo "@" ] host [ ":" port ]

 Split into components {userinfo@, host, :port},
 remember that according to the RFC, it is necessary to
 distinguish between missing component (no delimiter)
 and empty component (delimiter present).

 Returns kTRUE if string qualifies as valid URI authority:
 authority   = [ userinfo "@" ] host [ ":" port ]

 Set userinfo component of URI:
 userinfo    = *( unreserved / pct-encoded / sub-delims / ":" )

 Return kTRUE is string qualifies as valid URI userinfo:
 userinfo    = *( unreserved / pct-encoded / sub-delims / ":" )
 this equals to pchar without the '@' character

 Set host component of URI:
 RFC 3986:    host = IP-literal / IPv4address / reg-name
 implemented: host =  IPv4address / reg-name

 Set port component of URI:
 port        = *DIGIT

 Set path component of URI:
 path          = path-abempty    ; begins with "/" or is empty
               / path-absolute   ; begins with "/" but not "//"
               / path-noscheme   ; begins with a non-colon segment
               / path-rootless   ; begins with a segment
               / path-empty      ; zero characters

 Set fragment component of URI:
 fragment    = *( pchar / "/" / "?" )

 Returns kTRUE if string qualifies as valid fragment component
 fragment    = *( pchar / "/" / "?" )

 Display function,
 option "d" .. debug output
 anything else .. simply print URI.

 Initialize this URI object.
 Set all TString members to empty string,
 set all Bool_t members to kFALSE.

 Parse URI and set the member variables accordingly,
 returns kTRUE if URI validates, and kFALSE otherwise:
 URI         = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
 hier-part   = "//" authority path-abempty
             / path-absolute
             / path-rootless
             / path-empty

 hier-part   = "//" authority path-abempty
             / path-absolute
             / path-rootless
             / path-empty

 relative-part = "//" authority path-abempty
               / path-absolute
               / path-noscheme
               / path-empty

 returns hier-part component of URI
 hier-part   = "//" authority path-abempty
             / path-absolute
             / path-rootless
             / path-empty

 Returns kTRUE if string qualifies as hier-part:

 hier-part   = "//" authority path-abempty
             / path-absolute
             / path-rootless
             / path-empty

 Returns kTRUE is string qualifies as relative-part:
 relative-part = "//" authority path-abempty
               / path-absolute
               / path-noscheme
               / path-empty

 Returns kTRUE is string qualifies as relative-part:
 relative-part = "//" authority path-abempty
               / path-absolute
               / path-noscheme
               / path-empty

 Percent-encode and return the given string according to RFC 3986
 in principle, this function cannot fail or produce an error.

 Returns kTRUE if string qualifies as valid host component:
 host = IP-literal / IPv4address / reg-name
 implemented: host =  IPv4address / reg-name

 Retruns kTRUE if string qualifies as valid path component:
 path          = path-abempty    ; begins with "/" or is empty
               / path-absolute   ; begins with "/" but not "//"
               / path-noscheme   ; begins with a non-colon segment
               / path-rootless   ; begins with a segment
               / path-empty      ; zero characters

 Returns kTRUE if string qualifies as valid path-abempty component:
    path-abempty  = *( "/" segment )
    segment       = *pchar

 Returns kTRUE if string qualifies as valid path-absolute component
    path-absolute = "/" [ segment-nz *( "/" segment ) ]
    segment-nz    = 1*pchar
    segment       = *pchar

 Returns kTRUE if string qualifies as valid path-noscheme component:
 path-noscheme = segment-nz-nc *( "/" segment )
 segment-nz-nc = 1*( unreserved / pct-encoded / sub-delims / "@" )
 segment       = *pchar

 Returns kTRUE if string qualifies as valid path-rootless component:
 path-rootless = segment-nz *( "/" segment )

 Returns kTRUE if string qualifies as valid path-empty component:
 path-empty    = 0<pchar>

 Returns kTRUE if string qualifies as valid port component:
 RFC 3986: port        = *DIGIT

 Returns kTRUE if string qualifies as valid reg-name:

  reg-name    = *( unreserved / pct-encoded / sub-delims )
  sub-delims  = "!" / "$" / "&" / "'" / "(" / ")"
                  / "*" / "+" / "," / ";" / "="

 Returns kTRUE, if string holds a valid IPv4 address
 currently only decimal variant supported.
 Existence of leadig 0s or numeric range remains unchecked
 IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet.

 Returns kTRUE, if the given string does not contain
 RFC 3986 reserved characters
 unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"

 Syntax based normalisation according to
 RFC chapter 6.2.2.

 Percent-decode the given string according to chapter 2.1
 we assume a valid pct-encoded string.

 Normalise the percent-encoded parts of the string
 i.e. uppercase the hexadecimal digits
 %[:alpha:][:alpha:] -> %[:ALPHA:][:ALPHA:]

 Percent-decode the given string according to chapter 2.1
 we assume a valid pct-encoded string.

 Transform a URI reference into its target URI using
 given a base URI.
 This is an implementation of the pseudocode in chapter 5.2.2.

 RFC 3986, 5.3.2.
 If the base URI has a defined authority component and an empty
 path, then return a string consisting of "/" concatenated with the
 reference's path; otherwise,
 return a string consisting of the reference's path component
 appended to all but the last segment of the base URI's path (i.e.,
 excluding any characters after the right-most "/" in the base URI
 path, or excluding the entire base URI path if it does not contain
 any "/" characters).