CloneSet988


Previous CloneSetNext CloneSetBack to Main Report
Clone
Mass
Clones in
CloneSet
Parameter
Count
Clone
Similarity
Syntax Category
[Sequence Length]
28320.964namespace_member_declarations
Clone AbstractionParameter Bindings
Clone Instance
(Click to see clone)
Line CountSource Line
Source File
1285
src/Iesi.Collections/HashedSet.cs
2336
src/Iesi.Collections/HybridSet.cs
3326
src/Iesi.Collections/ListSet.cs
Clone Instance
1
Line Count
28
Source Line
5
Source File
src/Iesi.Collections/HashedSet.cs

namespace Iesi.Collections
{
        /// <summary>
        /// Implements a <c>Set</c> based on a hash table.  This will give the best lookup, add, and remove
        /// performance for very large data-sets, but iteration will occur in no particular order.
        /// </summary>
        [Serializable]
        public class HashedSet : DictionarySet
        {
                /// <summary>
                /// Creates a new set instance based on a hash table.
                /// </summary>
                public HashedSet()
                {
                        InternalDictionary = new Hashtable();
                }

                /// <summary>
                /// Creates a new set instance based on a hash table and
                /// initializes it based on a collection of elements.
                /// </summary>
                /// <param name="initialValues">A collection of elements that defines the initial set contents.</param>
                public HashedSet(ICollection initialValues) : this()
                {
                        this.AddAll(initialValues);
                }

        }
}


Clone Instance
2
Line Count
33
Source Line
6
Source File
src/Iesi.Collections/HybridSet.cs

namespace Iesi.Collections
{
        /// <summary>
        /// Implements a <c>Set</c> that automatically changes from a list to a hash table
        /// when the size reaches a certain threshold.  This is good if you are unsure about
        /// whether you data-set will be tiny or huge.  Because this uses a dual implementation,
        /// iteration order is not guaranteed!
        /// </summary>
        [Serializable]
        public class HybridSet : DictionarySet
        {
                /// <summary>
                /// Creates a new set instance based on either a list or a hash table, depending on which 
                /// will be more efficient based on the data-set size.
                /// </summary>
                public HybridSet()
                {
                        InternalDictionary = new HybridDictionary();
                }


                /// <summary>
                /// Creates a new set instance based on either a list or a hash table, depending on which 
                /// will be more efficient based on the data-set size, and
                /// initializes it based on a collection of elements.
                /// </summary>
                /// <param name="initialValues">A collection of elements that defines the initial set contents.</param>
                public HybridSet(ICollection initialValues) : this()
                {
                        this.AddAll(initialValues);
                }

        }
}


Clone Instance
3
Line Count
32
Source Line
6
Source File
src/Iesi.Collections/ListSet.cs

namespace Iesi.Collections
{
        /// <summary>
        /// Implements a <c>Set</c> based on a list.  Performance is much better for very small lists 
        /// than either <c>HashedSet</c> or <c>SortedSet</c>.  However, performance degrades rapidly as 
        /// the data-set gets bigger.  Use a <c>HybridSet</c> instead if you are not sure your data-set
        /// will always remain very small.  Iteration produces elements in the order they were added.
        /// However, element order is not guaranteed to be maintained by the various <c>Set</c>
        /// mathematical operators.  
        /// </summary>
        [Serializable]
        public class ListSet : DictionarySet
        {
                /// <summary>
                /// Creates a new set instance based on a list.
                /// </summary>
                public ListSet()
                {
                        InternalDictionary = new ListDictionary();
                }

                /// <summary>
                /// Creates a new set instance based on a list and
                /// initializes it based on a collection of elements.
                /// </summary>
                /// <param name="initialValues">A collection of elements that defines the initial set contents.</param>
                public ListSet(ICollection initialValues) : this()
                {
                        this.AddAll(initialValues);
                }

        }
}


Clone AbstractionParameter Count: 2Parameter Bindings

namespace Iesi.Collections
{
   /// <summary>
   /// Implements a <c>Set</c> based on a hash table.  This will give the best lookup, add, and remove
   /// performance for very large data-sets, but iteration will occur in no particular order.
   /// Implements a <c>Set</c> that automatically changes from a list to a hash table
   /// when the size reaches a certain threshold.  This is good if you are unsure about
   /// whether you data-set will be tiny or huge.  Because this uses a dual implementation,
   /// iteration order is not guaranteed!
   /// Implements a <c>Set</c> based on a list.  Performance is much better for very small lists 
   /// than either <c>HashedSet</c> or <c>SortedSet</c>.  However, performance degrades rapidly as 
   /// the data-set gets bigger.  Use a <c>HybridSet</c> instead if you are not sure your data-set
   /// will always remain very small.  Iteration produces elements in the order they were added.
   /// However, element order is not guaranteed to be maintained by the various <c>Set</c>
   /// mathematical operators.  
   /// </summary>
   [Serializable]
   public class [[#variable5e424340]]: DictionarySet
   {
      /// <summary>
      /// Creates a new set instance based on a hash table.
      /// Creates a new set instance based on either a list or a hash table, depending on which 
      /// will be more efficient based on the data-set size.
      /// Creates a new set instance based on a list.
      /// </summary>
      public [[#variable5e424340]]()
      {
         InternalDictionary = new [[#variable5e4242c0]]();
      }

      /// <summary>
      /// Creates a new set instance based on a hash table and
      /// Creates a new set instance based on either a list or a hash table, depending on which 
      /// will be more efficient based on the data-set size, and
      /// Creates a new set instance based on a list and
      /// initializes it based on a collection of elements.
      /// </summary>
      /// <param name="initialValues">A collection of elements that defines the initial set contents.</param>
      public [[#variable5e424340]](ICollection initialValues): this()
      {
         this.AddAll(initialValues);
      }

   }
}
 

CloneAbstraction
Parameter Bindings
Parameter
Index
Clone
Instance
Parameter
Name
Value
11[[#5e424340]]
HashedSet 
12[[#5e424340]]
HybridSet 
13[[#5e424340]]
ListSet 
21[[#5e4242c0]]
Hashtable 
22[[#5e4242c0]]
HybridDictionary 
23[[#5e4242c0]]
ListDictionary