openscattertable.cs

Data Structures and Algorithms with Object-Oriented Design Patterns in C# 这本书的范例代码dll自己反编译的source

namespace Opus6
{
    using System;
    using System.Collections;
    using System.Runtime.InteropServices;

    [Copyright("Copyright (c) 2001 by Bruno R. Preiss, P.Eng."), Version("$Id: OpenScatterTable.cs,v 1.5 2001/10/28 19:50:09 brpreiss Exp $")]
    public class OpenScatterTable : AbstractHashTable
    {
        public OpenScatterTable(int length)
        {
            this.array = new Opus6.OpenScatterTable.Entry[length];
            for (int num1 = 0; num1 < length; num1++)
            {
                this.array[num1] = new Opus6.OpenScatterTable.Entry(EntryState.EMPTY, null);
            }
        }

        public override void Accept(Visitor visitor)
        {
            for (int num1 = 0; num1 < this.Length; num1++)
            {
                if (this.array[num1].state == EntryState.OCCUPIED)
                {
                    visitor.Visit(this.array[num1].obj);
                    if (visitor.IsDone)
                    {
                        return;
                    }
                }
            }
        }

        protected static int C(int i)
        {
            return i;
        }

        public override int CompareTo(object arg)
        {
            throw new MethodNotImplementedException();
        }

        public override ComparableObject Find(ComparableObject obj)
        {
            int num1 = this.FindMatch(obj);
            if (num1 >= 0)
            {
                return this.array[num1].obj;
            }
            return null;
        }

        protected int FindInstance(ComparableObject obj)
        {
            int num1 = base.H(obj);
            for (int num2 = 0; num2 < this.Length; num2++)
            {
                int num3 = (num1 + OpenScatterTable.C(num2)) % this.Length;
                if (this.array[num3].state == EntryState.EMPTY)
                {
                    break;
                }
                if ((this.array[num3].state == EntryState.OCCUPIED) && (obj == this.array[num3].obj))
                {
                    return num3;
                }
            }
            return -1;
        }

        protected int FindMatch(ComparableObject obj)
        {
            int num1 = base.H(obj);
            for (int num2 = 0; num2 < this.Length; num2++)
            {
                int num3 = (num1 + OpenScatterTable.C(num2)) % this.Length;
                if (this.array[num3].state == EntryState.EMPTY)
                {
                    break;
                }
                if ((this.array[num3].state == EntryState.OCCUPIED) && (obj == this.array[num3].obj))
                {
                    return num3;
                }
            }
            return -1;
        }

        protected int FindUnoccupied(object obj)
        {
            int num1 = base.H(obj);
            for (int num2 = 0; num2 < (base.count + 1); num2++)
            {
                int num3 = (num1 + OpenScatterTable.C(num2)) % this.Length;
                if (this.array[num3].state != EntryState.OCCUPIED)
                {
                    return num3;
                }
            }
            throw new ContainerFullException();
        }

        public override IEnumerator GetEnumerator()
        {
            return new Opus6.OpenScatterTable.Enumerator(this);
        }

        public override void Insert(ComparableObject obj)
        {
            if (base.count == this.Length)
            {
                throw new ContainerFullException();
            }
            int num1 = this.FindUnoccupied(obj);
            this.array[num1] = new Opus6.OpenScatterTable.Entry(EntryState.OCCUPIED, obj);
            base.count++;
        }

        public override bool IsMember(ComparableObject obj)
        {
            return (this.FindInstance(obj) >= 0);
        }

        public static void Main()
        {
            Opus6.Console.WriteLine("OpenScatterTable Test");
            HashTable table1 = new OpenScatterTable(0x39);
            AbstractHashTable.TestHashTable(table1);
        }

        public override void Purge()
        {
            for (int num1 = 0; num1 < this.Length; num1++)
            {
                this.array[num1] = new Opus6.OpenScatterTable.Entry(EntryState.EMPTY, null);
            }
            base.count = 0;
        }

        public override void Withdraw(ComparableObject obj)
        {
            if (base.count == 0)
            {
                throw new ContainerEmptyException();
            }
            int num1 = this.FindInstance(obj);
            if (num1 < 0)
            {
                throw new ArgumentException("object not found");
            }
            this.array[num1] = new Opus6.OpenScatterTable.Entry(EntryState.DELETED, null);
            base.count--;
        }


        public override bool IsFull
        {
            get
            {
                return (base.count == this.Length);
            }
        }

        public override int Length
        {
            get
            {
                return this.array.Length;
            }
        }


        protected Opus6.OpenScatterTable.Entry[] array;


        [StructLayout(LayoutKind.Sequential)]
        protected struct Entry
        {
            internal OpenScatterTable.EntryState state;
            internal ComparableObject obj;
            internal Entry(OpenScatterTable.EntryState state, ComparableObject obj)
            {
                this.state = state;
                this.obj = obj;
            }

        }

        protected enum EntryState
        {
            EMPTY,
            OCCUPIED,
            DELETED
        }

        private class Enumerator : IEnumerator
        {
            internal Enumerator(OpenScatterTable table)
            {
                this.position = 1;
                this.table = table;
            }

            public bool MoveNext()
            {
                this.position++;
                while (this.position < this.table.Length)
                {
                    if (this.table.array[this.position].state == OpenScatterTable.EntryState.OCCUPIED)
                    {
                        break;
                    }
                    this.position++;
                }
                if (this.position == this.table.Length)
                {
                    this.position = -1;
                }
                return (this.position > 0);
            }

            public void Reset()
            {
                this.position = -1;
            }


            public object Current
            {
                get
                {
                    if (this.position < 0)
                    {
                        throw new InvalidOperationException();
                    }
                    return this.table.array[this.position].obj;
                }
            }


            private int position;
            private OpenScatterTable table;
        }
    }
}