// combine all URI fields in a single string, applying funcDecode to each
// component which it may make sense to decode (i.e. "unescape")
wxString wxURI::DoBuildURI(wxString (*funcDecode)(const wxString&)) const
{
wxString ret;
if (HasScheme())
ret += m_scheme + ":";
if (HasServer())
{
ret += "//";
if (HasUserInfo())
ret += funcDecode(m_userinfo) + "@";
if (m_hostType == wxURI_REGNAME)
ret += funcDecode(m_server);
else
ret += m_server;
if (HasPort())
ret += ":" + m_port;
}
ret += funcDecode(m_path);
if (HasQuery())
ret += "?" + funcDecode(m_query);
if (HasFragment())
ret += "#" + funcDecode(m_fragment);
return ret;
}
wxString wxURI::BuildUnescapedURI() const
{
wxString ret;
if (HasScheme())
ret = ret + m_scheme + wxT(":");
if (HasServer())
{
ret += wxT("//");
if (HasUserInfo())
ret = ret + wxURI::Unescape(m_userinfo) + wxT("@");
if (m_hostType == wxURI_REGNAME)
ret += wxURI::Unescape(m_server);
else
ret += m_server;
if (HasPort())
ret = ret + wxT(":") + m_port;
}
ret += wxURI::Unescape(m_path);
if (HasQuery())
ret = ret + wxT("?") + wxURI::Unescape(m_query);
if (HasFragment())
ret = ret + wxT("#") + wxURI::Unescape(m_fragment);
return ret;
}
wxString wxURI::BuildURI() const
{
wxString ret;
if (HasScheme())
ret = ret + m_scheme + wxT(":");
if (HasServer())
{
ret += wxT("//");
if (HasUserInfo())
ret = ret + m_userinfo + wxT("@");
ret += m_server;
if (HasPort())
ret = ret + wxT(":") + m_port;
}
ret += m_path;
if (HasQuery())
ret = ret + wxT("?") + m_query;
if (HasFragment())
ret = ret + wxT("#") + m_fragment;
return ret;
}
bool wxURL::ParseURL()
{
// If the URL was already parsed (m_protocol != NULL), pass this section.
if (!m_protocol)
{
// Clean up
CleanData();
// Make sure we have a protocol/scheme
if (!HasScheme())
{
m_error = wxURL_SNTXERR;
return false;
}
// Find and create the protocol object
if (!FetchProtocol())
{
m_error = wxURL_NOPROTO;
return false;
}
// Do we need a host name ?
if (m_protoinfo->m_needhost)
{
// Make sure we have one, then
if (!HasServer())
{
m_error = wxURL_SNTXERR;
return false;
}
}
}
#if wxUSE_PROTOCOL_HTTP
if (m_useProxy)
{
// Third, we rebuild the URL.
m_url = m_scheme + wxT(":");
if (m_protoinfo->m_needhost)
m_url = m_url + wxT("//") + m_server;
// We initialize specific variables.
m_protocol = m_proxy; // FIXME: we should clone the protocol
}
#endif // wxUSE_PROTOCOL_HTTP
m_error = wxURL_NOERR;
return true;
}
void wxURI::Resolve(const wxURI& base, int flags)
{
wxASSERT_MSG(!base.IsReference(),
"wxURI to inherit from must not be a reference!");
// If we aren't being strict, enable the older (pre-RFC2396) loophole that
// allows this uri to inherit other properties from the base uri - even if
// the scheme is defined
if ( !(flags & wxURI_STRICT) &&
HasScheme() && base.HasScheme() &&
m_scheme == base.m_scheme )
{
m_fields -= wxURI_SCHEME;
}
// Do nothing if this is an absolute wxURI
// if defined(R.scheme) then
// T.scheme = R.scheme;
// T.authority = R.authority;
// T.path = remove_dot_segments(R.path);
// T.query = R.query;
if (HasScheme())
return;
//No scheme - inherit
m_scheme = base.m_scheme;
m_fields |= wxURI_SCHEME;
// All we need to do for relative URIs with an
// authority component is just inherit the scheme
// if defined(R.authority) then
// T.authority = R.authority;
// T.path = remove_dot_segments(R.path);
// T.query = R.query;
if (HasServer())
return;
//No authority - inherit
if (base.HasUserInfo())
{
m_userinfo = base.m_userinfo;
m_fields |= wxURI_USERINFO;
}
m_server = base.m_server;
m_hostType = base.m_hostType;
m_fields |= wxURI_SERVER;
if (base.HasPort())
{
m_port = base.m_port;
m_fields |= wxURI_PORT;
}
// Simple path inheritance from base
if (!HasPath())
{
// T.path = Base.path;
m_path = base.m_path;
m_fields |= wxURI_PATH;
// if defined(R.query) then
// T.query = R.query;
// else
// T.query = Base.query;
// endif;
if (!HasQuery())
{
m_query = base.m_query;
m_fields |= wxURI_QUERY;
}
}
else if ( m_path.empty() || m_path[0u] != '/' )
{
// if (R.path starts-with "/") then
// T.path = remove_dot_segments(R.path);
// else
// T.path = merge(Base.path, R.path);
// T.path = remove_dot_segments(T.path);
// endif;
// T.query = R.query;
//
// So we don't do anything for absolute paths and implement merge for
// the relative ones
wxArrayString our(SplitInSegments(m_path)),
result(SplitInSegments(base.m_path));
if ( !result.empty() )
result.pop_back();
if ( our.empty() )
{
// if we have an empty path it means we were constructed from a "."
// string or something similar (e.g. "././././"), it should count
// as (empty) segment
our.push_back("");
}
const wxArrayString::const_iterator end = our.end();
for ( wxArrayString::const_iterator i = our.begin(); i != end; ++i )
{
if ( i->empty() || *i == "." )
{
// as in ParsePath(), while normally we ignore the empty
// segments, we need to take account of them at the end
if ( i == end - 1 )
result.push_back("");
continue;
}
if ( *i == ".." )
{
if ( !result.empty() )
{
result.pop_back();
if ( i == end - 1 )
result.push_back("");
}
//else: just ignore, extra ".." don't accumulate
}
else
{
if ( result.empty() )
{
// ensure that the resulting path will always be absolute
result.push_back("");
}
result.push_back(*i);
}
}
m_path = wxJoin(result, '/', '\0');
}
//T.fragment = R.fragment;
}
bool wxURI::IsReference() const
{
return !HasScheme() || !HasServer();
}
bool wxURI::operator==(const wxURI& uri) const
{
if (HasScheme())
{
if(m_scheme != uri.m_scheme)
return false;
}
else if (uri.HasScheme())
return false;
if (HasServer())
{
if (HasUserInfo())
{
if (m_userinfo != uri.m_userinfo)
return false;
}
else if (uri.HasUserInfo())
return false;
if (m_server != uri.m_server ||
m_hostType != uri.m_hostType)
return false;
if (HasPort())
{
if(m_port != uri.m_port)
return false;
}
else if (uri.HasPort())
return false;
}
else if (uri.HasServer())
return false;
if (HasPath())
{
if(m_path != uri.m_path)
return false;
}
else if (uri.HasPath())
return false;
if (HasQuery())
{
if (m_query != uri.m_query)
return false;
}
else if (uri.HasQuery())
return false;
if (HasFragment())
{
if (m_fragment != uri.m_fragment)
return false;
}
else if (uri.HasFragment())
return false;
return true;
}
/** Constructs a CUri16 object from the input string.
Can leave if it cannot allocate memory for a CUri object.
The calling program must destroy the CUri16 object when it is no longer
needed.
@return pointer to CUri16 object
@param aUri descriptor to URI
@leave KErrBadName if the input is invalid
*/
CUri16* TUriShortcutParser16::CreateUriL( const TDesC16& aUri ) const
{
const TInt uriLen = aUri.Length();
if ( uriLen == 0 || UriUtils::HasInvalidChars( aUri ) )
{
User::Leave( KErrBadName );
}
TPtrC16 scheme;
TPtrC16 prefix;
TPtrC16 tld;
if ( !HasScheme( aUri ) )
{
if ( HasPath( aUri ) )
{
scheme.Set( DefaultScheme() );
}
else
{
if ( UriUtils::HostType( aUri ) != UriUtils::ETextHost )
{
scheme.Set( DefaultScheme() );
}
else
{
switch ( ComponentCount( aUri ) )
{
case 1:
if ( aUri.CompareF( KLocalhost ) != 0)
{
//add prefix, and tld
prefix.Set( KWww );
tld.Set( DefaultDomain() );
}
//no break after this case
case 2:
scheme.Set( DefaultScheme() );
break;
case 3:
default:
//it has a prefix
scheme.Set( MatchingScheme( aUri ) );
break;
}
}
}
}
//Calculates the length of the buffer needed to construct the complete URI
TInt bufLen = uriLen;
if ( scheme.Length() > 0 )
{
bufLen += scheme.Length() + KSizeOfSchemeSeparator;
}
if ( prefix.Length() > 0 )
{
bufLen += prefix.Length() + 1;//dot separator
}
if ( tld.Length() > 0 )
{
bufLen += tld.Length() + 1;//dot separator
}
//This descriptor must be long enough to contain the entire URI.
HBufC16* uriBuf = HBufC16::NewLC( bufLen );
TPtr16 uriDes( uriBuf->Des() );
//Copy the scheme and separator
if ( scheme.Length() > 0 )
{
uriDes.Copy( scheme );
uriDes.Append( KSchemeSeparator );
}
//Append the prefix and dot char
if ( prefix.Length() > 0 )
{
uriDes.Append( prefix );
uriDes.Append( KSeparatorDot );
}
//Appends user supplied string here
uriDes.Append( aUri );
//Finally appends the domain
if ( tld.Length() > 0 )
{
uriDes.Append( KSeparatorDot );
uriDes.Append( tld );
}
//Constructs the CUri object
TUriParser16 uriParser;
User::LeaveIfError( uriParser.Parse( uriDes ) );
CUri16* uri = CUri16::NewL( uriParser );
CleanupStack::PopAndDestroy( uriBuf );
return uri;
}
void wxURI::Resolve(const wxURI& base, int flags)
{
wxASSERT_MSG(!base.IsReference(),
wxT("wxURI to inherit from must not be a reference!"));
// If we arn't being strict, enable the older (pre-RFC2396)
// loophole that allows this uri to inherit other
// properties from the base uri - even if the scheme
// is defined
if ( !(flags & wxURI_STRICT) &&
HasScheme() && base.HasScheme() &&
m_scheme == base.m_scheme )
{
m_fields -= wxURI_SCHEME;
}
// Do nothing if this is an absolute wxURI
// if defined(R.scheme) then
// T.scheme = R.scheme;
// T.authority = R.authority;
// T.path = remove_dot_segments(R.path);
// T.query = R.query;
if (HasScheme())
{
return;
}
//No scheme - inherit
m_scheme = base.m_scheme;
m_fields |= wxURI_SCHEME;
// All we need to do for relative URIs with an
// authority component is just inherit the scheme
// if defined(R.authority) then
// T.authority = R.authority;
// T.path = remove_dot_segments(R.path);
// T.query = R.query;
if (HasServer())
{
return;
}
//No authority - inherit
if (base.HasUserInfo())
{
m_userinfo = base.m_userinfo;
m_fields |= wxURI_USERINFO;
}
m_server = base.m_server;
m_hostType = base.m_hostType;
m_fields |= wxURI_SERVER;
if (base.HasPort())
{
m_port = base.m_port;
m_fields |= wxURI_PORT;
}
// Simple path inheritance from base
if (!HasPath())
{
// T.path = Base.path;
m_path = base.m_path;
m_fields |= wxURI_PATH;
// if defined(R.query) then
// T.query = R.query;
// else
// T.query = Base.query;
// endif;
if (!HasQuery())
{
m_query = base.m_query;
m_fields |= wxURI_QUERY;
}
}
else
{
// if (R.path starts-with "/") then
// T.path = remove_dot_segments(R.path);
// else
// T.path = merge(Base.path, R.path);
// T.path = remove_dot_segments(T.path);
// endif;
// T.query = R.query;
if (m_path.empty() || m_path[0u] != wxT('/'))
{
//Merge paths
const wxChar* op = m_path.c_str();
const wxChar* bp = base.m_path.c_str() + base.m_path.Length();
//not a ending directory? move up
if (base.m_path[0] && *(bp-1) != wxT('/'))
UpTree(base.m_path, bp);
//normalize directories
while(*op == wxT('.') && *(op+1) == wxT('.') &&
(*(op+2) == '\0' || *(op+2) == wxT('/')) )
{
UpTree(base.m_path, bp);
if (*(op+2) == '\0')
op += 2;
else
op += 3;
}
m_path = base.m_path.substr(0, bp - base.m_path.c_str()) +
m_path.substr((op - m_path.c_str()), m_path.Length());
}
}
//T.fragment = R.fragment;
}