/// <summary> /// Add the contents of an array to a LazyList /// </summary> /// <param name="list">The list to add to or null if none yet created.</param> /// <param name="array">The Array whose contents should be added.</param> /// <returns>The lazylist created or added to.</returns> public static object AddArray(object list, Array array) { for (int i = 0; array != null && i < array.Length; i++) { list = LazyList.Add(list, array.GetValue(i)); } return(list); }
/// <summary> /// Add the contents of a Collection to a LazyList /// </summary> /// <typeparam name="E">Generics of The List to be created</typeparam> /// <param name="list">The list to add to or null if none yet created.</param> /// <param name="collection">The Collection whose contents should be added.</param> /// <returns>The lazylist created or added to.</returns> public static object AddCollection <E>(object list, ICollection <E> collection) { foreach (E item in collection) { list = LazyList.Add(list, item); } return(list); }
public override string ToString() { if (LazyList.Size(nested) > 0) { return("NJetty.Util.Util.MultiException" + LazyList.GetList(nested)); } return("NJetty.Util.Util.MultiException[]"); }
/// <summary> /// Get a value from a multiple value. /// If the value is not a multivalue, then index 0 retrieves the /// value or null. /// </summary> /// <param name="name">The entry key.</param> /// <param name="i">Index of element to get.</param> /// <returns>Unmodifieable List of values.</returns> public object GetValue(K name, int i) { object l = _map.ContainsKey(name) ? _map[name] : null; if (i == 0 && LazyList.Size(l) == 0) { return(null); } return(LazyList.Get(l, i)); }
/// <summary> /// Put multi valued entry. /// Existing values will be relaced with the new value /// </summary> /// <param name="name"></param> /// <param name="values"></param> public void AddValues(K name, string[] values) { object list = null; for (int i = 0; i < values.Length; i++) { list = LazyList.Add(list, values[i]); } Add(name, list); }
public override string ToString() { List <string> list = new List <string>(); foreach (T item in this) { list.Add(item.ToString()); } return(LazyList.ToString(list)); }
/// <summary> /// /// </summary> /// <returns>Dictionary of string arrays</returns> public Dictionary <K, object> ToStringArrayMap() { Dictionary <K, object> map = new Dictionary <K, object>(_map.Count * 3 / 2); foreach (K key in _map.Keys) { object l = _map[key]; string[] a = LazyList.ToStringArray(l); map.Add(key, a); } return(map); }
/// <summary> /// Add and Exception to the List of Multiple Exceptions /// </summary> /// <param name="e"></param> public void Add(Exception e) { if (e is MultiException) { MultiException me = (MultiException)e; for (int i = 0; i < LazyList.Size(me.nested); i++) { nested = LazyList.Add(nested, LazyList.Get(me.nested, i)); } } else { nested = LazyList.Add(nested, e); } }
/// <summary> /// Add value to multi valued entry. /// If the entry is single valued, it is converted to the first /// value of a multi valued entry. /// The value will be (existing value[s] + the new value[s]) /// </summary> /// <param name="name">The entry key.</param> /// <param name="value">The entry value.</param> public void Append(K name, object value) { object lo = _map.ContainsKey(name) ? _map[name] : null; object ln = LazyList.Add(lo, value); if (lo != ln) { if (_map.ContainsKey(name)) { _map[name] = ln; } else { _map.Add(name, ln); } } }
/// <summary> /// Add values to multi valued entry. /// If the entry is single valued, it is converted to the first /// value of a multi valued entry. /// The value will be (existing value[s] + the new value[s]) /// </summary> /// <param name="name">The entry key</param> /// <param name="values">The string array of multiple values.</param> public void AppendValues(K name, string[] values) { object lo = _map.ContainsKey(name) ? _map[name] : null; object ln = LazyList.AddArray(lo, values); if (lo != ln) { if (_map.ContainsKey(name)) { _map[name] = ln; } else { _map.Add(name, ln); } } }
/// <summary> /// Add values to multi valued entry. /// If the entry is single valued, it is converted to the first /// value of a multi valued entry. /// The value will be (existing value[s] + the new value[s]) /// </summary> /// <param name="name">The entry key.</param> /// <param name="values">The List of multiple values.</param> public void AppendValues(K name, ICollection <object> values) { object lo = _map.ContainsKey(name) ? _map[name] : null; object ln = LazyList.AddCollection(lo, values); if (lo != ln) { if (_map.ContainsKey(name)) { _map[name] = ln; } else { _map.Add(name, ln); } } }
public new bool TryGetValue(K key, out object value) { object l = _map.TryGetValue(key, out value); switch (LazyList.Size(l)) { case 0: return(false); case 1: value = LazyList.Get(l, 0); return(true); default: value = LazyList.GetList(l, true); return(true); } }
/// <summary> /// Add all contents of dictionary in our multi-map, /// replacing existing once with new onces /// </summary> /// <param name="m">Dictionary</param> public void AddAll(Dictionary <K, object> m) { bool multi = m is MultiMap <K>; if (m != null) { foreach (K item in m.Keys) { if (multi) { _map.Add(item, LazyList.Clone(m[item])); } else { _map.Add(item, m[item]); } } } }
/// <summary> /// Remove value. /// </summary> /// <param name="name">The entry key</param> /// <param name="value">The entry value</param> /// <returns>true if it was removed</returns> public bool RemoveValue(K name, object value) { object lo = _map.ContainsKey(name) ? _map[name] : null; object ln = lo; int s = LazyList.Size(lo); if (s > 0) { ln = LazyList.Remove(lo, value); if (ln == null) { _map.Remove(name); } else { _map.Add(name, ln); } } return(LazyList.Size(ln) != s); }
public new object this[K name] { get { object l = _map.ContainsKey(name) ? _map[name] : null; switch (LazyList.Size(l)) { case 0: return(null); case 1: object o = LazyList.Get(l, 0); return(o); default: return(LazyList.GetList(l, true)); } } set { Add(name, value); } }
/// <summary> /// Throw a multiexception. /// If this multi exception is empty then no action is taken. If it /// contains a single exception that is thrown, otherwise the this /// multi exception is thrown. /// </summary> /// /// <exception cref="Exception"></exception> /// <exception cref="SystemException"></exception> /// <exception cref="MultiException">throws this instance, If there are more that one Exception</exception> public void IfExceptionThrow() { switch (LazyList.Size(nested)) { case 0: break; case 1: Exception exception = (Exception)LazyList.Get(nested, 0); if (exception is SystemException) { throw (SystemException)exception; } if (exception is Exception) { throw (Exception)exception; } throw this; default: throw this; } }
/// <summary> /// Encode Hashtable with % encoding. /// </summary> /// <param name="map">multimap values to encode</param> /// <param name="charset">Characterset Encoding</param> /// <param name="equalsForNullValue">if True, then an '=' is always used, even /// for parameters without a value. e.g. "blah?a=&b=&c=". /// </param> /// <returns>Encoded string Value</returns> public static string Encode(MultiMap <string> map, string charset, bool equalsForNullValue) { if (charset == null) { charset = StringUtil.__UTF8; } StringBuilder result = new StringBuilder(128); bool first = true; foreach (string key in map.Keys) { if (!first) { result.Append('&'); } object list = map[key]; int s = LazyList.Size(list); if (s == 0) { result.Append(EncodeString(key, charset)); if (equalsForNullValue) { result.Append('='); } } else { for (int i = 0; i < s; i++) { if (i > 0) { result.Append('&'); } object val = LazyList.Get(list, i); result.Append(EncodeString(key, charset)); if (val != null) { string str = val.ToString(); if (str.Length > 0) { result.Append('='); result.Append(EncodeString(str, charset)); } else if (equalsForNullValue) { result.Append('='); } } else if (equalsForNullValue) { result.Append('='); } } } first = false; } return(result.ToString()); }
/// <summary> /// Get multiple values. /// Single valued entries are converted to singleton lists. /// </summary> /// <param name="name">The entry key.</param> /// <returns>Unmodifieable List of values.</returns> public List <object> GetValues(K name) { return(LazyList.GetList(_map[name], true)); }
public Exception GetException(int i) { return((Exception)LazyList.Get(nested, i)); }
/// <summary> /// Put and entry into the map. /// Existing values will be relaced with the new value /// </summary> /// <param name="name">The entry key.</param> /// <param name="value">The entry value.</param> public new void Add(K name, object value) { _map.Add(name, LazyList.Add(null, value)); }