DeepCopy() публичный Метод

Creates copy of this instance using shared underlaying hashtable.
public DeepCopy ( ) : PhpArray
Результат PhpArray
Пример #1
0
 /// <summary>
 /// Fast creation of an empty array
 /// by referencing internal structure of empty singleton.
 /// </summary>
 public static PhpArray NewEmpty() => Empty.DeepCopy();
Пример #2
0
 /// <summary>
 /// Makes new array containing union of two arrays.
 /// </summary>
 public static PhpArray Union(PhpArray x, PhpArray y) => (PhpArray)x.DeepCopy().Unite(y);
Пример #3
0
        /// <summary>
        /// Compares two instances of <see cref="PhpArray"/>.
        /// </summary>
        /// <param name="x">First operand. Cannot be <c>null</c>.</param>
        /// <param name="y">Second operand. Cannot be <c>null</c>.</param>
        /// <param name="comparer">The comparer.</param>
        /// <param name="incomparable">Whether arrays are incomparable
        /// (no difference is found before both arrays enters an infinite recursion).
        /// Returns zero then.</param>
        public static int CompareArrays(PhpArray x, PhpArray y, IComparer <PhpValue> comparer, out bool incomparable)
        {
            Debug.Assert(x != null && y != null);

            incomparable = false;

            // if both operands point to the same internal dictionary:
            if (object.ReferenceEquals(x.table, y.table))
            {
                return(0);
            }

            //
            PhpArray array_x, array_y;
            PhpArray sorted_x, sorted_y;

            // if numbers of elements differs:
            int result = x.Count - y.Count;

            if (result != 0)
            {
                return(result);
            }

            // comparing with the same instance:
            if (x == y)
            {
                return(0);
            }

            // marks arrays as visited (will be always restored to false value before return):
            x.Visited = true;
            y.Visited = true;

            // it will be more effective to implement OrderedHashtable.ToOrderedList method and use it here (in future version):
            sorted_x = x.DeepCopy();
            sorted_x.Sort(KeyComparer.ArrayKeys);
            sorted_y = y.DeepCopy();
            sorted_y.Sort(KeyComparer.ArrayKeys);

            var iter_x = sorted_x.GetFastEnumerator();
            var iter_y = sorted_y.GetFastEnumerator();

            result = 0;

            try
            {
                // compares corresponding elements (keys first values then):
                while (iter_x.MoveNext())
                {
                    iter_y.MoveNext();

                    // compares keys:
                    result = iter_x.CurrentKey.CompareTo(iter_y.CurrentKey);
                    if (result != 0)
                    {
                        break;
                    }

                    // dereferences childs if they are references:
                    var child_x = iter_x.CurrentValue.GetValue();
                    var child_y = iter_y.CurrentValue.GetValue();

                    // compares values:
                    if ((array_x = child_x.ArrayOrNull()) != null)
                    {
                        if ((array_y = child_y.ArrayOrNull()) != null)
                        {
                            // at least one child has not been visited yet => continue with recursion:
                            if (!array_x.Visited || !array_y.Visited)
                            {
                                result = CompareArrays(array_x, array_y, comparer, out incomparable);
                            }
                            else
                            {
                                incomparable = true;
                            }

                            // infinity recursion has been detected:
                            if (incomparable)
                            {
                                break;
                            }
                        }
                        else
                        {
                            // compares an array with a non-array:
                            array_x.Compare(child_y, comparer);
                        }
                    }
                    else
                    {
                        // compares unknown item with a non-array:
                        result = -comparer.Compare(child_y, child_x);
                    }

                    if (result != 0)
                    {
                        break;
                    }
                } // while
            }
            finally
            {
                x.Visited = false;
                y.Visited = false;
            }
            return(result);
        }
Пример #4
0
        /// <remarks>Performs deep copy of array, return array with replacements.</remarks>
        internal static PhpArray ArrayReplaceImpl(PhpArray array, PhpArray[] arrays, bool recursive)
        {
            PhpArray result = array.DeepCopy();

            if (arrays != null)
            {
                for (int i = 0; i < arrays.Length; i++)
                {
                    ArrayReplaceImpl(result, arrays[i], recursive);
                }
            }

            //// if called by PHP language then all items in the result should be in place deeply copied:
            //result.InplaceCopyOnReturn = true;
            return result;
        }