| // $Id$ |
| // |
| // Copyright 2007-2008 Cisco Systems Inc. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| // use this file except in compliance with the License. You may obtain a copy |
| // of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| // License for the specific language governing permissions and limitations |
| // under the License. |
| |
| using System; |
| using System.Collections.Generic; |
| using System.Text; |
| |
| namespace Etch.Util |
| { |
| /// <summary> |
| /// Models a url of the form scheme://user:password@host:port/uri;parms?terms#fragment |
| /// </summary> |
| public class URL |
| { |
| #region MEMBER VARIABLES |
| |
| private String _scheme; |
| private String _user; |
| private String _password; |
| private String _host; |
| private int _port; |
| private String _uri; |
| private List<String> _params; |
| private Dictionary<String, Object> _terms; |
| private String _fragment; |
| |
| #endregion |
| |
| #region CONSTRUCTORS |
| |
| /// <summary> |
| /// Constructs a url from a string. |
| /// </summary> |
| /// <param name="urlString"></param> |
| public URL( String urlString ) |
| { |
| Parse( urlString ); |
| } |
| |
| /// <summary> |
| /// Constructs a URL from another URL |
| /// </summary> |
| /// <param name="other"></param> |
| public URL( URL other ) |
| { |
| _scheme = other.Scheme; |
| _user = other.User; |
| _password = other.Password; |
| _host = other.Host; |
| _port = other.Port; |
| _uri = other.Uri; |
| _params = CopyParams( other._params ); |
| _terms = CopyTerms( other._terms ); |
| _fragment = other._fragment; |
| } |
| |
| /// <summary> |
| /// Constructs an empty URL |
| /// </summary> |
| public URL() |
| { |
| // nothing to do. |
| } |
| |
| #endregion |
| |
| private void Parse( String s ) |
| { |
| // s is scheme:[//[user[:password]@]host[:port]/]uri[;params][?terms][#fragment] |
| |
| String[] x = StringUtil.LeftSplit( s, ':' ); |
| if ( x == null ) |
| throw new ArgumentNullException( "missing scheme" ); |
| |
| Scheme = Unescape( x[ 0 ] ); |
| s = x[ 1 ]; |
| |
| // s is [//[user[:password]@]host[:port]/]uri[;params][?terms][#fragment] |
| |
| x = StringUtil.LeftSplit( s, '#' ); |
| if ( x!=null ) |
| { |
| Fragment = Unescape( x[ 1 ] ); |
| s = x[ 0 ]; |
| } |
| |
| // s is [//[user[:password]@]host[:port]/]uri[;params][?terms] |
| |
| x = StringUtil.LeftSplit( s, '?' ); |
| if ( x != null ) |
| { |
| ParseTerms( x[ 1 ] ); |
| s = x[ 0 ]; |
| } |
| |
| // s is [//[user[:password]@]host[:port]/]uri[;params] |
| |
| x = StringUtil.LeftSplit( s, ';' ); |
| if ( x != null ) |
| { |
| ParseParams( x[ 1 ] ); |
| s = x[ 0 ]; |
| } |
| |
| // s is [//[user[:password]@]host[:port]/]uri |
| |
| if ( s.StartsWith( "//" ) ) |
| { |
| s = s.Substring( 2 ); |
| // s is [user[:password]@]host[:port]/uri |
| x = StringUtil.LeftSplit( s, '/' ); |
| if ( x != null ) |
| { |
| // s is [user[:password]@]host[:port]/uri |
| ParseHost( x[ 0 ] ); |
| s = x[ 1 ]; |
| } |
| else |
| { |
| // s is [user[:password]@]host[:port] |
| ParseHost( s ); |
| s = ""; |
| } |
| } |
| _uri = Unescape( s ); |
| } |
| |
| private void ParseHost( String s ) |
| { |
| // s is [user[:password]@]host[:port] |
| String[] x = StringUtil.LeftSplit( s, '@' ); |
| if ( x != null ) |
| { |
| ParseUserPassword( x[ 0 ] ); |
| ParseHostPort( x[ 1 ] ); |
| } |
| else |
| { |
| ParseHostPort( s ); |
| } |
| } |
| |
| private void ParseUserPassword( String s ) |
| { |
| // s is user[:password] |
| String[] x = StringUtil.LeftSplit( s, ':' ); |
| if ( x != null ) |
| { |
| _user = Unescape( x[ 0 ] ); |
| _password = Unescape( x[ 1 ] ); |
| } |
| else |
| { |
| _user = Unescape( s ); |
| } |
| } |
| |
| private void ParseHostPort( String s ) |
| { |
| // s is host[:port] |
| String[] x = StringUtil.LeftSplit( s, ':' ); |
| if ( x != null ) |
| { |
| _host = Unescape( x[ 0 ] ); |
| _port = Convert.ToInt32( Unescape( x[ 1 ] ) ); |
| } |
| else |
| { |
| _host = Unescape( s ); |
| } |
| } |
| |
| private void ParseParams( String s ) |
| { |
| // s is param[;param]* |
| if ( s.Length == 0 ) |
| return; |
| |
| EnsureParams(); |
| |
| String[] x; |
| while ( ( x = StringUtil.LeftSplit( s, ';' ) ) != null ) |
| { |
| AddParam( Unescape( x[ 0 ] ) ); |
| s = x[ 1 ]; |
| } |
| AddParam( Unescape( s ) ); |
| } |
| |
| private void ParseTerms( String s ) |
| { |
| // s is term[&term]* |
| |
| if ( s.Length == 0 ) |
| return; |
| |
| String[] x; |
| while ( ( x = StringUtil.LeftSplit( s, '&' ) ) != null ) |
| { |
| ParseTerm( x[ 0 ] ); |
| s = x[ 1 ]; |
| } |
| ParseTerm( s ); |
| } |
| |
| private void ParseTerm( String s ) |
| { |
| // s is name[=value] |
| |
| if ( s.Length == 0 ) |
| return; |
| |
| EnsureTerms(); |
| |
| String[] x = StringUtil.LeftSplit( s, '=' ); |
| if ( x != null ) |
| AddTerm( Unescape( x[ 0 ] ), Unescape( x[ 1 ] ) ); |
| else |
| AddTerm( Unescape( s ), "" ); |
| } |
| |
| #region SCHEME |
| |
| /// <summary> |
| /// Gets and Sets the scheme. |
| /// Return the scheme which may be null but not blank. |
| /// </summary> |
| public String Scheme |
| { |
| get |
| { |
| return _scheme; |
| } |
| set |
| { |
| CheckNotBlank( "scheme", value ); |
| _scheme = value; |
| } |
| } |
| |
| /// <summary> |
| /// Tests the scheme for a match. The schemes are case-insensitive. |
| /// </summary> |
| /// <param name="testScheme">a scheme to test against.</param> |
| /// <returns>true if the schemes match, false otherwise.</returns> |
| public bool IsScheme( String testScheme ) |
| { |
| return testScheme.Equals( _scheme, StringComparison.CurrentCultureIgnoreCase ); |
| } |
| |
| #endregion |
| |
| #region USER |
| |
| public String User |
| { |
| get |
| { |
| return _user; |
| } |
| set |
| { |
| CheckNotBlank( "user", value ); |
| _user = value; |
| } |
| } |
| |
| #endregion |
| |
| #region PASSWORD |
| |
| public String Password |
| { |
| get |
| { |
| return _password; |
| } |
| set |
| { |
| CheckNotBlank( "password", value ); |
| _password = value; |
| } |
| } |
| |
| #endregion |
| |
| #region HOST |
| |
| public String Host |
| { |
| get |
| { |
| return _host; |
| } |
| set |
| { |
| CheckNotBlank( "host", value ); |
| _host = value; |
| } |
| } |
| |
| #endregion |
| |
| #region PORT |
| |
| public int Port |
| { |
| get |
| { |
| return _port; |
| } |
| set |
| { |
| if ( value < 0 || value > 65535 ) |
| throw new ArgumentOutOfRangeException( "port < 0 || port > 65535 " ); |
| _port = value; |
| } |
| } |
| |
| #endregion |
| |
| #region URI |
| |
| public String Uri |
| { |
| get |
| { |
| return _uri; |
| } |
| set |
| { |
| _uri = value; |
| } |
| } |
| |
| #endregion |
| |
| #region PARAMS |
| |
| /// <summary> |
| /// |
| /// </summary> |
| /// <returns>true if there is atleast one param</returns> |
| public bool HasParams() |
| { |
| return ( ( _params!=null ) && ( _params.Count > 0 ) ); |
| } |
| |
| /// <summary> |
| /// Fetches the first param found which starts with the given prefix. The |
| /// search order is not specified, and the params are not maintained in any |
| /// specific order. |
| /// </summary> |
| /// <param name="prefix">the prefix of the param to fetch (e.g., "transport=").</param> |
| /// <returns>the param which starts with the specified prefix.</returns> |
| /// |
| public String GetParam( String prefix ) |
| { |
| if ( _params == null ) |
| return null; |
| |
| foreach ( String s in _params ) |
| { |
| if ( s.StartsWith( prefix ) ) |
| return s; |
| } |
| |
| return null; |
| } |
| |
| /// <summary> |
| /// |
| /// </summary> |
| /// <returns>an iterator over all the params. The params are strings, generally |
| /// of the form "transport=tcp". But they can be anything you like, really. |
| /// The iterator might be empty.</returns> |
| /// |
| public IEnumerator<String> GetParams() |
| { |
| if ( _params == null ) |
| return new EmptyIterator<String>(); |
| |
| return _params.GetEnumerator(); |
| } |
| |
| /// <summary> |
| /// Adds a param to the set of params for this url. Only the set of unique |
| /// params is maintained. Duplicate param values are suppressed. |
| /// </summary> |
| /// <param name="param">a param (e.g., "transport=tcp" or "01831864574898475").</param> |
| /// |
| public void AddParam( String param ) |
| { |
| EnsureParams(); |
| _params.Add( param ); |
| } |
| |
| /// <summary> |
| /// Removes the first param found which starts with the given prefix. The |
| /// search order is not specified, and the params are not maintained in any |
| /// specific order. |
| /// |
| /// </summary> |
| /// <param name="prefix">the prefix of the param to remove (e.g., "transport=").</param> |
| /// <returns>the param removed.</returns> |
| /// |
| public String RemoveParam( String prefix ) |
| { |
| if ( _params == null ) |
| return null; |
| |
| foreach ( String s in _params ) |
| { |
| if ( s.StartsWith( prefix ) ) |
| { |
| _params.Remove( s ); |
| return s; |
| } |
| } |
| return null; |
| } |
| |
| /// <summary> |
| /// Clear all params |
| /// </summary> |
| public void ClearParams() |
| { |
| if ( _params != null ) |
| _params.Clear(); |
| } |
| |
| public void EnsureParams() |
| { |
| if ( _params == null ) |
| _params = new List<string>(); |
| } |
| |
| #endregion |
| |
| #region QUERY TERMS |
| |
| /// <summary> |
| /// |
| /// </summary> |
| /// <returns>true if there is at least one query term. Query terms |
| /// are of the form name=value</returns> |
| public Boolean HasTerms() |
| { |
| return _terms!=null && _terms.Count>0; |
| } |
| |
| /// <summary> |
| /// |
| /// </summary> |
| /// <param name="name"></param> |
| /// <returns>true if there is at least one query term with the specified |
| /// name</returns> |
| public Boolean HasTerm( String name ) |
| { |
| if ( _terms == null ) |
| return false; |
| return _terms.ContainsKey( name ); |
| } |
| |
| |
| /// <summary> |
| /// |
| /// </summary> |
| /// <param name="name"></param> |
| /// <param name="value"></param> |
| /// <returns>if there is a query term with the specified value.</returns> |
| public Boolean HasTerm( String name, String value ) |
| { |
| if ( _terms == null ) |
| return false; |
| |
| Object obj = _terms[ name ]; |
| if ( obj == null ) |
| return false; |
| |
| if ( obj is List<String> ) |
| return ( ( List<String> ) obj ).Contains( value ); |
| |
| return obj.Equals( value ); |
| } |
| |
| /// <summary> |
| /// |
| /// </summary> |
| /// <param name="name"></param> |
| /// <param name="value"></param> |
| /// <returns>if there is a query term with the specified value.</returns> |
| public Boolean HasTerm( String name, int? value ) |
| { |
| return HasTerm( name, value.ToString() ); |
| } |
| |
| /// <summary> |
| /// |
| /// </summary> |
| /// <param name="name"></param> |
| /// <param name="value"></param> |
| /// <returns>if there is a query term with the specified value.</returns> |
| public Boolean HasTerm( String name, double? value ) |
| { |
| return HasTerm( name, value.ToString() ); |
| } |
| |
| /// <summary> |
| /// |
| /// </summary> |
| /// <param name="name"></param> |
| /// <returns>true if the query term specified by name has multiple values.</returns> |
| public Boolean HasMultipleValues(String name) |
| { |
| if ( _terms == null ) |
| return false; |
| |
| Object obj = _terms[ name ]; |
| if ( obj == null ) |
| return false; |
| |
| if ( obj is List<String> ) |
| return ( ( List<String> ) obj ).Count > 1; |
| |
| return false; |
| } |
| |
| /// <summary> |
| /// Gets the value of the specified query term. |
| /// </summary> |
| /// <param name="name"></param> |
| /// <returns>the value of the specified term, or null if not found.</returns> |
| public String GetTerm( String name ) |
| { |
| Object obj = null; |
| if ( _terms == null ) |
| return null; |
| try |
| { |
| obj = _terms[name]; |
| } |
| catch (Exception) |
| { |
| |
| } |
| if ( obj == null ) |
| return null; |
| |
| if ( obj is List<String> ) |
| { |
| IEnumerator<String> i = ( ( List<String> ) obj ).GetEnumerator(); |
| i.MoveNext(); |
| String s = i.Current; |
| |
| if ( i.MoveNext() ) |
| throw new Exception( "term has multiple values" ); |
| return s; |
| } |
| return ( String ) obj; |
| } |
| |
| /// <summary> |
| /// |
| /// </summary> |
| /// <param name="name"></param> |
| /// <param name="defaultValue"></param> |
| /// <returns>the value of the specified term, or defaultValue if not found.</returns> |
| public String GetTerm( String name, String defaultValue ) |
| { |
| String value = GetTerm( name ); |
| if ( value == null ) |
| return defaultValue; |
| return value; |
| } |
| |
| /// <summary> |
| /// Gets the boolean value of the specified query term. |
| /// </summary> |
| /// <param name="name"></param> |
| /// <returns>the boolean value, or null if not found.</returns> |
| /// <see cref="GetTerm(String)"/> |
| public bool? GetBooleanTerm( String name ) |
| { |
| String s = GetTerm( name ); |
| if ( s == null ) |
| return null; |
| |
| // modeling java behavior |
| return s.Equals( "true", StringComparison.CurrentCultureIgnoreCase )? true : false; |
| } |
| |
| public Boolean GetBooleanTerm( String name, Boolean defaultValue ) |
| { |
| String s = GetTerm( name ); |
| if ( s == null ) |
| return defaultValue; |
| |
| return ( s.Equals( "true", StringComparison.CurrentCultureIgnoreCase ) )? true : false; |
| } |
| |
| /// <summary> |
| /// Gets the integer value of the specified query term. |
| /// </summary> |
| /// <param name="name"></param> |
| /// <returns>the integer value, or null if not found.</returns> |
| /// |
| public int? GetIntegerTerm( String name ) |
| { |
| String s = GetTerm( name ); |
| if ( s == null ) |
| return null; |
| return Convert.ToInt32( s ); |
| } |
| |
| /// <summary> |
| /// Gets the integer value of the specified query term. |
| /// </summary> |
| /// <param name="name"></param> |
| /// <param name="defaultValue">the value to return if the term is not found.</param> |
| /// <returns>the integer value, or defaultValue if not found.</returns> |
| /// <see cref="GetTerm( String )"/> |
| /// |
| public int? GetIntegerTerm( String name, int defaultValue ) |
| { |
| int? i = GetIntegerTerm( name ); |
| if ( i == null ) |
| return defaultValue; |
| return i; |
| } |
| |
| public double? GetDoubleTerm( String name ) |
| { |
| String s = GetTerm( name ); |
| if ( s == null ) |
| return null; |
| |
| return Convert.ToDouble( s ); |
| } |
| |
| /// <summary> |
| /// Gets the values of the specified query term. |
| /// </summary> |
| /// <param name="name"></param> |
| /// <returns>an iterator over the string values of the query term. May be empty.</returns> |
| public IEnumerator<String> GetTerms( String name ) |
| { |
| if ( _terms == null ) |
| return null; |
| Object obj = _terms[ name ]; |
| if ( obj == null ) |
| return new EmptyIterator<String>(); |
| |
| if ( obj is List<String> ) |
| return ( ( List<String> ) obj ).GetEnumerator(); |
| |
| return new SingleIterator<String>( ( String ) obj ); |
| } |
| |
| /// <summary> |
| /// Gets the names of the query terms. |
| /// </summary> |
| /// <returns>an iterator over the string names.</returns> |
| public IEnumerator<String> GetTermNames() |
| { |
| if ( _terms == null ) |
| return new EmptyIterator<String>(); |
| |
| return _terms.Keys.GetEnumerator(); |
| } |
| |
| /// <summary> |
| /// Adds the specified query term to the set of query terms. Duplicate |
| /// name/value pairs are suppressed. |
| /// </summary> |
| /// <param name="name"></param> |
| /// <param name="value"></param> |
| public void AddTerm( String name, String value ) |
| { |
| EnsureTerms(); |
| Object obj; |
| |
| try |
| { |
| obj = _terms[ name ]; |
| } |
| catch ( KeyNotFoundException ) |
| { |
| obj = null; |
| } |
| |
| if ( obj == null ) |
| { |
| _terms.Add( name, value ); |
| return; |
| } |
| |
| if ( obj is List<String> ) |
| { |
| ( ( List<String> ) obj ).Add( value ); |
| return; |
| } |
| |
| List<String> values = new List<string>(); |
| values.Add( ( String ) obj ); |
| values.Add( value ); |
| _terms[ name ] = values; |
| } |
| |
| /// <summary> |
| /// Adds the specified query term to the set of query terms. Duplicate |
| /// name/value pairs are suppressed. |
| /// </summary> |
| /// <param name="name"></param> |
| /// <param name="value"></param> |
| public void AddTerm( String name, int? value ) |
| { |
| AddTerm( name, value.ToString() ); |
| } |
| |
| /// <summary> |
| /// Adds the specified query term to the set of query terms. Duplicate |
| /// name/value pairs are suppressed. |
| /// </summary> |
| /// <param name="name"></param> |
| /// <param name="value"></param> |
| public void AddTerm( String name, double? value ) |
| { |
| AddTerm( name, value.ToString() ); |
| } |
| |
| /// <summary> |
| /// Removes all the values associated with the specified query term. |
| /// </summary> |
| /// <param name="name"></param> |
| /// <returns>true if something was removed, false otherwise.</returns> |
| public Boolean RemoveTerm( String name ) |
| { |
| return _terms.Remove( name ); |
| } |
| |
| /// <summary> |
| /// Removes the specified name/value pair from the set of query terms. |
| /// </summary> |
| /// <param name="name"></param> |
| /// <param name="value"></param> |
| /// <returns>true if the name/value pair was found and removed.</returns> |
| /// |
| public Boolean RemoveTerm( String name, String value ) |
| { |
| if ( _terms == null ) |
| return false; |
| |
| Object obj = _terms[ name ]; |
| if ( obj == null ) |
| return false; |
| |
| if ( obj is List<String> ) |
| { |
| List<String> x = ( List<String> ) obj; |
| Boolean ok = x.Remove( value ); |
| if ( x.Count == 1 ) |
| { |
| IEnumerator<String> it = x.GetEnumerator(); |
| it.MoveNext(); |
| _terms[ name ] = it.Current; |
| } |
| |
| return ok; |
| } |
| _terms.Remove( name ); |
| return true; |
| } |
| |
| /// <summary> |
| /// Removes all query terms |
| /// </summary> |
| public void ClearTerms() |
| { |
| if ( _terms != null ) |
| _terms.Clear(); |
| } |
| |
| private void EnsureTerms() |
| { |
| if ( _terms == null ) |
| _terms = new Dictionary<String, Object>(); |
| } |
| |
| |
| #endregion |
| |
| #region FRAGMENT |
| |
| public String Fragment |
| { |
| get |
| { |
| return _fragment; |
| } |
| set |
| { |
| CheckNotBlank( "fragment", value ); |
| _fragment = value; |
| } |
| } |
| |
| #endregion |
| |
| #region UTIL |
| |
| public override string ToString() |
| { |
| StringBuilder sb = new StringBuilder(); |
| |
| Escape( sb, _scheme ); |
| sb.Append( ':' ); |
| |
| if ( _host != null ) |
| { |
| sb.Append( "//" ); |
| if ( _user != null ) |
| { |
| Escape( sb, _user ); |
| if ( _password != null ) |
| { |
| sb.Append( ':' ); |
| Escape( sb, _password ); |
| } |
| sb.Append( '@' ); |
| } |
| Escape( sb, _host ); |
| if ( _port != 0 ) |
| { |
| sb.Append( ':' ); |
| sb.Append( _port ); |
| } |
| sb.Append( '/' ); |
| } |
| |
| if ( _uri != null ) |
| Escape( sb, _uri ); |
| |
| if ( HasParams() ) |
| ParamsToString( sb ); |
| |
| if ( HasTerms() ) |
| TermsToString( sb ); |
| |
| if ( _fragment != null ) |
| { |
| sb.Append( '#' ); |
| Escape( sb, _fragment ); |
| } |
| return sb.ToString(); |
| } |
| |
| public override int GetHashCode() |
| { |
| int code = 23547853; |
| code ^= hc( _scheme ); |
| code ^= hc( _user ); |
| code ^= hc( _password ); |
| code ^= hc( _host ); |
| code ^= hc( _port ); |
| code ^= hc( _uri ); |
| code ^= hc( _params ); |
| code ^= hc( _terms ); |
| code ^= hc( _fragment ); |
| return code; |
| } |
| |
| private int hc( Dictionary<String,Object> m ) |
| { |
| return m != null ? m.GetHashCode() : 793; |
| } |
| |
| private int hc( List<String> s ) |
| { |
| return s != null ? s.GetHashCode() : 161; |
| } |
| |
| private int hc( int? i ) |
| { |
| return i != null ? i.GetHashCode() : 59; |
| } |
| |
| private int hc( String s ) |
| { |
| return s != null ? s.GetHashCode() : 91; |
| } |
| |
| |
| public override bool Equals( object obj ) |
| { |
| if ( obj == this ) |
| return true; |
| |
| if ( !( obj is URL ) ) |
| return false; |
| |
| URL other = ( URL ) obj; |
| |
| if ( !_scheme.Equals( other.Scheme, StringComparison.CurrentCultureIgnoreCase ) ) |
| return false; |
| |
| if ( !_user.Equals( other.User ) ) |
| return false; |
| |
| if ( !_password.Equals( other.Password ) ) |
| return false; |
| |
| if ( !_host.Equals( other.Host ) ) |
| return false; |
| |
| if ( _port != other.Port ) |
| return false; |
| |
| if (!_uri.Equals(other._uri)) |
| return false; |
| |
| if ( !CompareParams( _params, other._params ) ) |
| return false; |
| |
| if ( !CompareTerms( _terms, other._terms ) ) |
| return false; |
| |
| if ( !_fragment.Equals( other.Fragment ) ) |
| return false; |
| |
| return true; |
| } |
| |
| private bool CompareParams( List<String> a, List<String> b ) |
| { |
| if ( a == b ) |
| return true; |
| |
| int na = a != null ? a.Count : 0; |
| int nb = b != null ? b.Count : 0; |
| |
| |
| |
| if (na == 0 || nb == 0) |
| return na == 0 && nb == 0; |
| |
| return a.Equals( b ); |
| } |
| |
| private bool CompareTerms( Dictionary<String, Object> a, Dictionary<String, Object> b ) |
| { |
| if ( a == b ) |
| return true; |
| |
| int na = a != null ? a.Count : 0; |
| int nb = b != null ? b.Count : 0; |
| |
| if ( na == 0 || nb == 0 ) |
| return na == 0 && nb == 0; |
| |
| return a.Equals( b ); |
| } |
| |
| private void ParamsToString( StringBuilder sb ) |
| { |
| IEnumerator<String> it = GetParams(); |
| while ( it.MoveNext() ) |
| { |
| String param = it.Current; |
| sb.Append( ';' ); |
| Escape( sb, param ); |
| } |
| } |
| |
| private void TermsToString( StringBuilder sb ) |
| { |
| char sep = '?'; |
| IEnumerator<String> it = GetTermNames(); |
| while ( it.MoveNext() ) |
| { |
| String name = it.Current; |
| IEnumerator<String> jt = GetTerms( name ); |
| while ( jt.MoveNext() ) |
| { |
| String value = jt.Current; |
| sb.Append( sep ); |
| Escape( sb, name ); |
| sb.Append( '=' ); |
| Escape( sb, value ); |
| sep = '&'; |
| } |
| } |
| } |
| |
| /// <summary> |
| /// Dumps URL contents for easy viewing |
| /// </summary> |
| public void Dump() |
| { |
| Console.WriteLine( "---------------" ); |
| Console.WriteLine( "scheme = "+_scheme ); |
| Console.WriteLine( "user = "+_user ); |
| Console.WriteLine( "password = "+_password ); |
| Console.WriteLine( "host = "+_host ); |
| Console.WriteLine( "port = "+_port ); |
| Console.WriteLine( "uri = "+_uri ); |
| Console.WriteLine( "params = "+_params ); |
| Console.WriteLine( "terms = "+_terms ); |
| Console.WriteLine( "fragment = "+_fragment ); |
| } |
| |
| private void Escape( StringBuilder sb, String s ) |
| { |
| CharIterator i = new CharIterator( s ); |
| while ( i.MoveNext() ) |
| { |
| char c = i.Current; |
| if ( IsEscaped( c ) ) |
| { |
| sb.Append( '%' ); |
| sb.Append( StringUtil.ToHex( ( c >> 4 )& 15 ) ); |
| sb.Append( StringUtil.ToHex( c & 15 ) ); |
| } |
| else if ( c == ' ' ) |
| { |
| sb.Append( '+' ); |
| } |
| else |
| { |
| sb.Append( c ); |
| } |
| } |
| } |
| |
| private static Boolean IsEscaped( char c ) |
| { |
| if ( c >= '0' && c <= '9' ) |
| return false; |
| if ( c >= 'A' && c <= 'Z' ) |
| return false; |
| if ( c >= 'a' && c <= 'z' ) |
| return false; |
| if ( c == ' ' ) |
| return false; |
| if ( c == ',' ) |
| return false; |
| if ( c == '.' ) |
| return false; |
| if ( c == '/' ) |
| return false; |
| if ( c == '!' ) |
| return false; |
| if ( c == '$' ) |
| return false; |
| if ( c == '^' ) |
| return false; |
| if ( c == '*' ) |
| return false; |
| if ( c == '(' ) |
| return false; |
| if ( c == ')' ) |
| return false; |
| if ( c == '_' ) |
| return false; |
| if ( c == '-' ) |
| return false; |
| if ( c == '{' ) |
| return false; |
| if ( c == '}' ) |
| return false; |
| if ( c == '[' ) |
| return false; |
| if ( c == ']' ) |
| return false; |
| if ( c == '|' ) |
| return false; |
| if ( c == '\\' ) |
| return false; |
| return true; |
| } |
| |
| private String Unescape( String s ) |
| { |
| StringBuilder sb = new StringBuilder(); |
| CharIterator i = new CharIterator( s ); |
| while ( i.MoveNext() ) |
| { |
| char c = i.Current; |
| if ( c == '%') |
| { |
| i.MoveNext(); |
| char c1 = i.Current; |
| i.MoveNext(); |
| char c2 = i.Current; |
| sb.Append( ( char ) ( ( StringUtil.FromHex( c1 ) << 4 ) | StringUtil.FromHex( c2 ) ) ); |
| } |
| else if ( c == '+' ) |
| { |
| sb.Append( ' ' ); |
| } |
| else |
| { |
| sb.Append( c ); |
| } |
| } |
| return sb.ToString(); |
| } |
| |
| private static void CheckNotBlank( String name, String value ) |
| { |
| if ( value != null && value.Length == 0 ) |
| throw new ArgumentException( name + " is blank" ); |
| } |
| |
| private static String ValueToString( double value ) |
| { |
| return Convert.ToString( value ); |
| } |
| |
| private static String ValueToString( int value ) |
| { |
| return Convert.ToString( value ); |
| } |
| |
| private static List<String> CopyParams( List<String> paramss ) |
| { |
| if ( paramss == null ) |
| return null; |
| return new List<String>( paramss ); |
| } |
| |
| private static Dictionary<String, Object> CopyTerms( Dictionary<String, Object> terms ) |
| { |
| if ( terms == null ) |
| return null; |
| |
| Dictionary<String, Object> map = new Dictionary<string, object>( terms ); |
| IEnumerator<KeyValuePair<String, Object>> i = map.GetEnumerator(); |
| while ( i.MoveNext() ) |
| { |
| KeyValuePair<String, Object> me = i.Current; |
| Object obj = me.Value; |
| if ( obj is List<String> ) |
| map[ me.Key ] = new List<String>( ( List<String> ) obj ); |
| } |
| return map; |
| } |
| |
| #endregion |
| } |
| } |
