dotgnu-pnet-commits
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Dotgnu-pnet-commits] CVS: pnetlib/Generics FixedSizeCollection.cs,NONE


From: Rhys Weatherley <address@hidden>
Subject: [Dotgnu-pnet-commits] CVS: pnetlib/Generics FixedSizeCollection.cs,NONE,1.1 FixedSizeDeque.cs,NONE,1.1 FixedSizeDictIterator.cs,NONE,1.1 FixedSizeDictionary.cs,NONE,1.1 FixedSizeIterator.cs,NONE,1.1 FixedSizeList.cs,NONE,1.1 FixedSizeListIterator.cs,NONE,1.1 FixedSizeQueue.cs,NONE,1.1 FixedSizeStack.cs,NONE,1.1 ArrayList.cs,1.3,1.4 ReadOnlyCollection.cs,1.1,1.2 ReadOnlyDeque.cs,1.1,1.2 ReadOnlyDictIterator.cs,1.1,1.2 ReadOnlyDictionary.cs,1.1,1.2 ReadOnlyIterator.cs,1.2,1.3 ReadOnlyList.cs,1.1,1.2 ReadOnlyListIterator.cs,1.1,1.2 ReadOnlyQueue.cs,1.1,1.2 ReadOnlyStack.cs,1.1,1.2 ReverseIterator.cs,1.2,1.3 SynchronizedDictIterator.cs,1.2,1.3 SynchronizedIterator.cs,1.2,1.3 SynchronizedListIterator.cs,1.1,1.2
Date: Mon, 24 Feb 2003 02:21:05 -0500

Update of /cvsroot/dotgnu-pnet/pnetlib/Generics
In directory subversions:/tmp/cvs-serv26376/Generics

Modified Files:
        ArrayList.cs ReadOnlyCollection.cs ReadOnlyDeque.cs 
        ReadOnlyDictIterator.cs ReadOnlyDictionary.cs 
        ReadOnlyIterator.cs ReadOnlyList.cs ReadOnlyListIterator.cs 
        ReadOnlyQueue.cs ReadOnlyStack.cs ReverseIterator.cs 
        SynchronizedDictIterator.cs SynchronizedIterator.cs 
        SynchronizedListIterator.cs 
Added Files:
        FixedSizeCollection.cs FixedSizeDeque.cs 
        FixedSizeDictIterator.cs FixedSizeDictionary.cs 
        FixedSizeIterator.cs FixedSizeList.cs FixedSizeListIterator.cs 
        FixedSizeQueue.cs FixedSizeStack.cs 
Log Message:


Add fixed-size wrapper classes to replace the concrete-specific
"FixedSize" methods; fix Copyright messages.


--- NEW FILE ---
/*
 * FixedSizeCollection.cs - Wrap a collection to make it fixed-size.
 *
 * Copyright (c) 2003  Southern Storm Software, Pty Ltd
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

namespace Generics
{

using System;

public class FixedSizeCollection<T> : ICollection<T>, ICloneable
{
        // Internal state.
        protected ICollection<T> coll;

        // Constructor.
        public FixedSizeCollection(ICollection<T> coll)
                        {
                                if(coll == null)
                                {
                                        throw new ArgumentNullException("coll");
                                }
                                this.coll = coll;
                        }

        // Implement the ICollection<T> interface.
        public void CopyTo(T[] array, int index)
                        {
                                coll.CopyTo(array, index);
                        }
        public int Count
                        {
                                get
                                {
                                        return coll.Count;
                                }
                        }
        public bool IsSynchronized
                        {
                                get
                                {
                                        return coll.IsSynchronized;
                                }
                        }
        public Object SyncRoot
                        {
                                get
                                {
                                        return coll.SyncRoot;
                                }
                        }

        // Implement the IIterable<T> interface.
        public IIterator<T> GetIterator()
                        {
                                return new 
FixedSizeIterator<T>(coll.GetIterator());
                        }

        // Implement the ICloneable interface.
        public virtual Object Clone()
                        {
                                if(coll is ICloneable)
                                {
                                        return new FixedSizeCollection<T>
                                                
((ICollection<T>)(((ICloneable)coll).Clone()));
                                }
                                else
                                {
                                        throw new InvalidOperationException
                                                (S._("Invalid_NotCloneable"));
                                }
                        }

}; // class FixedSizeCollection<T>

}; // namespace Generics

--- NEW FILE ---
/*
 * FixedSizeDeque.cs - Wrap a deque to make it fixed-size.
 *
 * Copyright (c) 2003  Southern Storm Software, Pty Ltd
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

namespace Generics
{

using System;

public class FixedSizeDeque<T> : FixedSizeCollection<T>, IDeque<T>
{
        // Internal state.
        protected IDeque<T> deque;

        // Constructor.
        public FixedSizeDeque(IDeque<T> deque) : base(deque)
                        {
                                this.deque = deque;
                        }

        // Implement the IDeque<T> interface.
        public void PushFront(T value)
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public void PushBack(T value)
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public T PopFront()
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public T PopBack()
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public T PeekFront()
                        {
                                return deque.PeekFront();
                        }
        public T PeekEnd()
                        {
                                return deque.PeekEnd();
                        }
        public T[] ToArray()
                        {
                                return deque.ToArray();
                        }
        public bool IsFixedSize
                        {
                                get
                                {
                                        return true;
                                }
                        }
        public bool IsReadOnly
                        {
                                get
                                {
                                        return deque.IsReadOnly;
                                }
                        }

        // Implement the ICloneable interface.
        public override Object Clone()
                        {
                                if(deque is ICloneable)
                                {
                                        return new FixedSizeDeque<T>
                                                
((IDeque<T>)(((ICloneable)deque).Clone()));
                                }
                                else
                                {
                                        throw new InvalidOperationException
                                                (S._("Invalid_NotCloneable"));
                                }
                        }

}; // class FixedSizeDeque<T>

}; // namespace Generics

--- NEW FILE ---
/*
 * FixedSizeDictIterator.cs - Wrap an iterator to make it fixed-size.
 *
 * Copyright (c) 2003  Southern Storm Software, Pty Ltd
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

namespace Generics
{

using System;

internal sealed class FixedSizeDictIterator<KeyT, ValueT>
        : IDictionaryIterator<KeyT, ValueT>
{
        // Internal state.
        protected IDictionaryIterator<KeyT, ValueT> iterator;

        // Constructor.
        public FixedSizeDictIterator(IDictionaryIterator<KeyT, ValueT> iterator)
                        {
                                this.iterator = iterator;
                        }

        // Implement the IIterator<DictionaryEntry<KeyT, ValueT>> interface.
        public bool MoveNext()
                        {
                                return iterator.MoveNext();
                        }
        public void Reset()
                        {
                                iterator.Reset();
                        }
        public void Remove()
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public DictionaryEntry<KeyT, ValueT> Current
                        {
                                get
                                {
                                        return iterator.Current;
                                }
                        }

        // Implement the IDictionaryIterator<KeyT, ValueT> interface.
        public DictionaryEntry<KeyT, ValueT> Entry
                        {
                                get
                                {
                                        return iterator.Entry;
                                }
                        }
        public KeyT Key
                        {
                                get
                                {
                                        return iterator.Key;
                                }
                        }
        public ValueT Value
                        {
                                get
                                {
                                        return iterator.Value;
                                }
                                set
                                {
                                        iterator.Value = value;
                                }
                        }

}; // class FixedSizeDictIterator<KeyT, ValueT>

}; // namespace Generics

--- NEW FILE ---
/*
 * FixedSizeDictionary.cs - Wrap a dictionary to make it fixed-size.
 *
 * Copyright (c) 2003  Southern Storm Software, Pty Ltd
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

namespace Generics
{

using System;

public class FixedSizeDictionary<KeyT, ValueT>
        : FixedSizeCollection< DictionaryEntry<KeyT, ValueT> >,
          IDictionary<KeyT, ValueT>
{
        // Internal state.
        protected IDictionary<KeyT, ValueT> dict;

        // Constructor.
        public FixedSizeDictionary(IDictionary<KeyT, ValueT> dict) : base(dict)
                        {
                                this.dict = dict;
                        }

        // Implement the IDictionary<KeyT, ValueT> interface.
        public void Add(KeyT key, ValueT value)
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public void Clear()
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public bool Contains(KeyT key)
                        {
                                return dict.Contains(key);
                        }
        public new IDictionaryIterator<KeyT, ValueT> GetIterator()
                        {
                                return new FixedSizeDictIterator<KeyT, ValueT>
                                        (dict.GetIterator());
                        }
        public void Remove(KeyT key)
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public bool IsFixedSize
                        {
                                get
                                {
                                        return true;
                                }
                        }
        public bool IsReadOnly
                        {
                                get
                                {
                                        return dict.IsReadOnly;
                                }
                        }
        public ValueT this[KeyT key]
                        {
                                get
                                {
                                        return dict[key];
                                }
                                set
                                {
                                        dict[key] = value;
                                }
                        }
        public ICollection<KeyT> Keys
                        {
                                get
                                {
                                        return new 
FixedSizeCollection<KeyT>(dict.Keys);
                                }
                        }
        public ICollection<ValueT> Values
                        {
                                get
                                {
                                        return new 
FixedSizeCollection<ValueT>(dict.Values);
                                }
                        }

        // Implement the ICloneable interface.
        public override Object Clone()
                        {
                                if(dict is ICloneable)
                                {
                                        return new FixedSizeDictionary<T>
                                                
((IDictionary<T>)(((ICloneable)dict).Clone()));
                                }
                                else
                                {
                                        throw new InvalidOperationException
                                                (S._("Invalid_NotCloneable"));
                                }
                        }

}; // class FixedSizeDictionary<KeyT, ValueT>

}; // namespace Generics

--- NEW FILE ---
/*
 * FixedSizeIterator.cs - Wrap an iterator to make it fixed-size.
 *
 * Copyright (c) 2003  Southern Storm Software, Pty Ltd
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

namespace Generics
{

using System;

internal sealed class FixedSizeIterator<T> : IIterator<T>
{
        // Internal state.
        protected IIterator<T> iterator;

        // Constructor.
        public FixedSizeIterator(IIterator<T> iterator)
                        {
                                this.iterator = iterator;
                        }

        // Implement the IIterator<T> interface.
        public bool MoveNext()
                        {
                                return iterator.MoveNext();
                        }
        public void Reset()
                        {
                                iterator.Reset();
                        }
        public void Remove()
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public T Current
                        {
                                get
                                {
                                        return iterator.Current;
                                }
                        }

}; // class FixedSizeIterator<T>

}; // namespace Generics

--- NEW FILE ---
/*
 * FixedSizeList.cs - Wrap a list to make it fixed-size.
 *
 * Copyright (c) 2003  Southern Storm Software, Pty Ltd
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

namespace Generics
{

using System;

public class FixedSizeList<T> : FixedSizeCollection<T>, IList<T>
{
        // Internal state.
        protected IList<T> list;

        // Constructor.
        public FixedSizeList(IList<T> list) : base(list)
                        {
                                this.list = list;
                        }

        // Implement the IList<T> interface.
        public int Add(T value)
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public void Clear()
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public bool Contains(T value)
                        {
                                return list.Contains(value);
                        }
        public new IListIterator<T> GetIterator()
                        {
                                return new 
FixedSizeListIterator<T>(list.GetIterator());
                        }
        public int IndexOf(T value)
                        {
                                return list.IndexOf(value);
                        }
        public void Insert(int index, T value)
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public void Remove(T value)
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public void RemoveAt(int index)
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public bool IsFixedSize
                        {
                                get
                                {
                                        return true;
                                }
                        }
        public bool IsReadOnly
                        {
                                get
                                {
                                        return list.IsReadOnly;
                                }
                        }
        public T this[int index]
                        {
                                get
                                {
                                        return list[index];
                                }
                                set
                                {
                                        list[index] = value;
                                }
                        }

        // Implement the ICloneable interface.
        public override Object Clone()
                        {
                                if(list is ICloneable)
                                {
                                        return new FixedSizeList<T>
                                                
((IList<T>)(((ICloneable)list).Clone()));
                                }
                                else
                                {
                                        throw new InvalidOperationException
                                                (S._("Invalid_NotCloneable"));
                                }
                        }

}; // class FixedSizeList<T>

}; // namespace Generics

--- NEW FILE ---
/*
 * FixedSizeIterator.cs - Wrap a list iterator to make it fixed-size.
 *
 * Copyright (c) 2003  Southern Storm Software, Pty Ltd
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

namespace Generics
{

using System;

internal sealed class FixedSizeListIterator<T> : IListIterator<T>
{
        // Internal state.
        protected IListIterator<T> iterator;

        // Constructor.
        public FixedSizeListIterator(IListIterator<T> iterator)
                        {
                                this.iterator = iterator;
                        }

        // Implement the IIterator<T> interface.
        public bool MoveNext()
                        {
                                return iterator.MoveNext();
                        }
        public void Reset()
                        {
                                iterator.Reset();
                        }
        public void Remove()
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        T IIterator<T>.Current
                        {
                                get
                                {
                                        return ((IIterator<T>)iterator).Current;
                                }
                        }

        // Implement the IListIterator<T> interface.
        public bool MovePrev()
                        {
                                return iterator.MovePrev();
                        }
        public int Position
                        {
                                get
                                {
                                        return iterator.Position;
                                }
                        }
        public T Current
                        {
                                get
                                {
                                        return iterator.Current;
                                }
                                set
                                {
                                        iterator.Current = value;
                                }
                        }

}; // class FixedSizeListIterator<T>

}; // namespace Generics

--- NEW FILE ---
/*
 * FixedSizeQueue.cs - Wrap a queue to make it fixed-size.
 *
 * Copyright (c) 2003  Southern Storm Software, Pty Ltd
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

namespace Generics
{

using System;

public class FixedSizeQueue<T> : FixedSizeCollection<T>, IQueue<T>
{
        // Internal state.
        protected IQueue<T> queue;

        // Constructor.
        public FixedSizeQueue(IQueue<T> queue) : base(queue)
                        {
                                this.queue = queue;
                        }

        // Implement the IQueue<T> interface.
        public void Enqueue(T value)
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public T Dequeue()
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public T Peek()
                        {
                                return queue.Peek();
                        }
        public T[] ToArray()
                        {
                                return queue.ToArray();
                        }
        public bool IsFixedSize
                        {
                                get
                                {
                                        return true;
                                }
                        }
        public bool IsReadOnly
                        {
                                get
                                {
                                        return queue.IsReadOnly;
                                }
                        }

        // Implement the ICloneable interface.
        public override Object Clone()
                        {
                                if(queue is ICloneable)
                                {
                                        return new FixedSizeQueue<T>
                                                
((IQueue<T>)(((ICloneable)queue).Clone()));
                                }
                                else
                                {
                                        throw new InvalidOperationException
                                                (S._("Invalid_NotCloneable"));
                                }
                        }

}; // class FixedSizeQueue<T>

}; // namespace Generics

--- NEW FILE ---
/*
 * FixedSizeStack.cs - Wrap a stack to make it fixed-size.
 *
 * Copyright (c) 2003  Southern Storm Software, Pty Ltd
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

namespace Generics
{

using System;

public class FixedSizeStack<T> : FixedSizeCollection<T>, IStack<T>
{
        // Internal state.
        protected IStack<T> stack;

        // Constructor.
        public FixedSizeStack(IStack<T> stack) : base(stack)
                        {
                                this.stack = stack;
                        }

        // Implement the IStack<T> interface.
        public void Push(T value)
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public T Pop()
                        {
                                throw new InvalidOperationException
                                        (S._("NotSupp_FixedSizeCollection"));
                        }
        public T Peek()
                        {
                                return stack.Peek();
                        }
        public T[] ToArray()
                        {
                                return stack.ToArray();
                        }
        public bool IsFixedSize
                        {
                                get
                                {
                                        return true;
                                }
                        }
        public bool IsReadOnly
                        {
                                get
                                {
                                        return stack.IsReadOnly;
                                }
                        }

        // Implement the ICloneable interface.
        public override Object Clone()
                        {
                                if(stack is ICloneable)
                                {
                                        return new FixedSizeStack<T>
                                                
((IStack<T>)(((ICloneable)stack).Clone()));
                                }
                                else
                                {
                                        throw new InvalidOperationException
                                                (S._("Invalid_NotCloneable"));
                                }
                        }

}; // class FixedSizeStack<T>

}; // namespace Generics

Index: ArrayList.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/Generics/ArrayList.cs,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -r1.3 -r1.4
*** ArrayList.cs        24 Feb 2003 04:36:25 -0000      1.3
--- ArrayList.cs        24 Feb 2003 07:21:00 -0000      1.4
***************
*** 1201,1536 ****
        }; // class IListWrapper<T>
  
-       // Pass-through wrapper class that encapsulates another array list.
-       private class PassThroughWrapper<T> : ArrayList<T>
-       {
-               protected ArrayList<T> list;
- 
-               public PassThroughWrapper(ArrayList<T> list)
-                               {
-                                       this.list = list;
-                               }
- 
-               // Implement the IList interface.
-               public override int Add(T value)
-                               {
-                                       return list.Add(value);
-                               }
-               public override void Clear()
-                               {
-                                       list.Clear();
-                               }
-               public override bool Contains(T item)
-                               {
-                                       return list.Contains(item);
-                               }
-               public override int IndexOf(T value)
-                               {
-                                       return list.IndexOf(value);
-                               }
-               public override void Insert(int index, T value)
-                               {
-                                       list.Insert(index, value);
-                               }
-               public override void Remove(T value)
-                               {
-                                       list.Remove(value);
-                               }
-               public override void RemoveAt(int index)
-                               {
-                                       list.RemoveAt(index);
-                               }
-               public override bool IsFixedSize
-                               {
-                                       get
-                                       {
-                                               return list.IsFixedSize;
-                                       }
-                               }
-               public override bool IsReadOnly
-                               {
-                                       get
-                                       {
-                                               return list.IsReadOnly;
-                                       }
-                               }
-               public override T this[int index]
-                               {
-                                       get
-                                       {
-                                               return list[index];
-                                       }
-                                       set
-                                       {
-                                               list[index] = value;
-                                       }
-                               }
- 
-               // Range-related methods.
-               public override void AddRange(ICollection<T> c)
-                               {
-                                       list.AddRange(c);
-                               }
-               public override void InsertRange(int index, ICollection<T> c)
-                               {
-                                       list.InsertRange(index, c);
-                               }
-               public override void RemoveRange(int index, int count)
-                               {
-                                       list.RemoveRange(index, count);
-                               }
-               public override void SetRange(int index, ICollection<T> c)
-                               {
-                                       list.SetRange(index, c);
-                               }
- 
-               // Searching methods.
-               public override int BinarySearch(T value)
-                               {
-                                       return list.BinarySearch(value);
-                               }
-               public override int BinarySearch(T value, IComparer<T> comparer)
-                               {
-                                       return list.BinarySearch(value, 
comparer);
-                               }
-               public override int BinarySearch(int index, int count,
-                                                                            T 
value, IComparer<T> comparer)
-                               {
-                                       return list.BinarySearch(index, count, 
value, comparer);
-                               }
-               public override int IndexOf(T value, int startIndex)
-                               {
-                                       return list.IndexOf(value, startIndex);
-                               }
-               public override int IndexOf(T value, int startIndex, int count)
-                               {
-                                       return list.IndexOf(value, startIndex, 
count);
-                               }
-               public override int LastIndexOf(T value)
-                               {
-                                       return list.LastIndexOf(value);
-                               }
-               public override int LastIndexOf(T value, int startIndex)
-                               {
-                                       return list.LastIndexOf(value, 
startIndex);
-                               }
-               public override int LastIndexOf(T value, int startIndex, int 
count)
-                               {
-                                       return list.LastIndexOf(value, 
startIndex, count);
-                               }
- 
-               // Implement the ICollection<T> interface.
-               public override void CopyTo(T[] array, int arrayIndex)
-                               {
-                                       list.CopyTo(array, arrayIndex);
-                               }
-               public override int Count
-                               {
-                                       get
-                                       {
-                                               return list.count;
-                                       }
-                               }
-               public override bool IsSynchronized
-                               {
-                                       get
-                                       {
-                                               return list.IsSynchronized;
-                                       }
-                               }
-               public override Object SyncRoot
-                               {
-                                       get
-                                       {
-                                               return list.SyncRoot;
-                                       }
-                               }
- 
-               // Copy from this array list to another array.
-               public override void CopyTo(T[] array)
-                               {
-                                       list.CopyTo(array);
-                               }
-               public override void CopyTo(int index, T[] array,
-                                                                   int 
arrayIndex, int count)
-                               {
-                                       list.CopyTo(index, array, arrayIndex, 
count);
-                               }
- 
-               // Reverse the contents of this array list.
-               public override void Reverse()
-                               {
-                                       list.Reverse();
-                               }
-               public override void Reverse(int index, int count)
-                               {
-                                       list.Reverse(index, count);
-                               }
- 
-               // Sort the contents of this array list.
-               public override void Sort()
-                               {
-                                       list.Sort();
-                               }
-               public override void Sort(IComparer<T> comparer)
-                               {
-                                       list.Sort(comparer);
-                               }
-               public override void Sort(int index, int count, IComparer<T> 
comparer)
-                               {
-                                       list.Sort(index, count, comparer);
-                               }
- 
-               // Create an array that contains the elements of this array 
list.
-               public override T[] ToArray()
-                               {
-                                       return list.ToArray();
-                               }
-               public override Array ToArray(Type type)
-                               {
-                                       return list.ToArray(type);
-                               }
- 
-               // Trim the array list to its actual size.
-               public override void TrimToSize()
-                               {
-                                       list.TrimToSize();
-                               }
- 
-               // Get or set the current capacity of the array list.
-               public override int Capacity
-                               {
-                                       get
-                                       {
-                                               return list.Capacity;
-                                       }
-                                       set
-                                       {
-                                               list.Capacity = value;
-                                       }
-                               }
- 
-               // Get an iterator for this array list.
-               public override IListIterator<T> GetIterator()
-                               {
-                                       return list.GetIterator();
-                               }
-               public override IListIterator<T> GetIterator(int index, int 
count)
-                               {
-                                       return list.GetIterator(index, count);
-                               }
- 
-       }; // class PassThroughWrapper<T>
- 
-       // Adapt an array list to appear to have a fixed size.
-       public static ArrayList<T> FixedSize<T>(ArrayList<T> list)
-                       {
-                               if(list == null)
-                               {
-                                       throw new ArgumentNullException("list");
-                               }
-                               else if(list.IsFixedSize)
-                               {
-                                       return list;
-                               }
-                               else
-                               {
-                                       return new FixedSizeWrapper<T>(list);
-                               }
-                       }
- 
-       // Wrapper class for fixed size lists.
-       private class FixedSizeWrapper<T> : PassThroughWrapper<T>
-       {
-               public FixedSizeWrapper(ArrayList<T> list)
-                               : base(list)
-                               {
-                                       // Nothing to do here.
-                               }
- 
-               // Implement the IList interface.
-               public override int Add(T value)
-                               {
-                                       throw new NotSupportedException
-                                               
(S._("NotSupp_FixedSizeCollection"));
-                               }
-               public override void Clear()
-                               {
-                                       throw new NotSupportedException
-                                               
(S._("NotSupp_FixedSizeCollection"));
-                               }
-               public override void Insert(int index, T value)
-                               {
-                                       throw new NotSupportedException
-                                               
(S._("NotSupp_FixedSizeCollection"));
-                               }
-               public override void Remove(T value)
-                               {
-                                       throw new NotSupportedException
-                                               
(S._("NotSupp_FixedSizeCollection"));
-                               }
-               public override void RemoveAt(int index)
-                               {
-                                       throw new NotSupportedException
-                                               
(S._("NotSupp_FixedSizeCollection"));
-                               }
-               public override bool IsFixedSize
-                               {
-                                       get
-                                       {
-                                               return true;
-                                       }
-                               }
-               public override bool IsReadOnly
-                               {
-                                       get
-                                       {
-                                               return list.IsReadOnly;
-                                       }
-                               }
-               public override T this[int index]
-                               {
-                                       get
-                                       {
-                                               return list[index];
-                                       }
-                                       set
-                                       {
-                                               list[index] = value;
-                                       }
-                               }
- 
-               // Range-related methods.
-               public override void AddRange(ICollection<T> c)
-                               {
-                                       throw new NotSupportedException
-                                               
(S._("NotSupp_FixedSizeCollection"));
-                               }
-               public override void InsertRange(int index, ICollection c)
-                               {
-                                       throw new NotSupportedException
-                                               
(S._("NotSupp_FixedSizeCollection"));
-                               }
-               public override void RemoveRange(int index, int count)
-                               {
-                                       throw new NotSupportedException
-                                               
(S._("NotSupp_FixedSizeCollection"));
-                               }
- 
-               // Implement the ICloneable interface.
-               public override Object Clone()
-                               {
-                                       return new FixedSizeWrapper<T>
-                                               ((ArrayList<T>)(list.Clone()));
-                               }
- 
-               // Trim the array list to its actual size.
-               public override void TrimToSize()
-                               {
-                                       throw new NotSupportedException
-                                               (S. 
_("NotSupp_FixedSizeCollection"));
-                               }
- 
-       }; // class FixedSizeWrapper<T>
- 
        // Adapt an array list to get access to a sub-range.
        public virtual ArrayList<T> GetRange(int index, int count)
--- 1201,1204 ----
***************
*** 1807,1958 ****
  
        }; // class RangeWrapper<T>
- 
-       // Adapt an array list to appear to be read-only.
-       public static ArrayList<T> ReadOnly<T>(ArrayList<T> list)
-                       {
-                               if(list == null)
-                               {
-                                       throw new ArgumentNullException("list");
-                               }
-                               else if(list.IsReadOnly)
-                               {
-                                       return list;
-                               }
-                               else
-                               {
-                                       return new ReadOnlyWrapper<T>(list);
-                               }
-                       }
- 
-       // Wrapper class for read-only lists.
-       private class ReadOnlyWrapper<T> : PassThroughWrapper
-       {
-               public ReadOnlyWrapper(ArrayList<T> list)
-                               : base(list)
-                               {
-                                       // Nothing to do here.
-                               }
- 
-               // Implement the IList interface.
-               public override int Add(T value)
-                               {
-                                       throw new 
NotSupportedException(S._("NotSupp_ReadOnly"));
-                               }
-               public override void Clear()
-                               {
-                                       throw new 
NotSupportedException(S._("NotSupp_ReadOnly"));
-                               }
-               public override void Insert(int index, T value)
-                               {
-                                       throw new 
NotSupportedException(S._("NotSupp_ReadOnly"));
-                               }
-               public override void Remove(T value)
-                               {
-                                       throw new 
NotSupportedException(S._("NotSupp_ReadOnly"));
-                               }
-               public override void RemoveAt(int index)
-                               {
-                                       throw new 
NotSupportedException(S._("NotSupp_ReadOnly"));
-                               }
-               public override bool IsReadOnly
-                               {
-                                       get
-                                       {
-                                               return true;
-                                       }
-                               }
-               public override T this[int index]
-                               {
-                                       get
-                                       {
-                                               return list[index];
-                                       }
-                                       set
-                                       {
-                                               throw new NotSupportedException
-                                                       
(S._("NotSupp_ReadOnly"));
-                                       }
-                               }
- 
-               // Range-related methods.
-               public override void AddRange(ICollection<T> c)
-                               {
-                                       throw new 
NotSupportedException(S._("NotSupp_ReadOnly"));
-                               }
-               public override void InsertRange(int index, ICollection<T> c)
-                               {
-                                       throw new 
NotSupportedException(S._("NotSupp_ReadOnly"));
-                               }
-               public override void RemoveRange(int index, int count)
-                               {
-                                       throw new 
NotSupportedException(S._("NotSupp_ReadOnly"));
-                               }
-               public override void SetRange(int index, ICollection<T> c)
-                               {
-                                       throw new 
NotSupportedException(S._("NotSupp_ReadOnly"));
-                               }
- 
-               // Implement the ICloneable interface.
-               public override Object Clone()
-                               {
-                                       return new 
ReadOnlyWrapper<T>((ArrayList<T>)(list.Clone()));
-                               }
- 
-               // Reverse the contents of this array list.
-               public override void Reverse()
-                               {
-                                       throw new 
NotSupportedException(S._("NotSupp_ReadOnly"));
-                               }
-               public override void Reverse(int index, int count)
-                               {
-                                       throw new 
NotSupportedException(S._("NotSupp_ReadOnly"));
-                               }
- 
-               // Sort the contents of this array list.
-               public override void Sort()
-                               {
-                                       throw new 
NotSupportedException(S._("NotSupp_ReadOnly"));
-                               }
-               public override void Sort(IComparer<T> comparer)
-                               {
-                                       throw new 
NotSupportedException(S._("NotSupp_ReadOnly"));
-                               }
-               public override void Sort(int index, int count, IComparer<T> 
comparer)
-                               {
-                                       throw new 
NotSupportedException(S._("NotSupp_ReadOnly"));
-                               }
- 
-               // Trim the array list to its actual size.
-               public override void TrimToSize()
-                               {
-                                       throw new 
NotSupportedException(S._("NotSupp_ReadOnly"));
-                               }
- 
-               // Get or set the current capacity of the array list.
-               public override int Capacity
-                               {
-                                       get
-                                       {
-                                               return list.Capacity;
-                                       }
-                                       set
-                                       {
-                                               throw new NotSupportedException
-                                                       
(S._("NotSupp_ReadOnly"));
-                                       }
-                               }
- 
-               // Get an iterator for this array list.
-               public override IListIterator<T> GetIterator()
-                               {
-                                       return new 
ReadOnlyListIterator<T>(list.GetIterator());
-                               }
-               public override IListIterator<T> GetIterator(int index, int 
count)
-                               {
-                                       return new ReadOnlyListIterator<T>
-                                               (list.GetIterator(index, 
count));
-                               }
- 
-       }; // class ReadOnlyWrapper<T>
  
        // Adapt an array list to appear to be synchronized
--- 1475,1478 ----

Index: ReadOnlyCollection.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/Generics/ReadOnlyCollection.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** ReadOnlyCollection.cs       24 Feb 2003 06:56:27 -0000      1.1
--- ReadOnlyCollection.cs       24 Feb 2003 07:21:00 -0000      1.2
***************
*** 2,20 ****
   * ReadOnlyCollection.cs - Wrap a collection to make it read-only.
   *
!  * Copyright (C) 2003  Southern Storm Software, Pty Ltd.
   *
!  * This program is free software; you can redistribute it and/or modify
!  * it under the terms of the GNU General Public License as published by
!  * the Free Software Foundation; either version 2 of the License, or
!  * (at your option) any later version.
   *
!  * This program is distributed in the hope that it will be useful,
!  * but WITHOUT ANY WARRANTY; without even the implied warranty of
!  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!  * GNU General Public License for more details.
   *
!  * You should have received a copy of the GNU General Public License
!  * along with this program; if not, write to the Free Software
!  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
--- 2,24 ----
   * ReadOnlyCollection.cs - Wrap a collection to make it read-only.
   *
!  * Copyright (c) 2003  Southern Storm Software, Pty Ltd
   *
!  * Permission is hereby granted, free of charge, to any person obtaining
!  * a copy of this software and associated documentation files (the 
"Software"),
!  * to deal in the Software without restriction, including without limitation
!  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
!  * and/or sell copies of the Software, and to permit persons to whom the
!  * Software is furnished to do so, subject to the following conditions:
   *
!  * The above copyright notice and this permission notice shall be included
!  * in all copies or substantial portions of the Software.
   *
!  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
!  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
!  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
!  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
!  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
!  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
!  * OTHER DEALINGS IN THE SOFTWARE.
   */
  

Index: ReadOnlyDeque.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/Generics/ReadOnlyDeque.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** ReadOnlyDeque.cs    24 Feb 2003 06:56:27 -0000      1.1
--- ReadOnlyDeque.cs    24 Feb 2003 07:21:00 -0000      1.2
***************
*** 2,20 ****
   * ReadOnlyDeque.cs - Wrap a deque to make it read-only.
   *
!  * Copyright (C) 2003  Southern Storm Software, Pty Ltd.
   *
!  * This program is free software; you can redistribute it and/or modify
!  * it under the terms of the GNU General Public License as published by
!  * the Free Software Foundation; either version 2 of the License, or
!  * (at your option) any later version.
   *
!  * This program is distributed in the hope that it will be useful,
!  * but WITHOUT ANY WARRANTY; without even the implied warranty of
!  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!  * GNU General Public License for more details.
   *
!  * You should have received a copy of the GNU General Public License
!  * along with this program; if not, write to the Free Software
!  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
--- 2,24 ----
   * ReadOnlyDeque.cs - Wrap a deque to make it read-only.
   *
!  * Copyright (c) 2003  Southern Storm Software, Pty Ltd
   *
!  * Permission is hereby granted, free of charge, to any person obtaining
!  * a copy of this software and associated documentation files (the 
"Software"),
!  * to deal in the Software without restriction, including without limitation
!  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
!  * and/or sell copies of the Software, and to permit persons to whom the
!  * Software is furnished to do so, subject to the following conditions:
   *
!  * The above copyright notice and this permission notice shall be included
!  * in all copies or substantial portions of the Software.
   *
!  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
!  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
!  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
!  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
!  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
!  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
!  * OTHER DEALINGS IN THE SOFTWARE.
   */
  

Index: ReadOnlyDictIterator.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/Generics/ReadOnlyDictIterator.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** ReadOnlyDictIterator.cs     24 Feb 2003 06:56:27 -0000      1.1
--- ReadOnlyDictIterator.cs     24 Feb 2003 07:21:00 -0000      1.2
***************
*** 2,20 ****
   * ReadOnlyDictIterator.cs - Wrap an iterator to make it read-only.
   *
!  * Copyright (C) 2003  Southern Storm Software, Pty Ltd.
   *
!  * This program is free software; you can redistribute it and/or modify
!  * it under the terms of the GNU General Public License as published by
!  * the Free Software Foundation; either version 2 of the License, or
!  * (at your option) any later version.
   *
!  * This program is distributed in the hope that it will be useful,
!  * but WITHOUT ANY WARRANTY; without even the implied warranty of
!  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!  * GNU General Public License for more details.
   *
!  * You should have received a copy of the GNU General Public License
!  * along with this program; if not, write to the Free Software
!  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
--- 2,24 ----
   * ReadOnlyDictIterator.cs - Wrap an iterator to make it read-only.
   *
!  * Copyright (c) 2003  Southern Storm Software, Pty Ltd
   *
!  * Permission is hereby granted, free of charge, to any person obtaining
!  * a copy of this software and associated documentation files (the 
"Software"),
!  * to deal in the Software without restriction, including without limitation
!  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
!  * and/or sell copies of the Software, and to permit persons to whom the
!  * Software is furnished to do so, subject to the following conditions:
   *
!  * The above copyright notice and this permission notice shall be included
!  * in all copies or substantial portions of the Software.
   *
!  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
!  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
!  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
!  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
!  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
!  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
!  * OTHER DEALINGS IN THE SOFTWARE.
   */
  

Index: ReadOnlyDictionary.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/Generics/ReadOnlyDictionary.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** ReadOnlyDictionary.cs       24 Feb 2003 06:56:27 -0000      1.1
--- ReadOnlyDictionary.cs       24 Feb 2003 07:21:00 -0000      1.2
***************
*** 2,20 ****
   * ReadOnlyDictionary.cs - Wrap a dictionary to make it read-only.
   *
!  * Copyright (C) 2003  Southern Storm Software, Pty Ltd.
   *
!  * This program is free software; you can redistribute it and/or modify
!  * it under the terms of the GNU General Public License as published by
!  * the Free Software Foundation; either version 2 of the License, or
!  * (at your option) any later version.
   *
!  * This program is distributed in the hope that it will be useful,
!  * but WITHOUT ANY WARRANTY; without even the implied warranty of
!  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!  * GNU General Public License for more details.
   *
!  * You should have received a copy of the GNU General Public License
!  * along with this program; if not, write to the Free Software
!  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
--- 2,24 ----
   * ReadOnlyDictionary.cs - Wrap a dictionary to make it read-only.
   *
!  * Copyright (c) 2003  Southern Storm Software, Pty Ltd
   *
!  * Permission is hereby granted, free of charge, to any person obtaining
!  * a copy of this software and associated documentation files (the 
"Software"),
!  * to deal in the Software without restriction, including without limitation
!  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
!  * and/or sell copies of the Software, and to permit persons to whom the
!  * Software is furnished to do so, subject to the following conditions:
   *
!  * The above copyright notice and this permission notice shall be included
!  * in all copies or substantial portions of the Software.
   *
!  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
!  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
!  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
!  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
!  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
!  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
!  * OTHER DEALINGS IN THE SOFTWARE.
   */
  

Index: ReadOnlyIterator.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/Generics/ReadOnlyIterator.cs,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -r1.2 -r1.3
*** ReadOnlyIterator.cs 24 Feb 2003 04:36:26 -0000      1.2
--- ReadOnlyIterator.cs 24 Feb 2003 07:21:00 -0000      1.3
***************
*** 2,20 ****
   * ReadOnlyIterator.cs - Wrap an iterator to make it read-only.
   *
!  * Copyright (C) 2003  Southern Storm Software, Pty Ltd.
   *
!  * This program is free software; you can redistribute it and/or modify
!  * it under the terms of the GNU General Public License as published by
!  * the Free Software Foundation; either version 2 of the License, or
!  * (at your option) any later version.
   *
!  * This program is distributed in the hope that it will be useful,
!  * but WITHOUT ANY WARRANTY; without even the implied warranty of
!  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!  * GNU General Public License for more details.
   *
!  * You should have received a copy of the GNU General Public License
!  * along with this program; if not, write to the Free Software
!  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
--- 2,24 ----
   * ReadOnlyIterator.cs - Wrap an iterator to make it read-only.
   *
!  * Copyright (c) 2003  Southern Storm Software, Pty Ltd
   *
!  * Permission is hereby granted, free of charge, to any person obtaining
!  * a copy of this software and associated documentation files (the 
"Software"),
!  * to deal in the Software without restriction, including without limitation
!  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
!  * and/or sell copies of the Software, and to permit persons to whom the
!  * Software is furnished to do so, subject to the following conditions:
   *
!  * The above copyright notice and this permission notice shall be included
!  * in all copies or substantial portions of the Software.
   *
!  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
!  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
!  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
!  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
!  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
!  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
!  * OTHER DEALINGS IN THE SOFTWARE.
   */
  

Index: ReadOnlyList.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/Generics/ReadOnlyList.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** ReadOnlyList.cs     24 Feb 2003 06:56:27 -0000      1.1
--- ReadOnlyList.cs     24 Feb 2003 07:21:00 -0000      1.2
***************
*** 2,20 ****
   * ReadOnlyList.cs - Wrap a list to make it read-only.
   *
!  * Copyright (C) 2003  Southern Storm Software, Pty Ltd.
   *
!  * This program is free software; you can redistribute it and/or modify
!  * it under the terms of the GNU General Public License as published by
!  * the Free Software Foundation; either version 2 of the License, or
!  * (at your option) any later version.
   *
!  * This program is distributed in the hope that it will be useful,
!  * but WITHOUT ANY WARRANTY; without even the implied warranty of
!  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!  * GNU General Public License for more details.
   *
!  * You should have received a copy of the GNU General Public License
!  * along with this program; if not, write to the Free Software
!  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
--- 2,24 ----
   * ReadOnlyList.cs - Wrap a list to make it read-only.
   *
!  * Copyright (c) 2003  Southern Storm Software, Pty Ltd
   *
!  * Permission is hereby granted, free of charge, to any person obtaining
!  * a copy of this software and associated documentation files (the 
"Software"),
!  * to deal in the Software without restriction, including without limitation
!  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
!  * and/or sell copies of the Software, and to permit persons to whom the
!  * Software is furnished to do so, subject to the following conditions:
   *
!  * The above copyright notice and this permission notice shall be included
!  * in all copies or substantial portions of the Software.
   *
!  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
!  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
!  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
!  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
!  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
!  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
!  * OTHER DEALINGS IN THE SOFTWARE.
   */
  
***************
*** 101,105 ****
                                {
                                        return new ReadOnlyList<T>
!                                               
((IDeque<T>)(((ICloneable)list).Clone()));
                                }
                                else
--- 105,109 ----
                                {
                                        return new ReadOnlyList<T>
!                                               
((IList<T>)(((ICloneable)list).Clone()));
                                }
                                else

Index: ReadOnlyListIterator.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/Generics/ReadOnlyListIterator.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** ReadOnlyListIterator.cs     24 Feb 2003 04:36:26 -0000      1.1
--- ReadOnlyListIterator.cs     24 Feb 2003 07:21:00 -0000      1.2
***************
*** 2,20 ****
   * ReadOnlyListIterator.cs - Wrap a list iterator to make it read-only.
   *
!  * Copyright (C) 2003  Southern Storm Software, Pty Ltd.
   *
!  * This program is free software; you can redistribute it and/or modify
!  * it under the terms of the GNU General Public License as published by
!  * the Free Software Foundation; either version 2 of the License, or
!  * (at your option) any later version.
   *
!  * This program is distributed in the hope that it will be useful,
!  * but WITHOUT ANY WARRANTY; without even the implied warranty of
!  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!  * GNU General Public License for more details.
   *
!  * You should have received a copy of the GNU General Public License
!  * along with this program; if not, write to the Free Software
!  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
--- 2,24 ----
   * ReadOnlyListIterator.cs - Wrap a list iterator to make it read-only.
   *
!  * Copyright (c) 2003  Southern Storm Software, Pty Ltd
   *
!  * Permission is hereby granted, free of charge, to any person obtaining
!  * a copy of this software and associated documentation files (the 
"Software"),
!  * to deal in the Software without restriction, including without limitation
!  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
!  * and/or sell copies of the Software, and to permit persons to whom the
!  * Software is furnished to do so, subject to the following conditions:
   *
!  * The above copyright notice and this permission notice shall be included
!  * in all copies or substantial portions of the Software.
   *
!  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
!  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
!  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
!  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
!  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
!  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
!  * OTHER DEALINGS IN THE SOFTWARE.
   */
  

Index: ReadOnlyQueue.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/Generics/ReadOnlyQueue.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** ReadOnlyQueue.cs    24 Feb 2003 06:56:27 -0000      1.1
--- ReadOnlyQueue.cs    24 Feb 2003 07:21:00 -0000      1.2
***************
*** 2,20 ****
   * ReadOnlyQueue.cs - Wrap a queue to make it read-only.
   *
!  * Copyright (C) 2003  Southern Storm Software, Pty Ltd.
   *
!  * This program is free software; you can redistribute it and/or modify
!  * it under the terms of the GNU General Public License as published by
!  * the Free Software Foundation; either version 2 of the License, or
!  * (at your option) any later version.
   *
!  * This program is distributed in the hope that it will be useful,
!  * but WITHOUT ANY WARRANTY; without even the implied warranty of
!  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!  * GNU General Public License for more details.
   *
!  * You should have received a copy of the GNU General Public License
!  * along with this program; if not, write to the Free Software
!  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
--- 2,24 ----
   * ReadOnlyQueue.cs - Wrap a queue to make it read-only.
   *
!  * Copyright (c) 2003  Southern Storm Software, Pty Ltd
   *
!  * Permission is hereby granted, free of charge, to any person obtaining
!  * a copy of this software and associated documentation files (the 
"Software"),
!  * to deal in the Software without restriction, including without limitation
!  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
!  * and/or sell copies of the Software, and to permit persons to whom the
!  * Software is furnished to do so, subject to the following conditions:
   *
!  * The above copyright notice and this permission notice shall be included
!  * in all copies or substantial portions of the Software.
   *
!  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
!  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
!  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
!  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
!  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
!  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
!  * OTHER DEALINGS IN THE SOFTWARE.
   */
  

Index: ReadOnlyStack.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/Generics/ReadOnlyStack.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** ReadOnlyStack.cs    24 Feb 2003 06:56:27 -0000      1.1
--- ReadOnlyStack.cs    24 Feb 2003 07:21:00 -0000      1.2
***************
*** 2,20 ****
   * ReadOnlyStack.cs - Wrap a stack to make it read-only.
   *
!  * Copyright (C) 2003  Southern Storm Software, Pty Ltd.
   *
!  * This program is free software; you can redistribute it and/or modify
!  * it under the terms of the GNU General Public License as published by
!  * the Free Software Foundation; either version 2 of the License, or
!  * (at your option) any later version.
   *
!  * This program is distributed in the hope that it will be useful,
!  * but WITHOUT ANY WARRANTY; without even the implied warranty of
!  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!  * GNU General Public License for more details.
   *
!  * You should have received a copy of the GNU General Public License
!  * along with this program; if not, write to the Free Software
!  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
--- 2,24 ----
   * ReadOnlyStack.cs - Wrap a stack to make it read-only.
   *
!  * Copyright (c) 2003  Southern Storm Software, Pty Ltd
   *
!  * Permission is hereby granted, free of charge, to any person obtaining
!  * a copy of this software and associated documentation files (the 
"Software"),
!  * to deal in the Software without restriction, including without limitation
!  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
!  * and/or sell copies of the Software, and to permit persons to whom the
!  * Software is furnished to do so, subject to the following conditions:
   *
!  * The above copyright notice and this permission notice shall be included
!  * in all copies or substantial portions of the Software.
   *
!  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
!  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
!  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
!  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
!  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
!  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
!  * OTHER DEALINGS IN THE SOFTWARE.
   */
  

Index: ReverseIterator.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/Generics/ReverseIterator.cs,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -r1.2 -r1.3
*** ReverseIterator.cs  24 Feb 2003 04:36:26 -0000      1.2
--- ReverseIterator.cs  24 Feb 2003 07:21:00 -0000      1.3
***************
*** 2,20 ****
   * ReverseIterator.cs - Wrap an iterator to reverse its traversal direction.
   *
!  * Copyright (C) 2003  Southern Storm Software, Pty Ltd.
   *
!  * This program is free software; you can redistribute it and/or modify
!  * it under the terms of the GNU General Public License as published by
!  * the Free Software Foundation; either version 2 of the License, or
!  * (at your option) any later version.
   *
!  * This program is distributed in the hope that it will be useful,
!  * but WITHOUT ANY WARRANTY; without even the implied warranty of
!  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!  * GNU General Public License for more details.
   *
!  * You should have received a copy of the GNU General Public License
!  * along with this program; if not, write to the Free Software
!  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
--- 2,24 ----
   * ReverseIterator.cs - Wrap an iterator to reverse its traversal direction.
   *
!  * Copyright (c) 2003  Southern Storm Software, Pty Ltd
   *
!  * Permission is hereby granted, free of charge, to any person obtaining
!  * a copy of this software and associated documentation files (the 
"Software"),
!  * to deal in the Software without restriction, including without limitation
!  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
!  * and/or sell copies of the Software, and to permit persons to whom the
!  * Software is furnished to do so, subject to the following conditions:
   *
!  * The above copyright notice and this permission notice shall be included
!  * in all copies or substantial portions of the Software.
   *
!  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
!  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
!  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
!  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
!  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
!  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
!  * OTHER DEALINGS IN THE SOFTWARE.
   */
  

Index: SynchronizedDictIterator.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/Generics/SynchronizedDictIterator.cs,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -r1.2 -r1.3
*** SynchronizedDictIterator.cs 24 Feb 2003 05:20:34 -0000      1.2
--- SynchronizedDictIterator.cs 24 Feb 2003 07:21:00 -0000      1.3
***************
*** 2,20 ****
   * SynchronizedDictIterator.cs - Wrap an iterator to synchronize it.
   *
!  * Copyright (C) 2003  Southern Storm Software, Pty Ltd.
   *
!  * This program is free software; you can redistribute it and/or modify
!  * it under the terms of the GNU General Public License as published by
!  * the Free Software Foundation; either version 2 of the License, or
!  * (at your option) any later version.
   *
!  * This program is distributed in the hope that it will be useful,
!  * but WITHOUT ANY WARRANTY; without even the implied warranty of
!  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!  * GNU General Public License for more details.
   *
!  * You should have received a copy of the GNU General Public License
!  * along with this program; if not, write to the Free Software
!  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
--- 2,24 ----
   * SynchronizedDictIterator.cs - Wrap an iterator to synchronize it.
   *
!  * Copyright (c) 2003  Southern Storm Software, Pty Ltd
   *
!  * Permission is hereby granted, free of charge, to any person obtaining
!  * a copy of this software and associated documentation files (the 
"Software"),
!  * to deal in the Software without restriction, including without limitation
!  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
!  * and/or sell copies of the Software, and to permit persons to whom the
!  * Software is furnished to do so, subject to the following conditions:
   *
!  * The above copyright notice and this permission notice shall be included
!  * in all copies or substantial portions of the Software.
   *
!  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
!  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
!  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
!  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
!  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
!  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
!  * OTHER DEALINGS IN THE SOFTWARE.
   */
  

Index: SynchronizedIterator.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/Generics/SynchronizedIterator.cs,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -r1.2 -r1.3
*** SynchronizedIterator.cs     24 Feb 2003 04:36:26 -0000      1.2
--- SynchronizedIterator.cs     24 Feb 2003 07:21:00 -0000      1.3
***************
*** 2,20 ****
   * SynchronizedIterator.cs - Wrap an iterator to synchronize it.
   *
!  * Copyright (C) 2003  Southern Storm Software, Pty Ltd.
   *
!  * This program is free software; you can redistribute it and/or modify
!  * it under the terms of the GNU General Public License as published by
!  * the Free Software Foundation; either version 2 of the License, or
!  * (at your option) any later version.
   *
!  * This program is distributed in the hope that it will be useful,
!  * but WITHOUT ANY WARRANTY; without even the implied warranty of
!  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!  * GNU General Public License for more details.
   *
!  * You should have received a copy of the GNU General Public License
!  * along with this program; if not, write to the Free Software
!  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
--- 2,24 ----
   * SynchronizedIterator.cs - Wrap an iterator to synchronize it.
   *
!  * Copyright (c) 2003  Southern Storm Software, Pty Ltd
   *
!  * Permission is hereby granted, free of charge, to any person obtaining
!  * a copy of this software and associated documentation files (the 
"Software"),
!  * to deal in the Software without restriction, including without limitation
!  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
!  * and/or sell copies of the Software, and to permit persons to whom the
!  * Software is furnished to do so, subject to the following conditions:
   *
!  * The above copyright notice and this permission notice shall be included
!  * in all copies or substantial portions of the Software.
   *
!  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
!  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
!  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
!  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
!  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
!  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
!  * OTHER DEALINGS IN THE SOFTWARE.
   */
  

Index: SynchronizedListIterator.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/Generics/SynchronizedListIterator.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** SynchronizedListIterator.cs 24 Feb 2003 04:36:26 -0000      1.1
--- SynchronizedListIterator.cs 24 Feb 2003 07:21:00 -0000      1.2
***************
*** 2,20 ****
   * SynchronizedListIterator.cs - Wrap a list iterator to synchronize it.
   *
!  * Copyright (C) 2003  Southern Storm Software, Pty Ltd.
   *
!  * This program is free software; you can redistribute it and/or modify
!  * it under the terms of the GNU General Public License as published by
!  * the Free Software Foundation; either version 2 of the License, or
!  * (at your option) any later version.
   *
!  * This program is distributed in the hope that it will be useful,
!  * but WITHOUT ANY WARRANTY; without even the implied warranty of
!  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!  * GNU General Public License for more details.
   *
!  * You should have received a copy of the GNU General Public License
!  * along with this program; if not, write to the Free Software
!  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
--- 2,24 ----
   * SynchronizedListIterator.cs - Wrap a list iterator to synchronize it.
   *
!  * Copyright (c) 2003  Southern Storm Software, Pty Ltd
   *
!  * Permission is hereby granted, free of charge, to any person obtaining
!  * a copy of this software and associated documentation files (the 
"Software"),
!  * to deal in the Software without restriction, including without limitation
!  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
!  * and/or sell copies of the Software, and to permit persons to whom the
!  * Software is furnished to do so, subject to the following conditions:
   *
!  * The above copyright notice and this permission notice shall be included
!  * in all copies or substantial portions of the Software.
   *
!  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
!  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
!  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
!  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
!  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
!  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
!  * OTHER DEALINGS IN THE SOFTWARE.
   */
  





reply via email to

[Prev in Thread] Current Thread [Next in Thread]