root/trunk/x42view.net/ReadOnlyList.cs

/******************************************************************************
        x42view.net - .x42 viewer and auditing tool
        Copyright (C) 2007 HermitWorks Entertainment Corporation

        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.
                51 Franklin Street, Fifth Floor
                Boston, MA  02110-1301, USA.
******************************************************************************/

using System;
using System.Collections.Generic;
using System.Text;

namespace x42view
{
        public class ReadOnlyList<T> : IList<T>
        {
                private T[] items;
                public ReadOnlyList( ICollection<T> items )
                {
                        if( items == null )
                                throw new ArgumentNullException( "items" );

                        this.items = new T[items.Count];
                        items.CopyTo( this.items, 0 );
                }

                public int Count { get { return items.Length; } }
                public T this[int index] { get { return items[index]; } }

                private static ReadOnlyList<T> empty;
                public static ReadOnlyList<T> Empty
                {
                        get
                        {
                                if( empty == null )
                                        empty = new ReadOnlyList<T>( new T[0] );

                                return empty;
                        }
                }

                public int IndexOf( T item )
                {
                        return Array.IndexOf( items, item );                    
                }

                #region IList<T> Members

                void IList<T>.Insert( int index, T item )
                {
                        throw new NotSupportedException();
                }

                void IList<T>.RemoveAt( int index )
                {
                        throw new NotSupportedException();
                }

                T IList<T>.this[int index]
                {
                        get
                        {
                                return items[index];
                        }
                        set
                        {
                                throw new NotSupportedException();
                        }
                }

                #endregion

                #region ICollection<T> Members

                void ICollection<T>.Add( T item )
                {
                        throw new NotSupportedException();
                }

                void ICollection<T>.Clear()
                {
                        throw new NotSupportedException();
                }

                public bool Contains( T item )
                {
                        return IndexOf( item ) != -1;
                }

                public void CopyTo( T[] array, int arrayIndex )
                {
                        items.CopyTo( array, arrayIndex );
                }

                bool ICollection<T>.IsReadOnly
                {
                        get { return true; }
                }

                bool ICollection<T>.Remove( T item )
                {
                        throw new NotSupportedException();
                }

                #endregion

                #region IEnumerable<T> Members

                public IEnumerator<T> GetEnumerator()
                {
                        return ((IEnumerable<T>)items).GetEnumerator();
                }

                #endregion

                #region IEnumerable Members

                System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
                {
                        return GetEnumerator();
                }

                #endregion
        }
}