Merge "Alarm Conditional AppLaunch Refactoring" into tizen_2.2
[platform/framework/native/appfw.git] / inc / FBaseUtilUri.h
1 //
2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
3 //
4 // Licensed under the Apache License, Version 2.0 (the License);
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 /**
18  * @file                FBaseUtilUri.h
19  * @brief               This is the header file for the %Uri class.
20  *
21  * This header file contains the declarations of the %Uri class.
22  */
23 #ifndef _FBASE_UTIL_URI_H_
24 #define _FBASE_UTIL_URI_H_
25
26 #include <FBaseObject.h>
27 #include <FBaseString.h>
28 #include <FBaseBuffer.h>
29
30
31 namespace Tizen { namespace Base { namespace Utility
32 {
33
34 /**
35  * @class       Uri
36  * @brief       This class provides useful methods for URI.
37  *
38  * @since 2.0
39  *
40  * The %Uri class represents a Uniform Resource Identifier (URI) as defined by RFC2396 and provides accessors
41  * which access the URI component.
42  * It also provides methods for creating, accessing, normalizing, resolving, and relativizing %Uri instances.
43  *
44  * For more information on the class features, see <a href="../org.tizen.native.appprogramming/html/guide/base/uri.htm">URI</a>.
45  *
46  * The following example demonstrates how to use the %Uri class.
47  *
48  * @code
49  *
50  * #include <FBase.h>
51  *
52  * using namespace Tizen::Base;
53  * using namespace Tizen::Base::Utility;
54  *
55  * void
56  * MyClass::UriSample(void)
57  * {
58  *              String base(L"https://developer.tizen.org");
59  *              String against(L"/downloads/tizen-sdk");
60  *              String resolveString(L"https://developer.tizen.org/downloads/tizen-sdk");
61  *
62  *              Uri baseUri;
63  *              baseUri.SetUri(base);
64  *
65  *              Uri againstUri;
66  *              againstUri.SetUri(against);
67  *
68  *              Uri resultUri;
69  *              baseUri.Resolve(againstUri, resultUri);
70  *
71  *              String resultString = resultUri.ToString();
72  *              if (resultString.Equals(resolveString))
73  *              {
74  *                      // ...
75  *              }
76  * }
77  * @endcode
78  */
79 class _OSP_EXPORT_ Uri
80         : public Tizen::Base::Object
81 {
82 public:
83         /**
84          * This is the default constructor for this class.
85          *
86          * @since 2.0
87          */
88         Uri(void);
89
90         /**
91          * Copying of objects using this copy constructor is allowed.
92          *
93          * @since 2.0
94          *
95          *  @param[in]  uri             An instance of %Uri to copy
96          */
97         Uri(const Uri& uri);
98
99         /**
100          * This destructor overrides Tizen::Base::Object::~Object().
101          *
102          * @since 2.0
103          */
104         virtual ~Uri(void);
105
106         /**
107          * Sets the current %Uri instance to the value of the specified instance of %Uri.
108          *
109          * @since 2.0
110          *
111          * @param[in]   uri             An instance of %Uri
112          */
113         void SetUri(const Uri& uri);
114
115         /**
116          * Sets the current %Uri instance by parsing a given string.
117          *
118          * @since 2.0
119          *
120          * @return              An error code
121          * @param[in]   str             A string to parse into a URI
122          * @exception   E_SUCCESS                               The method is successful.
123          * @exception   E_INVALID_ARG                   The specified @c str is an empty string.
124          * @exception   E_INVALID_FORMAT                The specified @c str violates the URI syntax (RFC 2396).
125          */
126         result SetUri(const Tizen::Base::String& str);
127
128         /**
129          * Sets an absolute %Uri instance with given components.
130          *
131          * @since 2.0
132          *
133          * @return              An error code
134          * @param[in]   scheme                  The scheme
135          * @param[in]   ssp                             The scheme-specific-part
136          * @param[in]   fragment                The fragment
137          * @exception   E_SUCCESS                               The method is successful.
138          * @exception   E_INVALID_FORMAT                A component violates the URI syntax(RFC 2396).
139          */
140         result SetUri(const Tizen::Base::String& scheme, const Tizen::Base::String& ssp, const Tizen::Base::String& fragment);
141
142         /**
143          * Sets an absolute and hierarchical %Uri instance with the given components.
144          *
145          * @since 2.0
146          *
147          * @return              An error code
148          * @param[in]   scheme                  The scheme
149          * @param[in]   userInfo                The user name and authorization
150          * @param[in]   host                    The host name
151          * @param[in]   port                    The port number
152          * @param[in]   path                    The path
153          * @param[in]   query                   The query
154          * @param[in]   fragment                The fragment
155          * @exception   E_SUCCESS                               The method is successful.
156          * @exception   E_INVALID_FORMAT                A component violates the URI syntax(RFC 2396).
157          */
158         result SetUri(const Tizen::Base::String& scheme, const Tizen::Base::String& userInfo, const Tizen::Base::String& host, int port, const Tizen::Base::String& path, const Tizen::Base::String& query, const Tizen::Base::String& fragment);
159
160         /**
161          * Sets an absolute and hierarchical %Uri instance with the given components.
162          *
163          * @since 2.0
164          *
165          * @return              An error code
166          * @param[in]   scheme                  The scheme
167          * @param[in]   host                    The host name
168          * @param[in]   path                    The path
169          * @param[in]   fragment                The fragment
170          * @exception   E_SUCCESS                               The method is successful.
171          * @exception   E_INVALID_FORMAT                A component violates the URI syntax(RFC 2396).
172          * @remarks     The authority and query component are left empty, and the port is set to @c -1.
173          */
174         result SetUri(const Tizen::Base::String& scheme, const Tizen::Base::String& host, const Tizen::Base::String& path, const Tizen::Base::String& fragment);
175
176         /**
177          * Sets an absolute and hierarchical %Uri instance with the given components.
178          *
179          * @since 2.0
180          *
181          * @return              An error code
182          * @param[in]   scheme                  The scheme
183          * @param[in]   authority               The authority
184          * @param[in]   path                    The path
185          * @param[in]   query                   The query
186          * @param[in]   fragment                The fragment
187          * @exception   E_SUCCESS                               The method is successful.
188          * @exception   E_INVALID_FORMAT                A component violates the URI syntax(RFC 2396).
189          */
190         result SetUri(const Tizen::Base::String& scheme, const Tizen::Base::String& authority, const Tizen::Base::String& path, const Tizen::Base::String& query, const Tizen::Base::String& fragment);
191
192         /**
193          * Copying of objects using this copy assignment operator is allowed.
194          *
195          * @since 2.0
196          *
197          * @return              A reference to the calling instance
198          * @param[in]   rhs             An instance of %Uri
199          */
200         Uri& operator =(const Uri& rhs);
201
202         /**
203          * Gets the value of the authority component.
204          *
205          * @since 2.0
206          *
207          * @return              The value of the authority component, @n
208          *                              else an empty string if the authority component is undefined
209          * @remarks             The string returned by this method is equal to the string returned by GetEncodedAuthority(),
210          *                              except that all sequences of the escaped octets are decoded.
211          */
212         Tizen::Base::String GetAuthority(void) const;
213
214         /**
215          * Gets the value of the fragment component.
216          *
217          * @since 2.0
218          *
219          * @return              The value of the fragment component, @n
220          *                              else an empty string if the fragment component is undefined
221          * @remarks             The string returned by this method is equal to the string returned by GetEncodedFragment(),
222          *                              except that all sequences of the escaped octets are decoded.
223          */
224         Tizen::Base::String GetFragment(void) const;
225
226         /**
227          * Gets the value of the host component.
228          *
229          * @since 2.0
230          *
231          * @return              The value of the host component, @n
232          *                              else an empty string if the host component is undefined
233          */
234         Tizen::Base::String GetHost(void) const;
235
236         /**
237          * Gets the value of the path component.
238          *
239          * @since 2.0
240          *
241          * @return              The value of the path component, @n
242          *                              else an empty string if the path component is undefined
243          * @remarks             The string returned by this method is equal to the string returned by GetEncodedPath(),
244          *                              except that all sequences of the escaped octets are decoded.
245          */
246         Tizen::Base::String GetPath(void) const;
247
248
249         /**
250          * Gets the value of the port component.
251          *
252          * @since 2.0
253          *
254          * @return              The value of the port component, @n
255          *                              else @c -1 if the port component is undefined
256          */
257         int GetPort(void) const;
258
259
260         /**
261          * Gets the value of the query component.
262          *
263          * @since 2.0
264          *
265          * @return              The value of the query component, @n
266          *                              else an empty string if the query component is undefined
267          * @remarks             The string returned by this method is equal to the string returned by GetEncodedQuery(),
268          *                              except that all sequences of the escaped octets are decoded.
269          */
270         Tizen::Base::String GetQuery(void) const;
271
272
273         /**
274          * Gets the value of the scheme component.
275          *
276          * @since 2.0
277          *
278          * @return              The value of the query scheme, @n
279          *                              else an empty string if the query scheme is undefined
280          */
281         Tizen::Base::String GetScheme(void) const;
282
283
284         /**
285          * Gets the value of the scheme-specific-part component.
286          *
287          * @since 2.0
288          *
289          * @return              The value of the scheme-specific-part component, @n
290          *                              else an empty string if the scheme-specific-part component is undefined
291          * @remarks             The string returned by this method is equal to the string returned by GetEncodedSchemeSpecificPart(),
292          *                              except that all sequences of the escaped octets are decoded.
293          */
294         Tizen::Base::String GetSchemeSpecificPart(void) const;
295
296
297         /**
298          * Gets the value of the user-info component.
299          *
300          * @since 2.0
301          *
302          * @return              The value of the user-info component, @n
303          *                              else an empty string if the user-info component is undefined
304          * @remarks             The string returned by this method is equal to the string returned by GetEncodedUserInfo(),
305          *                              except that all sequences of the escaped octets are decoded.
306          */
307         Tizen::Base::String GetUserInfo(void) const;
308
309
310         /**
311          * Gets the encoded value of the authority component. @n
312          * The non-US-ASCII characters in the authority component are encoded to escaped octets.
313          *
314          * @since 2.0
315          *
316          * @return              The encoded value of the authority component, @n
317          *                              else an empty string if the authority component is undefined
318          */
319         Tizen::Base::String GetEncodedAuthority(void) const;
320
321
322         /**
323          * Gets the encoded value of the fragment component. @n
324          * The non-US-ASCII characters in the fragment component are encoded to escaped octets.
325          *
326          * @since 2.0
327          *
328          * @return              The encoded value of the fragment component, @n
329          *                              else an empty string if the fragment component is undefined
330          */
331         Tizen::Base::String GetEncodedFragment(void) const;
332
333
334         /**
335          * Gets the encoded value of the path component. @n
336          * The non-US-ASCII characters in the path component are encoded to escaped octets.
337          *
338          * @since 2.0
339          *
340          * @return              The encoded value of the path component, @n
341          *                              else an empty string if the path component is undefined
342          */
343         Tizen::Base::String GetEncodedPath(void) const;
344
345
346         /**
347          * Gets the encoded value of the query component. @n
348          * The non-US-ASCII characters in the query component are encoded to escaped octets.
349          *
350          * @since 2.0
351          *
352          * @return              The encoded value of the query component, @n
353          *                              else an empty string if the query component is undefined
354          */
355         Tizen::Base::String GetEncodedQuery(void) const;
356
357
358         /**
359          * Gets the encoded value of the scheme-specific-part component. @n
360          * The non-US-ASCII characters in the scheme-specific-part component are encoded to escaped octets.
361          *
362          * @since 2.0
363          *
364          * @return              The encoded value of the scheme-specific-part component, @n
365          *                              else an empty string if the scheme-specific-part component is undefined
366          */
367         Tizen::Base::String GetEncodedSchemeSpecificPart(void) const;
368
369         /**
370         * Gets the encoded value of a user-info component,
371         * or returns an empty string if the user-info component is undefined. @n
372         * The non-US-ASCII characters in the user-info component are encoded to escaped octets.
373         *
374         * @since 2.0
375         *
376         * @return               The encoded value of user-info, @n
377         *                               else an empty string if the user-info component is undefined
378         */
379         Tizen::Base::String GetEncodedUserInfo(void) const;
380
381
382         /**
383          * Checks whether the current %Uri instance is an absolute URI.
384          *
385          * @since 2.0
386          *
387          * @return              @c true if the current %Uri instance is an absolute URI, @n
388          *                              else @c false
389          */
390         bool IsAbsolute(void) const;
391
392
393         /**
394          * Checks whether the calling %Uri instance is an opaque URI.
395          *
396          * @since 2.0
397          *
398          * @return              @c true if the current %Uri instance is an opaque URI, @n
399          *                              else @c false
400          */
401         bool IsOpaque(void) const;
402
403
404         /**
405          * Gets the encoded US-ASCII string.
406          *
407          * @since 2.0
408          *
409          * @return              The encoded US-ASCII string
410          * @remarks             If this URI does not contain any non US_ASCII characters,
411          *                              then the string returned by this method is equal to the string returned by ToString().
412          *
413          * The following example demonstrates how to use the %GetEncodedString() method.
414          *
415          * @code
416          * String str(L"https://www.tizen.org/?currency==\u20ac");
417          *
418          *       Uri uri;
419          *       uri.SetUri(str);
420          *
421          *       String encode = uri.GetEncodedString();        // encode == L"https://www.tizen.org/?currency==%E2%82%AC"
422          *
423          * @endcode
424          */
425         Tizen::Base::String GetEncodedString(void) const;
426
427         /**
428          * Compares the calling URI instance to the specified %Uri instance. @n
429          * When comparing corresponding components of two URIs, if one component in the current instance is undefined
430          * but the other is defined, then the current instance is considered to be less than the given object.
431          *
432          * @since 2.0
433          *
434          * @return              The result of the comparison
435          * @code
436          * < 0  if the current instance is less than the given object
437          * = 0  if the current instance is equal to the given object
438          * > 0  if the current instance is greater than the given object
439          * @endcode
440          * @param[in]   uri                     An instance of %Uri
441          * @remarks
442          *
443          * Ordering of URIs
444          * 1. Scheme
445          *    Two URIs are ordered according to the ordering of schemes, without regard to case.
446          * 2. Hierarchical URI vs. Opaque URI
447          *    A hierarchical URI is less than an opaque URI if they have an identical scheme.
448          * 3. Scheme-specific-part
449          *    If two opaque URIs have an identical scheme, they are ordered according to
450          *    the scheme-specific-part, without regard to %case.
451          * 4. Fragment
452          *    If two opaque URIs have identical schemes and scheme-specific-parts, they are ordered according
453          *    to the ordering of fragments, without regard to case.
454          * 5. Authority
455          *    If two hierarchical URIs have identical schemes, they are ordered according to the authority,
456          *    without regard to the case.
457          *       5-1. Server-based authority
458          *             If two URIs are server-based, they are ordered according to their user-information,
459          *             without regard to case.
460          *             If the hosts are identical, then the URIs are ordered according to the ordering of ports.
461          * 6. Path
462          *    If two hierarchical URIs have identical schemas and authority components, they are ordered according to the
463          *    ordering of paths, without regard to the case.
464          *    If their paths are identical, their queries are compared. And if the queries are the same, then their fragments
465          *    are compared.
466          *
467          */
468         int CompareTo(const Uri& uri) const;
469
470
471         /**
472          *      Compares the specified instance to the current instance.
473          *
474          *  @since 2.0
475          *
476          *      @return         @c true if the two instances are equal, @n
477          *                              else @c false
478          *      @param[in]      obj     The object to compare with the current instance
479          *      @remarks        Two equal instances must return the same hash value. The default
480          *                              implementation of this method returns @c true if two instances
481          *                              have the same address. @n
482          *                              The method can be overridden to support value equality. Furthermore, the Equals()
483          *                              method must return the same results as the equality operator.
484          */
485         virtual bool Equals(const Tizen::Base::Object& obj) const;
486
487
488         /**
489          *      Gets the hash value of the current instance.
490          *
491          *  @since 2.0
492          *
493          *      @return         The hash value of the current instance
494          *      @remarks        Two equal instances must return the same hash value. For better performance,
495          *                              the used hash function must generate a random distribution for all inputs.
496          */
497         virtual int GetHashCode(void) const;
498
499
500         /**
501          * Normalizes the current URI.
502          *
503          * @since 2.0
504          *
505          * @return              The normalized URI, @n
506          *                              else the current URI in case any error occurs
507          * @remarks     Normalization is the process of removing unnecessary "." and ".." segments from the path component of the
508          *                      hierarchical URI. All "." segments are removed and If a ".." segment is preceded by a non-".." segment,
509          *                      both of these segments are removed. If a URI is opaque, the normalization has no effect.
510          *
511          * The following example demonstrates how to use the %Normalize() method.
512          *
513          * @code
514          *       Uri uri1;
515          *       uri1.SetUri(L"http://www.example.com/a/b/../c/./d.html");
516          *
517          *       Uri uriNormalized = uri1.Normalize();
518          *       String uriStr = uriNormalized.ToString();              // uriStr == L"http://www.example.com/a/c/d.html"
519          *
520          * @endcode
521          */
522         Uri Normalize(void);
523
524
525         /**
526          * Parses the server-based authority component, if defined.
527          *
528          * @since 2.0
529          *
530          * @return              An error code
531          * @param[out]  uri                                     The parsed URI
532          * @exception   E_SUCCESS                       The method is successful.
533          * @exception   E_INVALID_FORMAT        The authority component is defined but cannot be parsed as a server-based authority.
534          * @remarks             This method is provided because the generic URI syntax cannot always distinguish a malformed server-based authority from a legitimate registry-based authority.
535          *                              For example, the authority component in the URI string "//foo:bar/" is not a legal
536          *                              server-based authority but it is legal as a registry-based authority.
537          */
538         result ParseAuthority(Uri& uri);
539
540
541         /**
542          * Relativizes the specified %Uri instance against the calling %Uri instance.
543          *
544          * @since 2.0
545          *
546          * @return              An error code
547          * @param[in]   uri                                     The %Uri to relativize against the calling %Uri
548          * @param[out]  resultUri                       The relativized URI
549          * @exception   E_SUCCESS                       The method is successful.
550          * @exception   E_OUT_OF_MEMORY         The memory is insufficient.
551          * @remarks             Relativization is the opposite of Resolution. It is used
552          *                              to divide a URI into the base URI and the relative URI.
553          */
554         result Relativize(const Uri& uri, Uri& resultUri);
555
556
557         /**
558          * Resolves the specified %Uri instance against the calling %Uri instance.
559          *
560          * @since 2.0
561          *
562          * @return              An error code
563          * @param[in]   uri                                     The URI to resolve against this URI
564          * @param[out]  resultUri                       The resolved URI
565          * @exception   E_SUCCESS                       The method is successful.
566          * @exception   E_OUT_OF_MEMORY         The memory is insufficient.
567          * @remarks             Resolution is the process of resolving a URI against another, base URI. For hierarchical URI,
568          *                              the path of the original is resolved against the path of the base URI and then normalized. @
569          *                              For example, to resolve the URI "/downloads/tizen-sdk" against the base URI "https://developer.tizen.org",
570          *                              the resultant URI is "https://developer.tizen.org/downloads/tizen-sdk".
571          */
572         result Resolve(const Uri& uri, Uri& resultUri);
573
574
575         /**
576          * Sets the authority component to the specified String instance.
577          *
578          * @since 2.0
579          *
580          * @return              An error code
581          * @param[in]   authority                       The authority
582          * @exception   E_SUCCESS                       The method is successful.
583          * @exception   E_INVALID_FORMAT        The specified string is invalid.
584          */
585         result SetAuthority(const Tizen::Base::String& authority);
586
587
588         /**
589          * Sets the fragment component to the specified String instance.
590          *
591          * @since 2.0
592          *
593          * @return              An error code
594          * @param[in]   fragment                        The new fragment
595          * @exception   E_SUCCESS                       The method is successful.
596          * @exception   E_INVALID_FORMAT        The specified string is invalid.
597          */
598         result SetFragment(const Tizen::Base::String& fragment);
599
600
601         /**
602          * Sets the host component to the specified String instance.
603          *
604          * @since 2.0
605          *
606          * @return              An error code
607          * @param[in]   host                            The new host
608          * @exception   E_SUCCESS                       The method is successful.
609          * @exception   E_INVALID_FORMAT        The specified string is invalid.
610          */
611         result SetHost(const Tizen::Base::String& host);
612
613
614         /**
615          * Sets the path component to the specified String instance.
616          *
617          * @since 2.0
618          *
619          * @return              An error code
620          * @param[in]   path                            The new path component
621          * @exception   E_SUCCESS                       The method is successful.
622          * @exception   E_INVALID_FORMAT        The specified string is invalid.
623          */
624         result SetPath(const Tizen::Base::String& path);
625
626
627         /**
628          * Sets the port component to a given integer.
629          *
630          * @since 2.0
631          *
632          * @return              An error code
633          * @param[in]   port                            The new port component
634          * @exception   E_SUCCESS                       The method is successful.
635          * @exception   E_INVALID_ARG           The specified @c port is negative.
636          */
637         result SetPort(int port);
638
639
640         /**
641          * Sets the query component to the specified String instance.
642          *
643          * @since 2.0
644          *
645          * @return              An error code
646          * @param[in]   query                           The new query string
647          * @exception   E_SUCCESS                       The method is successful.
648          * @exception   E_INVALID_FORMAT        The specified string is invalid.
649          */
650         result SetQuery(const Tizen::Base::String& query);
651
652
653         /**
654          * Sets the scheme component to the specified String instance.
655          *
656          * @since 2.0
657          *
658          * @return              An error code
659          * @param[in]   scheme                          The new scheme
660          * @exception   E_SUCCESS                       The method is successful.
661          * @exception   E_INVALID_FORMAT        The specified string is invalid.
662          */
663         result SetScheme(const Tizen::Base::String& scheme);
664
665
666         /**
667          * Sets the scheme-specific-part component to the specified String instance.
668          *
669          * @since 2.0
670          *
671          * @return              An error code
672          * @param[in]   ssp                                     The new scheme-specific-part component
673          * @exception   E_SUCCESS                       The method is successful.
674          * @exception   E_INVALID_FORMAT        The specified string is invalid.
675          */
676         result SetSchemeSpecificPart(const Tizen::Base::String& ssp);
677
678
679         /**
680          * Sets the user-info component to the specified String instance.
681          *
682          * @since 2.0
683          *
684          * @return              An error code
685          * @param[in]   userInfo                        The new user-info string
686          * @exception   E_SUCCESS                       The method is successful.
687          * @exception   E_INVALID_FORMAT        The specified string is invalid.
688          */
689         result SetUserInfo(const Tizen::Base::String& userInfo);
690
691
692         /**
693          * Gets the content of the calling %Uri instance as a string containing escaped octets.
694          *
695          * @since 2.0
696          *
697          * @return              The content of this URI as a string containing escaped octets
698          */
699         Tizen::Base::String ToString(void) const;
700
701 private:
702         //
703         // Constructs an Uri instance with the given components.
704         // scheme, ssp(opaquePart), authority, user-info, host, port, path, query, fragment
705         //
706         result SetUri(const Tizen::Base::String& scheme, const Tizen::Base::String& opaque,
707                 const Tizen::Base::String& authority, const Tizen::Base::String& userInfo,
708                 const Tizen::Base::String& host, int port, const Tizen::Base::String& path,
709                 const Tizen::Base::String& query, const Tizen::Base::String& fragment);
710
711         //
712         // Appends a given scheme-specific-part to a String.
713         //
714         result AppendSchemeSpecificPart(Tizen::Base::String& strbuf, const Tizen::Base::String& opaque,
715                 const Tizen::Base::String& authority, const Tizen::Base::String& userInfo,
716                 const Tizen::Base::String& host, int port, const Tizen::Base::String& path,
717                 const Tizen::Base::String& query) const;
718
719         //
720         // Appends a given fragment to a String.
721         //
722         result AppendFragment(Tizen::Base::String& strbuf, const Tizen::Base::String& fragment) const;
723
724         //
725         // Appends a given authority component to a String.
726         //
727         result AppendAuthority(Tizen::Base::String& strbuf, const Tizen::Base::String& authority,
728                 const Tizen::Base::String& userInfo, const Tizen::Base::String& host, int port) const;
729
730         //
731         // Parses a given URI string.
732         //
733         result ParseUri(const Tizen::Base::String& str);
734
735         //
736         // Copies a given URI.
737         //
738         result CopyUri(const Uri& uri);
739
740         //
741         // Encodes all components - authority, fragment, path, query, and ssp.
742         //
743         void EncodeAllComponent(void);
744
745         //
746         // Parses a hierarchical URI string.
747         // @return              The start index of the fragment. If the operation fails, @c -1 is returned.
748         // @param[in]   startSsp                        The start index of scheme-specific-part
749         // @param[in] lengthOfUri               The length of the URI string
750         // @param[out] authority        A parsed authority component
751         // @param[out] path                     A parsed path component
752         // @param[out] query                    A parsed query component
753         //
754         result ParseHierarchicalUri(const Tizen::Base::String& str, int startSsp, Tizen::Base::String& authority,
755                 Tizen::Base::String& path, Tizen::Base::String& query, int& index);
756
757
758         //
759         // Parses a server_based authority component.
760         // server_based authority: [user-info@]<host>[:port]
761         //
762         result ParseAuthority(const Tizen::Base::String& str, int curIndex, Tizen::Base::String& newAuth,
763                 Tizen::Base::String& userInfo, Tizen::Base::String& host, int& port);
764
765         void SetAndEncodeAuthority(const Tizen::Base::String& authority,
766                 const Tizen::Base::String& path, const Tizen::Base::String& query);
767
768         //
769         // Parses a server_based authority component.
770         // Assigns user-info, host and port to their member variable.
771         //
772         result ParseServerAuthority(const Tizen::Base::String& str, Tizen::Base::String& user, Tizen::Base::String& host, int& port);
773
774         //
775         // Parses an IPv4 address.
776         //
777         result ParseIpv4(const Tizen::Base::String& str, int index, int& count);
778
779         //
780         // Parses an IPv6 address.
781         // It will be implemented.
782         //
783         result ParseIpv6(const Tizen::Base::String& ip6, Tizen::Base::String& outIpv6);
784
785         //
786         // Parses a host name and returns a host name as an out-param.
787         //
788         result ParseHostName(const Tizen::Base::String& str, int index, Tizen::Base::String& host);
789
790         //
791         // These methods verify components.
792         // If a given component is valid, return @c true, else, @c false.
793         // @param[in]   str             A component
794         //
795         bool VerifyScheme(const Tizen::Base::String& str) const;
796         bool VerifyAuthority(const Tizen::Base::String& str) const;
797         bool VerifyHost(const Tizen::Base::String& str) const;
798         bool VerifyPath(const Tizen::Base::String& str) const;
799         bool VerifyUserInfo(const Tizen::Base::String& str) const;
800         bool VerifyUriChar(const Tizen::Base::String& str) const;
801
802         //
803         // Checks that a given string only consists of server_based characters.
804         // @return              @c true if a string consists of only server_based characters, @n
805         //                      else @c false
806         //
807         bool VerifyServerAuthority(const Tizen::Base::String& str) const;
808
809         //
810         //  Checks that a given string only consists of registry_based characters.
811         // @return              @c true if a string consists of only registry_based characters, @n
812         //                              else @c false
813         //
814         bool VerifyRegistryAuthority(const Tizen::Base::String& str) const;
815
816         //
817         // Checks whether a given char is a user-info character or not.
818         // user-info char: alphabet, digit, -_.!~*'(), ;:&=+$,
819         //
820         bool IsUserInfo(wchar_t mch) const;
821
822         //
823         // Returns true if a given wchar_t is a mark character.
824         // mark char : -_.!~*'()
825         //
826         bool IsMark(wchar_t mch) const;
827
828         //
829         // Returns true if two given wchar_ts are hexadecimals.
830         //
831         bool IsEscapedChar(wchar_t ch1, wchar_t ch2) const;
832
833         //
834         // Returns true if a given string is already encoded.
835         //
836         bool IsEncoded(const Tizen::Base::String& str) const;
837
838         //
839         // Returns true if a given wchar_t is an ISO control character.
840         //
841         bool IsControlChar(wchar_t ch) const;
842
843         //
844         // Compares @c pStr1 with @c pStr2. @n
845         // If @c pStr1 is greater than @c pStr2, returns @c 1.
846         // If two strings are the same, return @c 0.
847         // If @c pStr1 is less than @c pStr2, returns @c -1.
848         //
849         int Compare(const Tizen::Base::String& pStr1, const Tizen::Base::String& pStr2) const;
850
851         //
852         // Adds leading dots.
853         // If the normalized path is relative, and if the first segment could be parsed as a scheme name,
854         // then prepend a '.' segment
855         //
856         void AddLeadingDot(Tizen::Base::WcharBuffer& path, int* segments, int numSegments);
857
858         //
859         // Finds the first character in stopString.
860         // If there is not a character in stopString, the last index is returned.
861         //
862         int Scan(const Tizen::Base::String& str, int start, const Tizen::Base::String& stopString);
863
864         //
865         // Normalizes a given string and removes unnecessary dots.
866         //
867         Tizen::Base::String InternalNormalize(const Tizen::Base::String& path);
868
869         //
870         // Returns the number of segments from a given path.
871         //
872         int GetNumberOfSegments(const Tizen::Base::String& path) const;
873
874         // Join the segments in the given path according to the given segment-index array,
875         // ignoring those segments whose index entries have been set to @c -1, and inserting slashes as needed.
876         // Return the length of the resulting path.
877         //
878         // Preconditions:
879         //   segs[i] == @c -1 implies segment i is to be ignored
880         //   path computed by split, as above, with '\0' having replaced '/'
881         //
882         // Postconditions:
883         //  path[0] .. path[return value] == Resulting path
884         //
885         int Join(Tizen::Base::WcharBuffer& path, int* segments, int segCount);
886
887         //
888         // Removes unnecessary dots and segment pairs consisting of a non-".." segment
889         // followed by a ".." segment
890         //
891         void RemoveDots(const Tizen::Base::WcharBuffer& mb, int* segments, int segCount, int length);
892
893         //
894         // Splits a path component into segments.
895         //
896         void SplitIntoSegments(Tizen::Base::WcharBuffer& mb, int* segments, int segCount);
897
898         //
899         // Implements Uri resolution in RFC2396 5.2
900         //
901         result Resolve(const Uri& baseUri, const Uri& childUri, Uri& resultUri);
902
903         //
904         // Resolves the path of the base and child URI.
905         //
906         Tizen::Base::String ResolvePath(const Tizen::Base::String& path, const Tizen::Base::String& resolve, bool isAbsolute);
907
908         bool EqualsComponent(const Tizen::Base::String& comp1, const Tizen::Base::String& comp2);
909         result Relativize(const Uri& baseUri, const Uri& childUri, Uri& resultUri);
910
911         //
912         // Converts a component represented by UTF8 to a component represented by Unicode.
913         //
914         Tizen::Base::String Decode(const Tizen::Base::String& str);
915
916         //
917         // Converts a component represented by Unicode to a component represented by UTF8.
918         //
919         Tizen::Base::String Encode(const Tizen::Base::String& str) const;
920
921         static result AppendEscape(Tizen::Base::String& strbuf, byte b);
922
923         //
924         // Clears the current instance.
925         //
926         void Clear(void);
927
928         // Component
929         Tizen::Base::String __scheme;
930         Tizen::Base::String __ssp;
931         Tizen::Base::String __authority;
932         Tizen::Base::String __host;
933         Tizen::Base::String __fragment;
934         Tizen::Base::String __path;
935         Tizen::Base::String __userInfo;
936         Tizen::Base::String __query;
937         Tizen::Base::String __ipv4;
938         Tizen::Base::String __ipv6;
939
940         // Encoded Component
941         Tizen::Base::String __encodedAuth;
942         Tizen::Base::String __encodedFragment;
943         Tizen::Base::String __encodedPath;
944         Tizen::Base::String __encodedQuery;
945         Tizen::Base::String __encodedSsp;
946         Tizen::Base::String __encodedUserInfo;
947
948         int __port;
949         bool __hasScheme;
950         int __ipv6ByteCount;
951
952         friend class _UriImpl;
953         class _UriImpl* __pUriImpl;
954
955 }; // Uri
956
957 }}} // Tizen::Base::Utility
958
959 #endif //_FBASE_UTIL_URI_H_