Example #1
0
 public ParserState(string uri)
 {
     remaining = uri;
     elements  = new UriElements();
 }
Example #2
0
        // protected methods
        protected internal virtual string GetComponents(Uri uri, UriComponents components, UriFormat format)
        {
            if ((format < UriFormat.UriEscaped) || (format > UriFormat.SafeUnescaped))
            {
                throw new ArgumentOutOfRangeException("format");
            }

            UriElements elements = UriParseComponents.ParseComponents(uri.OriginalString.Trim());

            string scheme = scheme_name;
            int    dp     = default_port;

            if ((scheme == null) || (scheme == "*"))
            {
                scheme = elements.scheme;
#if SSHARP
                dp = KnownProtocols.GetProtocolDefaultPort(scheme);
#else
                dp = Uri.GetDefaultPort(scheme);
#endif
            }
            else if (String.Compare(scheme, elements.scheme, true) != 0)
            {
                throw new SystemException("URI Parser: scheme mismatch: " + scheme + " vs. " + elements.scheme);
            }

            // it's easier to answer some case directly (as the output isn't identical
            // when mixed with others components, e.g. leading slash, # ...)
            switch (components)
            {
            case UriComponents.Scheme:
                return(scheme);

            case UriComponents.UserInfo:
                return(elements.user);

            case UriComponents.Host:
                return(elements.host);

            case UriComponents.Port:
            {
                string p = elements.port;
                if (p != null && p.Length != 0 && p != dp.ToString())
                {
                    return(p);
                }
                return(String.Empty);
            }

            case UriComponents.Path:
                return(Format(IgnoreFirstCharIf(elements.path, '/'), format));

            case UriComponents.Query:
                return(Format(elements.query, format));

            case UriComponents.Fragment:
                return(Format(elements.fragment, format));

            case UriComponents.StrongPort:
            {
                return(elements.port.Length != 0 ? elements.port : dp.ToString());
            }

            case UriComponents.SerializationInfoString:
                components = UriComponents.AbsoluteUri;
                break;
            }

            // now we deal with multiple flags...

            StringBuilder sb = new StringBuilder();

            if ((components & UriComponents.Scheme) != 0)
            {
                sb.Append(scheme);
#if SSHARP
                sb.Append(scheme == "mailto" || scheme == "news" ? ":" : Uri.SchemeDelimiter);
#else
                sb.Append(Uri.GetSchemeDelimiter(scheme));
#endif
            }

            if ((components & UriComponents.UserInfo) != 0)
            {
                string userinfo = elements.user;
                if (!String.IsNullOrEmpty(userinfo))
                {
                    sb.Append(elements.user);
                    sb.Append('@');
                }
            }

            if ((components & UriComponents.Host) != 0)
            {
                sb.Append(elements.host);
            }

            // for StrongPort always show port - even if -1
            // otherwise only display if ut's not the default port
            if ((components & UriComponents.StrongPort) != 0)
            {
                sb.Append(":");
                if (elements.port.Length != 0)
                {
                    sb.Append(elements.port);
                }
                else
                {
                    sb.Append(dp);
                }
            }

            if ((components & UriComponents.Port) != 0)
            {
                string p = elements.port;
                if (p != null && p.Length != 0 && p != dp.ToString())
                {
                    sb.Append(":");
                    sb.Append(elements.port);
                }
            }

            if ((components & UriComponents.Path) != 0)
            {
                if ((components & UriComponents.PathAndQuery) != 0 &&
                    (elements.path.Length == 0 || !elements.path.StartsWith("/")))
                {
                    sb.Append("/");
                }
                sb.Append(elements.path);
            }

            if ((components & UriComponents.Query) != 0)
            {
                string query = elements.query;
                if (!String.IsNullOrEmpty(query))
                {
                    sb.Append("?");
                    sb.Append(elements.query);
                }
            }

            string result = Format(sb.ToString(), format);
            if ((components & UriComponents.Fragment) != 0)
            {
                string f = elements.fragment;
                if (!String.IsNullOrEmpty(f))
                {
                    result += "#" + Format(f, format);
                }
            }
            return(result);
        }