/// <summary> /// Returns a new OrderedMap containing all the keys of this OrderedMap. /// </summary> /// <param name="filter">A value used to filter the keys for the specified value. If null, no filtering is done.</param> /// <returns>Returns a new OrderedMap with the keys of this OrderedMap.</returns> public OrderedMap GetKeysOrderedMap(object filter) { OrderedMap newOrderedMap = null; if (this.Count > 0) { newOrderedMap = new OrderedMap(); foreach (string theKey in this.Keys) { if (filter == null) newOrderedMap[null] = theKey; else { if (this[theKey].ToString().Equals(filter.ToString())) newOrderedMap[null] = theKey; } } } return newOrderedMap; }
/// <summary> /// Returns an OrderedMap with the pathnames that match the specified pattern. /// </summary> /// <param name="pattern">The search pattern.</param> /// <returns>Returns an OrderedMap with the pathnames that match the specified pattern.</returns> public static OrderedMap Glob(string pattern) { OrderedMap newOrderedMap = null; try { string path = System.Web.HttpContext.Current.Request.MapPath( System.Web.HttpContext.Current.Request.ApplicationPath); System.IO.DirectoryInfo dirInfo = new System.IO.DirectoryInfo(System.IO.Path.GetDirectoryName(path)); System.IO.FileSystemInfo[] fileInfos = dirInfo.GetFiles(pattern); if (fileInfos.Length > 0) { newOrderedMap = new OrderedMap(); for (int index = 0; index < fileInfos.Length; index++) newOrderedMap[index] = fileInfos[index].Name; } } catch { } return newOrderedMap; }
/// <summary> /// Returns an OrderedMap with information about the specified path. /// </summary> /// <param name="path">The path to retrieve the information from.</param> /// <returns>Returns an OrderedMap with information about the specified path.</returns> public static OrderedMap PathInfo(string path) { OrderedMap pathInfo = null; try { pathInfo = new OrderedMap(); pathInfo["dirname"] = System.IO.Path.GetDirectoryName(path); pathInfo["basename"] = System.IO.Path.GetFileName(path); pathInfo["extension"] = System.IO.Path.GetExtension(path); } catch { } return pathInfo; }
/// <summary> /// Returns a new OrderedMap that represents a slice of the specified OrderedMap. /// </summary> /// <param name="input">The OrderedMap to extract the slice from.</param> /// <param name="offset">The starting position of the slice.</param> /// <param name="length">The length of the slice.</param> /// <returns>Returns a new OrderedMap that represents a slice of the specified OrderedMap.</returns> public static OrderedMap Slice(OrderedMap input, int offset, int length) { OrderedMap newOrderedMap = null; if (input != null && input.Count > 0) { newOrderedMap = new OrderedMap(); int theOffset = offset, theLength = length; _GetAbsPositions(ref theOffset, ref theLength, input.Count); for (int index = theOffset; index < theOffset + theLength; index++) { System.Collections.DictionaryEntry entry = input.GetEntryAt(index); if (OrderedMap.IsKeyInteger((string) entry.Key)) newOrderedMap[null] = entry.Value; else newOrderedMap[entry.Key] = entry.Value; } } return newOrderedMap; }
/// <summary> /// Sorts by key the specified OrderedMap and reverses it. The existing keys are preserved. /// </summary> /// <param name="input">The OrderedMap to be sorted.</param> /// <param name="sortFlags">The sorting options (SORTREGULAR, SORTNUMERIC, SORTSTRING).</param> public static void SortKeyPreserveReverse(ref OrderedMap input, int sortFlags) { OrderedMap.Sort(ref input, sortFlags, true, false, null, null); input = OrderedMap.Reverse(input, true); }
/// <summary> /// Reverses the specified OrderedMap, if <code>preserveKeys</code> is true, the original keys will be used. /// </summary> /// <param name="input">The OrderedMap that will be reversed.</param> /// <param name="preserveKeys">The boolean value that indicates whether to preserve the original keys or auto-generate new keys.</param> /// <returns>Returns a new reversed OrderedMap.</returns> public static OrderedMap Reverse(OrderedMap input, bool preserveKeys) { OrderedMap newOrderedMap = null; if (input != null && input.Count > 0) { newOrderedMap = new OrderedMap(); for (int index = input.Count - 1; index >= 0; index--) { System.Collections.DictionaryEntry entry = input.GetEntryAt(index); if (preserveKeys) newOrderedMap[entry.Key] = entry.Value; else { if (IsKeyInteger(entry.Key.ToString())) newOrderedMap[null] = entry.Value; else newOrderedMap[entry.Key] = entry.Value; } } } return newOrderedMap; }
/// <summary> /// Randomizes the order of the elements in the specified OrderedMap. /// </summary> /// <param name="input">The OrderedMap to be randomly re-ordered.</param> public static void Shuffle(ref OrderedMap input) { OrderedMap.SortValueUser(ref input, "RamdomCompare", input); }
/// <summary> /// Splits the specified OrderedMap into chunks /// </summary> /// <param name="input">The OrderedMap to be splitted.</param> /// <param name="size">The size of each chunk.</param> /// <param name="preserveKeys">If true, the original keys will be preserved, otherwise new integer indices will be used.</param> /// <returns>Returns a new OrderedMap containing all the chunks.</returns> public static OrderedMap Chunk(OrderedMap input, int size, bool preserveKeys) { OrderedMap newOrderedMap = null; if (input != null && input.Count > 0) { newOrderedMap = new OrderedMap(); int totalChunks = input.Count/size; totalChunks += (input.Count%size) > 0 ? 1 : 0; for (int index = 0; index < totalChunks; index++) { OrderedMap theChunk = new OrderedMap(); for (int chunkIndex = 0; chunkIndex < size; chunkIndex++) { if ((index*size) + chunkIndex < input.Count) { string key = ""; if (preserveKeys) key = input.GetKeyAt((index*size) + chunkIndex); else key = chunkIndex.ToString(); theChunk[key] = input.GetValueAt((index*size) + chunkIndex); } else break; } newOrderedMap[index] = theChunk; } } return newOrderedMap; }
/// <summary> /// Counts all the values of the specified OrderedMap. /// </summary> /// <param name="input">The OrderedMap that contains the values to be counted.</param> /// <returns>Returns a new OrderedMap which contains the values and their frecuency.</returns> public static OrderedMap CountValues(OrderedMap input) { OrderedMap newOrderedMap = null; if (input != null && input.Count > 0) { newOrderedMap = new OrderedMap(); foreach (object theValue in input.Values) { if (newOrderedMap[theValue] != null) newOrderedMap[theValue] = ((int) newOrderedMap[theValue]) + 1; else newOrderedMap[theValue] = 1; } } return newOrderedMap; }
/// <summary> /// Appends the contents of the second OrderedMap to the first OrderedMap into a new OrderedMap. /// </summary> /// <param name="input1">The first OrderedMap.</param> /// <param name="input2">The second OrderedMap to be appended.</param> /// <returns>Returns a new OrderedMap with the appended OrderedMaps.</returns> public static OrderedMap Append(OrderedMap input1, OrderedMap input2) { OrderedMap newOrderedMap = null; //if at least one of the OrderedMaps is not null if (input1 != null || input2 != null) { newOrderedMap = new OrderedMap(); if (input1 != null) newOrderedMap = new OrderedMap(input1, false); if (input2 != null) { foreach (string key in input2.Keys) { if (newOrderedMap[key] == null) newOrderedMap[key] = input2[key]; } } } return newOrderedMap; }
/// <summary> /// Changes the case of all string keys of the specified OrderedMap. /// </summary> /// <param name="input">The OrderedMap that contains the keys to be changed.</param> /// <param name="arrayCase">Indicates whether to change the keys to lowercase (0) or to uppercase (any other integer value)</param> /// <returns>Returns a new OrderedMap with all string keys lowercased or uppercased.</returns> public static OrderedMap ChangeCase(OrderedMap input, int arrayCase) { OrderedMap newOrderedMap = null; if (input != null && input.Count > 0) { newOrderedMap = new OrderedMap(); foreach (string key in input.Keys) { string newKey = key; newKey = (arrayCase == 0 ? key.ToLower() : key.ToUpper()); newOrderedMap[newKey] = input[key]; } } return newOrderedMap; }
/// <summary> /// Sets a value in a multidimensional OrderedMap. /// </summary> /// <param name="args">The parameter <code>args</code> is an array of objects with the following form: /// args(value, key1, ..., keyn-1, keyn). Where value (the first element) is the value to be set, the rest of the elements /// are the keys, each key represents a dimension. /// For instance, a PHP source code that look like this: <code>arr[1][3][4][6] = "value";</code> would be converted using this method /// like this: <code>arr.SetValue("value", 1, 3, 4, 6);</code>.</param> public void SetValue(params object[] args) { if (args.Length < 2) return; if (args.Length == 2) { this[args[1]] = args[0]; return; } //if there are at least two indexers go on. string theKey = ""; //loop over the specified keys creating new OrderedMaps (i.e. dimensions) when necessary. OrderedMap currentOrderedMap = this; for (int index = 1; index < args.Length - 1; index++) { //if a key is not specified (null), it should be calculated. theKey = args[index] == null ? currentOrderedMap._GetMaxIntegerKey() : args[index].ToString(); if (currentOrderedMap[theKey] == null) { //specified element does not exist, create a new OrderedMap (i.e. a new dimension). currentOrderedMap[theKey] = new OrderedMap(); } else { //current element already exists in OrderedMap. if (currentOrderedMap[theKey] is string) { //current element is not a OrderedMap but a string. If possible, change the string value and return. object newValue; if (index == args.Length - 1) { //the string value should be changed by the new value. newValue = args[0]; } else if (index == args.Length - 2) { newValue = this._ReplaceCharAt((string) currentOrderedMap[theKey], (int) args[index + 1], args[0].ToString()[0]); } else { //the indexers are not valid in the string value, ignore this case and return. return; } //update the string value and return. currentOrderedMap[theKey] = newValue; return; } else { if (!(currentOrderedMap[theKey] is OrderedMap)) { //current element is not a string nor an OrderedMap. It is not possible to use that element as an array. throw new System.Exception("Warning: Cannot use a scalar value as an array"); } } } //move to next dimension, current element is an OrderedMap (either a new or an existing one). currentOrderedMap = (OrderedMap) currentOrderedMap[theKey]; } //end for //current OrderedMap represents the last dimension, set a new entry in the current OrderedMap, //formed by the last key (if any) and the specified value. currentOrderedMap[args[args.Length - 1]] = args[0]; }
/// <summary> /// Returns a new OrderedMap containing all the values of this OrderedMap. /// </summary> /// <returns></returns> public OrderedMap GetValuesOrderedMap() { OrderedMap newOrderedMap = null; if (this.Count > 0) { newOrderedMap = new OrderedMap(this.Values, false); } return newOrderedMap; }
/// <summary> /// Returns an OrderedMap containing randomly-choosen keys from this OrderedMap. /// </summary> /// <param name="numKeys">The number of keys to obtain.</param> /// <returns>Returns a new OrderedMap containing randomly-choosen keys.</returns> public OrderedMap GetRandomKeys(int numKeys) { OrderedMap newOrderedMap = null; if (this.Count > 0) { newOrderedMap = new OrderedMap(); System.Random random = new System.Random(); for (int index = 0; index < numKeys; index++) { int randKeyIndex = random.Next(this.Count - 1); newOrderedMap[null] = this.GetKeyAt(randKeyIndex); } } return newOrderedMap; }
/// <summary> /// Pads de specified OrderedMap with the specified pad value. /// If <code>padSize</code> is negative, then the OrderedMap will be left-padded, otherwise it will be right-paddded. /// </summary> /// <param name="input">The OrderedMap that will be use to do the padding.</param> /// <param name="padSize">The padding size.</param> /// <param name="padValue">The value used to pad.</param> /// <returns>Returns a new paddde OrderedMap.</returns> public static OrderedMap Pad(OrderedMap input, int padSize, object padValue) { OrderedMap newOrderedMap = null; if (input != null && input.Count > 0) { int absSize = System.Math.Abs(padSize); if (absSize > input.Count) { int toPad = absSize - input.Count; if (padSize > 0) { newOrderedMap = new OrderedMap(); foreach (string key in input.Keys) { if (IsKeyInteger(key)) newOrderedMap[null] = input[key]; else newOrderedMap[key] = input[key]; } for (int index = 0; index < toPad; index++) { newOrderedMap[null] = padValue; } } else { newOrderedMap = new OrderedMap(); for (int index = 0; index < toPad; index++) { newOrderedMap[null] = padValue; } newOrderedMap = OrderedMap.Merge(newOrderedMap, input); } } else { newOrderedMap = new OrderedMap(input, false); } } return newOrderedMap; }
/// <summary> /// Creates a new OrderedMap with a consecutive range of numbers. /// </summary> /// <param name="low">The first value of the range.</param> /// <param name="high">The last value of the range.</param> /// <returns>Returns a new OrderedMap with a consecutive range of numbers.</returns> public static OrderedMap CreateRange(int low, int high) { OrderedMap newOrderedMap = new OrderedMap(); bool increment = high >= low ? true : false; for (int index = low; increment ? index <= high : index >= high; index += increment ? 1 : -1) { newOrderedMap[null] = index; } return newOrderedMap; }
/// <summary> /// Reduces the specified OrderedMap to a single value using a callback function. /// </summary> /// <param name="input">The OrderedMap that contains the values to be reduced.</param> /// <param name="methodName">The method name to use for reduction.</param> /// <param name="initial">The initial value of the resulting reduced value.</param> /// <param name="instance">The instance that contains the definition of the method used for reduction.</param> /// <returns>Returns a single value which represents the reduction of the OrderedMap according to the specified callback method.</returns> public static double Reduce(OrderedMap input, string methodName, int initial, object instance) { double result = initial; if (input != null && input.Count > 0) { try { System.Type theType = instance.GetType(); System.Reflection.MethodInfo callbackMethod = theType.GetMethod(methodName); if (input != null && input.Count > 0) { object[] parameters = new object[] {initial, input.GetValueAt(0)}; result = (double) callbackMethod.Invoke(instance, parameters); for (int index = 1; index < input.Count; index++) { object theValue = input.GetValueAt(index); if (System.Text.RegularExpressions.Regex.IsMatch(theValue.ToString(), OrderedMap._NUMBERREGULAREXPRESSION)) { parameters[0] = result; parameters[1] = theValue; result = (double) callbackMethod.Invoke(instance, parameters); } } } } catch (System.Exception exception) { throw exception; } } return result; }
/// <summary> /// Creates a new OrderedMap with a consecutive range of characters (actually strings are used for compatibility). /// </summary> /// <param name="lowChar">The first value of the range.</param> /// <param name="highChar">The last value of the range.</param> /// <returns>Returns a new OrderedMap with a consecutive range of characters.</returns> public static OrderedMap CreateRange(string lowChar, string highChar) { OrderedMap newOrderedMap = new OrderedMap(); int lowCharInt = (int) lowChar[0], highCharInt = (int) highChar[0]; bool increment = highCharInt >= lowCharInt ? true : false; for (int index = lowCharInt; increment ? index <= highCharInt : index >= highCharInt; index += increment ? 1 : -1) { newOrderedMap[null] = new string(new char[] {(char) index}); } return newOrderedMap; }
/// <summary> /// Shifts (removes) the first element of the specified OrderedMap and returns the value. All the numeric keys are recalculated. /// </summary> /// <param name="input">The OrderedMap that will be shifted.</param> /// <returns>Returns the element that was removed from the specified OrderedMap.</returns> public static object Shift(ref OrderedMap input) { object result = null; if (input.Count > 0) { OrderedMap newOrderedMap = new OrderedMap(); result = input.GetValueAt(0); input.RemoveAt(0); foreach (string key in input.Keys) { if (OrderedMap.IsKeyInteger(key)) newOrderedMap[null] = input[key]; else newOrderedMap[key] = input[key]; } input = newOrderedMap; input.Reset(); } return result; }
/// <summary> /// Creates a new OrderedMap and fills it with the specified value. /// </summary> /// <param name="startIndex">The index used to calculate the keys.</param> /// <param name="num">The number of entries of the value.</param> /// <param name="theValue">The value to fill the OrderedMap with.</param> /// <returns>Returns a new OrderedMap filled with the specified value.</returns> public static OrderedMap Fill(int startIndex, int num, object theValue) { OrderedMap newOrderedMap = new OrderedMap(); for (int index = startIndex; index < startIndex + num; index++) newOrderedMap[index] = theValue; return newOrderedMap; }
/// <summary> /// Returns a new OrderedMap that represents a slice of the specified OrderedMap. /// </summary> /// <param name="input">The OrderedMap to extract the slice from.</param> /// <param name="offset">The starting position of the slice.</param> /// <returns>Returns a new OrderedMap that represents a slice of the specified OrderedMap.</returns> public static OrderedMap Slice(OrderedMap input, int offset) { return OrderedMap.Slice(input, offset, input.Count); }
/// <summary> /// Filters the elements of the specified OrderedMap using the specified method that belongs to the specified instance. /// </summary> /// <param name="input">The Ordered to be filtered.</param> /// <param name="functionName">The callback method used to filter the OrderedMap.</param> /// <param name="instance">The instance which defines the callback method.</param> /// <returns>Returns a new OrderedMap with the filtered elements.</returns> public static OrderedMap Filter(OrderedMap input, string methodName, object instance) { OrderedMap newOrderedMap = null; if (input != null && input.Count > 0) { if (methodName == null) { //No filter is needed. newOrderedMap = new OrderedMap(input, false); } else { try { newOrderedMap = new OrderedMap(); System.Type theType = instance.GetType(); System.Reflection.MethodInfo callbackMethod = theType.GetMethod(methodName); foreach (string theKey in input.Keys) { if ((bool) callbackMethod.Invoke(instance, new object[] {input[theKey]})) newOrderedMap[theKey] = input[theKey]; } } catch (System.Exception exception) { throw exception; } } } return newOrderedMap; }
/// <summary> /// Sorts the specified OrderedMap according to the rest of the arguments. /// The basic functionality of the sorting mechanism is: /// 1. An ArrayList is created using the specified OrderedMap, each ArrayList element is an OrderedMapSortItem (that represent an entry of the OrderedMap). /// 2. The method ArrayList.Sort of the just created ArrayList is called. /// 3. Since the OrderedMapSortItem class implements the System.IComparable interface, the ArrayList is sorted using that interface of each element. /// 4. An sorted-OrderedMap is then created and returned. /// </summary> /// <param name="input">The OrderedMap to be sorted.</param> /// <param name="sortFlags">The sorting options (SORTREGULAR, SORTNUMERIC, SORTSTRING).</param> /// <param name="preserveKeys">The boolean value that indicates whether to preserve the original keys (true) or not (false).</param> /// <param name="byValue">The value that indicates whether to sort the item by its value (true) or by its key (false).</param> /// <param name="methodName">The name of the user-defined method that will be used as comparing method.</param> /// <param name="instance">The instance of the class that defines the user-defined method that will be used as comparing method.</param> /// <remarks>If predefined sorting mechanisms need to be used (that is SORTREGULAR, SORTNUMERIC, SORTSTRING), then /// the parameters <code>methodName</code> and <code>instance</code> can be null.</remarks> public static void Sort(ref OrderedMap input, int sortFlags, bool preserveKeys, bool byValue, string methodName, object instance) { System.Collections.ArrayList sortedOrderedMap = new System.Collections.ArrayList(); foreach (string key in input.Keys) { OrderedMapSortItem item = null; if ((methodName == null || methodName == "") && instance == null) item = new OrderedMapSortItem(key, input[key], sortFlags, byValue); else item = new OrderedMapSortItem(key, input[key], byValue, methodName, instance); sortedOrderedMap.Add(item); } sortedOrderedMap.Sort(); OrderedMap newOrderedMap = new OrderedMap(); for (int index = 0; index < sortedOrderedMap.Count; index++) { OrderedMapSortItem entry = (OrderedMapSortItem) sortedOrderedMap[index]; if (preserveKeys) newOrderedMap[entry.Key] = entry.Value; else newOrderedMap[null] = entry.Value; } newOrderedMap._index = input._index; input = newOrderedMap; }
/// <summary> /// Exchanges all keys in the OrderedMap with their associated values. /// </summary> /// <param name="toTransform">The OrderedMap that contains the keys and values to be exchanged.</param> /// <returns>Returns a new exchanged OrderedMap.</returns> public static OrderedMap Flip(OrderedMap toTransform) { OrderedMap newOrderedMap = null; if (toTransform != null && toTransform.Count > 0) { try { newOrderedMap = new OrderedMap(); foreach (string key in toTransform.Keys) { newOrderedMap[toTransform[key]] = key; } } catch (System.Exception exception) { throw exception; } } return newOrderedMap; }
/// <summary> /// Reads an entire file into an OrderedMap. /// </summary> /// <param name="fileName">The name of the file to open and read.</param> /// <returns>Returns an OrderedMap containing the data from the file.</returns> public static OrderedMap FileToArray(string fileName) { OrderedMap result = null; try { result = new OrderedMap(); System.IO.StreamReader reader = new System.IO.StreamReader(fileName); string line = reader.ReadLine(); while (line != null) { result[line] = line; line = reader.ReadLine(); } reader.Close(); } catch { } return result; }
/// <summary> /// Computes the intersection of two OrderedMaps with extra key checking. /// That is, elements and keys of the first OrderedMap present in the second OrderedMap. /// </summary> /// <param name="input1">The OrderedMap that contains the entries to be searched.</param> /// <param name="input2">The OrderedMap where the entries of the first element will be searched.</param> /// <returns>Returns a new OrderedMap that contains the entries of the first OrderedMap present in the second OrderedMap.</returns> public static OrderedMap IntersectionWithKey(OrderedMap input1, OrderedMap input2) { OrderedMap newOrderedMap = null; for (int index = 0; index < input1.Count; index++) { System.Collections.DictionaryEntry entry = input1.GetEntryAt(index); if (input2.SearchStringRepresentation(entry) != -1) { if (newOrderedMap == null) newOrderedMap = new OrderedMap(); newOrderedMap[entry.Key] = entry.Value; } } return newOrderedMap; }
/// <summary> /// Reads the specified INI file and returns the contents in an OrderedMap. /// </summary> /// <param name="fileName">The INI file to read.</param> /// <returns>Returns the contents of the specified INI file.</returns> public static OrderedMap ParseINI(string fileName) { OrderedMap newOrderedMap = null; try { using (System.IO.StreamReader stream = new System.IO.StreamReader(fileName)) { newOrderedMap = new OrderedMap(); string line; while ((line = stream.ReadLine()) != null) { line = line.Trim(); if (line != "" && !line.StartsWith(";") && !line.StartsWith("[")) { string[] lineContents = line.Split('='); newOrderedMap[lineContents[0].Trim()] = lineContents[1].Trim(); } } } } catch { } return newOrderedMap; }
/// <summary> /// Merges the contents of the first OrderedMap with the contents of the second OrderedMap into a new OrderedMap. /// </summary> /// <param name="input1">The first OrderedMap to be merged.</param> /// <param name="input2">The second OrderedMap to be merged.</param> /// <returns>Returns a new OrderedMap with the merged OrderedMaps.</returns> public static OrderedMap Merge(OrderedMap input1, OrderedMap input2) { OrderedMap newOrderedMap = null; //if at least one of the OrderedMaps is not null if (input1 != null || input2 != null) { newOrderedMap = new OrderedMap(); if (input1 != null) { foreach (string key in input1.Keys) { if (IsKeyInteger(key)) newOrderedMap[null] = input1[key]; else newOrderedMap[key] = input1[key]; } } if (input2 != null) { foreach (string key in input2.Keys) { if (IsKeyInteger(key)) newOrderedMap[null] = input2[key]; else newOrderedMap[key] = input2[key]; } } } return newOrderedMap; }
/// <summary> /// Reads a line from the specified stream and parses it for CSV fields. /// </summary> /// <param name="stream">The stream to read from.</param> /// <param name="length">The maximum length of the line to be read</param> /// <param name="delimiter">The delimiter which separates the CSV fields.</param> /// <returns>Returns an OrderedMap that contains the CSV fields of the read line.</returns> public static OrderedMap ReadCSV(System.IO.FileStream stream, int length, string delimiter) { OrderedMap newOrderedMap = null; try { string line = ReadLine(stream, length); if (line != null) { if (delimiter == null || delimiter == string.Empty) delimiter = ","; string[] fields = line.Split(delimiter[0]); for (int index = 0; index < fields.Length; index++) fields[index] = fields[index].Trim(); newOrderedMap = new OrderedMap(fields, false); } } catch { } return newOrderedMap; }
/// <summary> /// Returns the current key and value pair of this OrderedMap and advances the internal index by one. /// </summary> /// <returns>Returns the current key and value pair from this OrderedMap</returns> public OrderedMap Each() { OrderedMap each = null; if ((this._index < this.Count) && (this._index >= 0)) { DictionaryEntry entry = this.GetEntryAt(this._index); each = new OrderedMap( new object[] {1, entry.Value}, new object[] {"value", entry.Value}, new object[] {0, entry.Key}, new object[] {"key", entry.Key}); this._index++; } return each; }