\twocolitem{\helpref{wxRealPoint}{wxrealpoint}}{Representation of a point using floating point numbers}
\twocolitem{\helpref{wxSize}{wxsize}}{Representation of a size}
\twocolitem{\helpref{wxTimeSpan}{wxtimespan}}{A time interval.}
+\twocolitem{\helpref{wxURI}{wxuri}}{Represents a Uniform Resource Identifier}
\twocolitem{\helpref{wxVariant}{wxvariant}}{A class for storing arbitrary types that may change at run-time}
\end{twocollist}
\docparam{uri}{URI (Uniform Resource Identifier) to initialize with}
+\membersection{wxURI::BuildURI}\label{wxuribuilduri}
+
+\constfunc{wxString}{BuildURI}{\void}
+
+Builds the URI from its individual components and adds proper seperators.
+
+If the URI is not a reference or is not resolved,
+the URI that is returned from Get is the same one
+passed to Create.
+
+
+\membersection{wxURI::BuildUnescapedURI}\label{wxuribuildunescapeduri}
+
+\constfunc{wxString}{BuildUnescapedURI}{\void}
+
+Builds the URI from its individual components, adds proper seperators, and
+returns escape sequences to normal characters.
+
+Note that it is preferred to call this over Unescape(BuildURI()) since
+BuildUnescapedURI performs some optimizations over the plain method.
+
+
\membersection{wxURI::Create}\label{wxuricreate}
\func{void}{Create}{\param{const wxChar* }{uri}}
\docparam{uri}{string to initialize from}
-\membersection{wxURI::Get}\label{wxuriget}
-
-\constfunc{wxString}{Get}{\void}
-
-Obtains the full URI.
-
-If the URI is not a reference or is not resolved,
-the URI that is returned from Get is the same one
-passed to Create.
\membersection{wxURI::GetFragment}\label{wxurigetfragment}
mode some compatability layers are enabled to allow loopholes from RFCs prior
to 2396}
+\membersection{wxURI::Unescape}\label{wxuriunescape}
+
+\func{wxString}{Unescape}{\param{const wxString\& }{uri}}
+
+Translates all escape sequences (% hex hex) of \arg{uri} into
+normal characters and returns the result.
+
+This is the preferred over wxURL::ConvertFromURI.
+
+If you want to unescape an entire wxURI, use BuildUnescapedURI instead,
+as it performs some optimizations over this method.
+
+\docparam{uri}{string with escaped characters to convert}
+
+
\helpref{wxURL::SetDefaultProxy}{wxurlsetdefaultproxy}
-%
-% SetProxy
-%
-\membersection{wxURL::ConvertToValidURI}\label{wxurlconverttovaliduri}
-
-\func{static wxString}{ConvertToValidURI}{\param{const wxString\&}{ uri}}
-
-It converts a non-standardized URI to a valid network URI. It encodes non
-standard characters.
-
virtual ~wxURI();
- void Create(const wxString& uri);
+ const wxChar* Create(const wxString& uri);
bool HasScheme() const { return (m_fields & wxURI_SCHEME) == wxURI_SCHEME; }
bool HasUser() const { return (m_fields & wxURI_USER) == wxURI_USER; }
const wxString& GetServer() const { return m_server; }
const wxURIHostType& GetHostType() const { return m_hostType; }
- wxString Get() const;
+ wxString BuildURI() const;
+ wxString BuildUnescapedURI() const;
void Resolve(const wxURI& base, int flags = wxURI_STRICT);
bool IsReference() const;
wxURI& operator = (const wxURI& uri);
wxURI& operator = (const wxString& string);
bool operator == (const wxURI& uri) const;
+
+ static wxString Unescape (const wxString& szEscapedURI);
protected:
wxURI& Assign(const wxURI& uri);
static bool ParseIPv6address(const wxChar*& uri);
static bool ParseIPvFuture(const wxChar*& uri);
-
static void Normalize(wxChar* uri, bool bIgnoreLeads = false);
static void UpTree(const wxChar* uristart, const wxChar*& uri);
- static wxChar Unescape(const wxChar* s);
+ static wxChar TranslateEscape(const wxChar* s);
static void Escape (wxString& s, const wxChar& c);
static bool IsEscape(const wxChar*& uri);
- static int CharToHex(const wxChar& c);
-
+ static wxInt32 CharToHex(const wxChar& c);
static bool IsUnreserved (const wxChar& c);
static bool IsReserved (const wxChar& c);
void SetProxy(const wxString& url_proxy);
#endif // wxUSE_SOCKETS
+#if WXWIN_COMPATIBILITY_2_4
+ //Use wxURI instead - delims is ignored
static wxString ConvertToValidURI(
const wxString& uri,
const wxChar* delims = wxT(";/?:@&=+$,")
);
+
+ //Use wxURI::Unescape instead
static wxString ConvertFromURI(const wxString& uri);
+#endif
protected:
static wxProtoInfo *ms_protocols;
// This creates the URI - all we do here is call the main parsing method
// ---------------------------------------------------------------------------
-void wxURI::Create(const wxString& uri)
+const wxChar* wxURI::Create(const wxString& uri)
{
if (m_fields)
Clear();
- Parse(uri);
+ return Parse(uri);
}
// ---------------------------------------------------------------------------
-// Escape/Unescape/IsEscape
+// Escape/TranslateEscape/IsEscape
//
-// Unescape unencodes a 3 character URL escape sequence
+// TranslateEscape unencodes a 3 character URL escape sequence
// Escape encodes an invalid URI character into a 3 character sequence
// IsEscape determines if the input string contains an escape sequence,
// if it does, then it moves the input string past the escape sequence
// ---------------------------------------------------------------------------
-wxChar wxURI::Unescape(const wxChar* s)
+wxChar wxURI::TranslateEscape(const wxChar* s)
{
wxASSERT_MSG(IsHex(*s) && IsHex(*(s+1)), wxT("Invalid escape!"));
return CharToHex(*s) * 0x10 + CharToHex(*++s);
}
+wxString wxURI::Unescape(const wxString& uri)
+{
+ wxString new_uri;
+
+ for(size_t i = 0; i < uri.length(); ++i)
+ {
+ if (uri[i] == wxT('%'))
+ {
+ new_uri += wxURI::TranslateEscape( &(uri.c_str()[i+1]) );
+ i += 2;
+ }
+ }
+
+ return new_uri;
+}
+
void wxURI::Escape(wxString& s, const wxChar& c)
{
const wxChar* hdig = wxT("0123456789abcdef");
}
// ---------------------------------------------------------------------------
-// Get
+// BuildURI
//
-// Get() actually builds the entire URI into a useable
+// BuildURI() builds the entire URI into a useable
// representation, including proper identification characters such as slashes
// ---------------------------------------------------------------------------
-wxString wxURI::Get() const
+wxString wxURI::BuildURI() const
{
wxString ret;
return ret;
}
+wxString wxURI::BuildUnescapedURI() const
+{
+ wxString ret;
+
+ if (HasScheme())
+ ret = ret + m_scheme + wxT(":");
+
+ if (HasServer())
+ {
+ ret += wxT("//");
+
+ if (HasUser())
+ ret = ret + wxURI::Unescape(m_user) + 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;
+}
+
// ---------------------------------------------------------------------------
// operator = and ==
// ---------------------------------------------------------------------------
// Misc methods - IsXXX and CharToHex
// ---------------------------------------------------------------------------
-int wxURI::CharToHex(const wxChar& c)
+wxInt32 wxURI::CharToHex(const wxChar& c)
{
if ((c >= 'A') && (c <= 'Z')) return c - 'A' + 0x0A;
if ((c >= 'a') && (c <= 'z')) return c - 'a' + 0x0a;
//
// wxURL Compatability
//
-// TODO: Use wxURI instead here...
// ---------------------------------------------------------------------------
#if wxUSE_URL
+#if WXWIN_COMPATIBILITY_2_4
+
#include "wx/url.h"
-wxString wxURL::ConvertToValidURI(const wxString& uri, const wxChar* delims)
+wxString wxURL::ConvertToValidURI(const wxString& uri, const wxChar* WXUNUSED(delims))
{
- wxString out_str;
- wxString hexa_code;
- size_t i;
-
- for (i = 0; i < uri.Len(); i++)
- {
- wxChar c = uri.GetChar(i);
-
- if (c == wxT(' '))
- {
- // GRG, Apr/2000: changed to "%20" instead of '+'
-
- out_str += wxT("%20");
- }
- else
- {
- // GRG, Apr/2000: modified according to the URI definition (RFC 2396)
- //
- // - Alphanumeric characters are never escaped
- // - Unreserved marks are never escaped
- // - Delimiters must be escaped if they appear within a component
- // but not if they are used to separate components. Here we have
- // no clear way to distinguish between these two cases, so they
- // are escaped unless they are passed in the 'delims' parameter
- // (allowed delimiters).
-
- static const wxChar marks[] = wxT("-_.!~*()'");
-
- if ( !wxIsalnum(c) && !wxStrchr(marks, c) && !wxStrchr(delims, c) )
- {
- hexa_code.Printf(wxT("%%%02X"), c);
- out_str += hexa_code;
- }
- else
- {
- out_str += c;
- }
- }
- }
-
- return out_str;
+ return wxURI(uri).BuildURI();
}
wxString wxURL::ConvertFromURI(const wxString& uri)
{
- wxString new_uri;
-
- size_t i = 0;
- while (i < uri.Len())
- {
- int code;
- if (uri[i] == wxT('%'))
- {
- i++;
- if (uri[i] >= wxT('A') && uri[i] <= wxT('F'))
- code = (uri[i] - wxT('A') + 10) * 16;
- else if (uri[i] >= wxT('a') && uri[i] <= wxT('f'))
- code = (uri[i] - wxT('a') + 10) * 16;
- else
- code = (uri[i] - wxT('0')) * 16;
-
- i++;
- if (uri[i] >= wxT('A') && uri[i] <= wxT('F'))
- code += (uri[i] - wxT('A')) + 10;
- else if (uri[i] >= wxT('a') && uri[i] <= wxT('f'))
- code += (uri[i] - wxT('a')) + 10;
- else
- code += (uri[i] - wxT('0'));
-
- i++;
- new_uri += (wxChar)code;
- continue;
- }
- new_uri += uri[i];
- i++;
- }
- return new_uri;
+ return wxURI::Unescape(uri);
}
+#endif //WXWIN_COMPATIBILITY_2_4
+
#endif //wxUSE_URL
//end of uri.cpp
wxURL::wxURL(const wxURI& url) : wxURI(url)
{
- Init(url.Get());
+ Init(url.BuildURI());
ParseURL();
}
wxURL& wxURL::operator = (const wxURI& url)
{
wxURI::operator = (url);
- Init(url.Get());
+ Init(url.BuildURI());
ParseURL();
return *this;
}
#include "wx/cppunit.h"
// Test wxURL & wxURI compat?
-#define TEST_URL 0
+#define TEST_URL 1
// ----------------------------------------------------------------------------
// test class
void Assignment();
void Comparison();
-#if 1
+#if TEST_URL
void URLCompat();
#endif
uri->GetPath() == wxT("/path/"));
URI_TEST("path/john/../../../joe",
- uri->Get() == wxT("../joe"));
+ uri->BuildURI() == wxT("../joe"));
}
#undef URI_TEST
#define URI_TEST_RESOLVE(string, eq, strict) \
uri = new wxURI(wxT(string));\
uri->Resolve(masteruri, strict);\
- CPPUNIT_ASSERT(uri->Get() == wxT(eq));\
+ CPPUNIT_ASSERT(uri->BuildURI() == wxT(eq));\
delete uri;
#define URI_TEST(string, eq) \
uri2 = uri1;
- CPPUNIT_ASSERT(uri1.Get() == uri2.Get());
+ CPPUNIT_ASSERT(uri1.BuildURI() == uri2.BuildURI());
}
void URITestCase::Comparison()
CPPUNIT_ASSERT( uricopy == url );
CPPUNIT_ASSERT( uricopy == urlcopy );
CPPUNIT_ASSERT( uricopy == uri );
+#if WXWIN_COMPATIBILITY_2_4
+ CPPUNIT_ASSERT( wxURL::ConvertFromURI(wxT("%20%41%20")) == wxT(" A ") );
+#endif
}
#endif
projects / wxWidgets.git / commitdiff
