mcs/class/Mono.C5/C5/WrappedArray.cs

   1 #if NET_2_0
   2 /*\r
   3  Copyright (c) 2003-2006 Niels Kokholm and Peter Sestoft\r
   4  Permission is hereby granted, free of charge, to any person obtaining a copy\r
   5  of this software and associated documentation files (the "Software"), to deal\r
   6  in the Software without restriction, including without limitation the rights\r
   7  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r
   8  copies of the Software, and to permit persons to whom the Software is\r
   9  furnished to do so, subject to the following conditions:\r
  10  \r
  11  The above copyright notice and this permission notice shall be included in\r
  12  all copies or substantial portions of the Software.\r
  13  \r
  14  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  15  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
  16  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r
  17  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r
  18  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  19  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
  20  SOFTWARE.\r
  21 */\r
  22 \r
  23 using System;\r
  24 using System.Text;\r
  25 using System.Diagnostics;\r
  26 using SCG = System.Collections.Generic;\r
  27 namespace C5\r
  28 {\r
  29   /// <summary>\r
  30   /// An advanced interface to operations on an array. The array is viewed as an \r
  31   /// <see cref="T:C5.IList`1"/> of fixed size, and so all operations that would change the\r
  32   /// size of the array will be invalid (and throw <see cref="T:C5.FixedSizeCollectionException"/>\r
  33   /// </summary>\r
  34   /// <typeparam name="T"></typeparam>\r
  35   public class WrappedArray<T> : IList<T>\r
  36   {\r
  37     class InnerList : ArrayList<T>\r
  38     {\r
  39       internal InnerList(T[] array) { this.array = array; size = array.Length; }\r
  40     }\r
  41     ArrayList<T> innerlist;\r
  42     //TODO: remember a ref to the wrapped array in WrappedArray to save a little on indexing?\r
  43     WrappedArray<T> underlying;\r
  44 \r
  45     /// <summary>\r
  46     /// \r
  47     /// </summary>\r
  48     /// <param name="wrappedarray"></param>\r
  49     public WrappedArray(T[] wrappedarray) { innerlist = new InnerList(wrappedarray); }\r
  50 \r
  51     //for views\r
  52     WrappedArray(ArrayList<T> arraylist, WrappedArray<T> underlying) { innerlist = arraylist; this.underlying = underlying; }\r
  53 \r
  54     #region IList<T> Members\r
  55 \r
  56     /// <summary>\r
  57     /// \r
  58     /// </summary>\r
  59     /// <value></value>\r
  60     public T First { get { return innerlist.First; } }\r
  61 \r
  62     /// <summary>\r
  63     /// \r
  64     /// </summary>\r
  65     /// <value></value>\r
  66     public T Last { get { return innerlist.Last; } }\r
  67 \r
  68     /// <summary>\r
  69     /// \r
  70     /// </summary>\r
  71     /// <param name="index"></param>\r
  72     /// <returns></returns>\r
  73     public T this[int index]\r
  74     {\r
  75       get { return innerlist[index]; }\r
  76       set { innerlist[index] = value; }\r
  77     }\r
  78 \r
  79     /// <summary>\r
  80     /// \r
  81     /// </summary>\r
  82     /// <param name="filter"></param>\r
  83     /// <returns></returns>\r
  84     public IList<T> FindAll(Fun<T, bool> filter) { return innerlist.FindAll(filter); }\r
  85 \r
  86     /// <summary>\r
  87     /// \r
  88     /// </summary>\r
  89     /// <typeparam name="V"></typeparam>\r
  90     /// <param name="mapper"></param>\r
  91     /// <returns></returns>\r
  92     public IList<V> Map<V>(Fun<T, V> mapper) { return innerlist.Map<V>(mapper); }\r
  93 \r
  94     /// <summary>\r
  95     /// \r
  96     /// </summary>\r
  97     /// <typeparam name="V"></typeparam>\r
  98     /// <param name="mapper"></param>\r
  99     /// <param name="equalityComparer"></param>\r
 100     /// <returns></returns>\r
 101     public IList<V> Map<V>(Fun<T, V> mapper, SCG.IEqualityComparer<V> equalityComparer) { return innerlist.Map<V>(mapper, equalityComparer); }\r
 102 \r
 103     /// <summary>\r
 104     /// ???? should we throw NotRelevantException\r
 105     /// </summary>\r
 106     /// <value></value>\r
 107     public bool FIFO\r
 108     {\r
 109       get { throw new FixedSizeCollectionException(); }\r
 110       set { throw new FixedSizeCollectionException(); }\r
 111     }\r
 112 \r
 113     /// <summary>\r
 114     /// \r
 115     /// </summary>\r
 116     public virtual bool IsFixedSize\r
 117     {\r
 118       get { return true; }\r
 119     }\r
 120 \r
 121     /// <summary>\r
 122     /// \r
 123     /// </summary>\r
 124     /// <param name="index"></param>\r
 125     /// <param name="item"></param>\r
 126     public void Insert(int index, T item)\r
 127     {\r
 128       throw new FixedSizeCollectionException();\r
 129     }\r
 130 \r
 131     /// <summary>\r
 132     /// \r
 133     /// </summary>\r
 134     /// <param name="pointer"></param>\r
 135     /// <param name="item"></param>\r
 136     public void Insert(IList<T> pointer, T item)\r
 137     {\r
 138       throw new FixedSizeCollectionException();\r
 139     }\r
 140 \r
 141     /// <summary>\r
 142     /// \r
 143     /// </summary>\r
 144     /// <param name="item"></param>\r
 145     public void InsertFirst(T item)\r
 146     {\r
 147       throw new FixedSizeCollectionException();\r
 148     }\r
 149 \r
 150     /// <summary>\r
 151     /// \r
 152     /// </summary>\r
 153     /// <param name="item"></param>\r
 154     public void InsertLast(T item)\r
 155     {\r
 156       throw new FixedSizeCollectionException();\r
 157     }\r
 158 \r
 159     /// <summary>\r
 160     /// \r
 161     /// </summary>\r
 162     /// <typeparam name="U"></typeparam>\r
 163     /// <param name="i"></param>\r
 164     /// <param name="items"></param>\r
 165     public void InsertAll<U>(int i, System.Collections.Generic.IEnumerable<U> items) where U : T\r
 166     {\r
 167       throw new FixedSizeCollectionException();\r
 168     }\r
 169 \r
 170     /// <summary>\r
 171     /// \r
 172     /// </summary>\r
 173     /// <returns></returns>\r
 174     public T Remove()\r
 175     {\r
 176       throw new FixedSizeCollectionException();\r
 177     }\r
 178 \r
 179     /// <summary>\r
 180     /// \r
 181     /// </summary>\r
 182     /// <returns></returns>\r
 183     public T RemoveFirst()\r
 184     {\r
 185       throw new FixedSizeCollectionException();\r
 186     }\r
 187 \r
 188     /// <summary>\r
 189     /// \r
 190     /// </summary>\r
 191     /// <returns></returns>\r
 192     public T RemoveLast()\r
 193     {\r
 194       throw new FixedSizeCollectionException();\r
 195     }\r
 196 \r
 197     /// <summary>\r
 198     /// \r
 199     /// </summary>\r
 200     /// <param name="start"></param>\r
 201     /// <param name="count"></param>\r
 202     /// <returns></returns>\r
 203     public IList<T> View(int start, int count)\r
 204     {\r
 205       return new WrappedArray<T>((ArrayList<T>)innerlist.View(start, count), underlying ?? this);\r
 206     }\r
 207 \r
 208     /// <summary>\r
 209     /// \r
 210     /// </summary>\r
 211     /// <param name="item"></param>\r
 212     /// <returns></returns>\r
 213     public IList<T> ViewOf(T item)\r
 214     {\r
 215       return new WrappedArray<T>((ArrayList<T>)innerlist.ViewOf(item), underlying ?? this);\r
 216     }\r
 217 \r
 218     /// <summary>\r
 219     /// \r
 220     /// </summary>\r
 221     /// <param name="item"></param>\r
 222     /// <returns></returns>\r
 223     public IList<T> LastViewOf(T item)\r
 224     {\r
 225       return new WrappedArray<T>((ArrayList<T>)innerlist.LastViewOf(item), underlying ?? this);\r
 226     }\r
 227 \r
 228     /// <summary>\r
 229     /// \r
 230     /// </summary>\r
 231     /// <value></value>\r
 232     public IList<T> Underlying { get { return underlying; } }\r
 233 \r
 234     /// <summary>\r
 235     /// \r
 236     /// </summary>\r
 237     /// <value></value>\r
 238     public int Offset { get { return innerlist.Offset; } }\r
 239 \r
 240     /// <summary>\r
 241     /// \r
 242     /// </summary>\r
 243     /// <value></value>\r
 244     public bool IsValid { get { return innerlist.IsValid; } }\r
 245 \r
 246     /// <summary>\r
 247     /// \r
 248     /// </summary>\r
 249     /// <param name="offset"></param>\r
 250     /// <returns></returns>\r
 251     public IList<T> Slide(int offset) { return innerlist.Slide(offset); }\r
 252 \r
 253     /// <summary>\r
 254     /// \r
 255     /// </summary>\r
 256     /// <param name="offset"></param>\r
 257     /// <param name="size"></param>\r
 258     /// <returns></returns>\r
 259     public IList<T> Slide(int offset, int size) { return innerlist.Slide(offset, size); }\r
 260 \r
 261     /// <summary>\r
 262     /// \r
 263     /// </summary>\r
 264     /// <param name="offset"></param>\r
 265     /// <returns></returns>\r
 266     public bool TrySlide(int offset) { return innerlist.TrySlide(offset); }\r
 267 \r
 268     /// <summary>\r
 269     /// \r
 270     /// </summary>\r
 271     /// <param name="offset"></param>\r
 272     /// <param name="size"></param>\r
 273     /// <returns></returns>\r
 274     public bool TrySlide(int offset, int size) { return innerlist.TrySlide(offset, size); }\r
 275 \r
 276     /// <summary>\r
 277     /// \r
 278     /// </summary>\r
 279     /// <param name="otherView"></param>\r
 280     /// <returns></returns>\r
 281     public IList<T> Span(IList<T> otherView) { return innerlist.Span(((WrappedArray<T>)otherView).innerlist); }\r
 282 \r
 283     /// <summary>\r
 284     /// \r
 285     /// </summary>\r
 286     public void Reverse() { innerlist.Reverse(); }\r
 287 \r
 288     /// <summary>\r
 289     /// \r
 290     /// </summary>\r
 291     /// <returns></returns>\r
 292     public bool IsSorted() { return innerlist.IsSorted(); }\r
 293 \r
 294     /// <summary>\r
 295     /// \r
 296     /// </summary>\r
 297     /// <param name="comparer"></param>\r
 298     /// <returns></returns>\r
 299     public bool IsSorted(SCG.IComparer<T> comparer) { return innerlist.IsSorted(comparer); }\r
 300 \r
 301     /// <summary>\r
 302     /// \r
 303     /// </summary>\r
 304     public void Sort() { innerlist.Sort(); }\r
 305 \r
 306     /// <summary>\r
 307     /// \r
 308     /// </summary>\r
 309     /// <param name="comparer"></param>\r
 310     public void Sort(SCG.IComparer<T> comparer) { innerlist.Sort(comparer); }\r
 311 \r
 312     /// <summary>\r
 313     /// \r
 314     /// </summary>\r
 315     public void Shuffle() { innerlist.Shuffle(); }\r
 316 \r
 317     /// <summary>\r
 318     /// \r
 319     /// </summary>\r
 320     /// <param name="rnd"></param>\r
 321     public void Shuffle(Random rnd) { innerlist.Shuffle(rnd); }\r
 322 \r
 323     #endregion\r
 324 \r
 325     #region IIndexed<T> Members\r
 326 \r
 327     /// <summary>\r
 328     /// \r
 329     /// </summary>\r
 330     /// <value></value>\r
 331     public Speed IndexingSpeed { get { return Speed.Constant; } }\r
 332 \r
 333     /// <summary>\r
 334     /// \r
 335     /// </summary>\r
 336     /// <param name="start"></param>\r
 337     /// <param name="count"></param>\r
 338     /// <returns></returns>\r
 339     public IDirectedCollectionValue<T> this[int start, int count] { get { return innerlist[start, count]; } }\r
 340 \r
 341     /// <summary>\r
 342     /// \r
 343     /// </summary>\r
 344     /// <param name="item"></param>\r
 345     /// <returns></returns>\r
 346     public int IndexOf(T item) { return innerlist.IndexOf(item); }\r
 347 \r
 348     /// <summary>\r
 349     /// \r
 350     /// </summary>\r
 351     /// <param name="item"></param>\r
 352     /// <returns></returns>\r
 353     public int LastIndexOf(T item) { return innerlist.LastIndexOf(item); }\r
 354 \r
 355     /// <summary>\r
 356     /// \r
 357     /// </summary>\r
 358     /// <param name="predicate"></param>\r
 359     /// <returns></returns>\r
 360     public int FindIndex(Fun<T, bool> predicate) { return innerlist.FindIndex(predicate); }\r
 361 \r
 362     /// <summary>\r
 363     /// \r
 364     /// </summary>\r
 365     /// <param name="predicate"></param>\r
 366     /// <returns></returns>\r
 367     public int FindLastIndex(Fun<T, bool> predicate) { return innerlist.FindLastIndex(predicate); }\r
 368 \r
 369     /// <summary>\r
 370     /// \r
 371     /// </summary>\r
 372     /// <param name="i"></param>\r
 373     /// <returns></returns>\r
 374     public T RemoveAt(int i) { throw new FixedSizeCollectionException(); }\r
 375 \r
 376     /// <summary>\r
 377     /// \r
 378     /// </summary>\r
 379     /// <param name="start"></param>\r
 380     /// <param name="count"></param>\r
 381     public void RemoveInterval(int start, int count) { throw new FixedSizeCollectionException(); }\r
 382 \r
 383     #endregion\r
 384 \r
 385     #region ISequenced<T> Members\r
 386 \r
 387     /// <summary>\r
 388     /// \r
 389     /// </summary>\r
 390     /// <returns></returns>\r
 391     public int GetSequencedHashCode() { return innerlist.GetSequencedHashCode(); }\r
 392 \r
 393     /// <summary>\r
 394     /// \r
 395     /// </summary>\r
 396     /// <param name="that"></param>\r
 397     /// <returns></returns>\r
 398     public bool SequencedEquals(ISequenced<T> that) { return innerlist.SequencedEquals(that); }\r
 399 \r
 400     #endregion\r
 401 \r
 402     #region ICollection<T> Members\r
 403     /// <summary>\r
 404     /// \r
 405     /// </summary>\r
 406     /// <value></value>\r
 407     public Speed ContainsSpeed { get { return Speed.Linear; } }\r
 408 \r
 409     /// <summary>\r
 410     /// \r
 411     /// </summary>\r
 412     /// <returns></returns>\r
 413     public int GetUnsequencedHashCode() { return innerlist.GetUnsequencedHashCode(); }\r
 414 \r
 415     /// <summary>\r
 416     /// \r
 417     /// </summary>\r
 418     /// <param name="that"></param>\r
 419     /// <returns></returns>\r
 420     public bool UnsequencedEquals(ICollection<T> that) { return innerlist.UnsequencedEquals(that); }\r
 421 \r
 422     /// <summary>\r
 423     /// \r
 424     /// </summary>\r
 425     /// <param name="item"></param>\r
 426     /// <returns></returns>\r
 427     public bool Contains(T item) { return innerlist.Contains(item); }\r
 428 \r
 429     /// <summary>\r
 430     /// \r
 431     /// </summary>\r
 432     /// <param name="item"></param>\r
 433     /// <returns></returns>\r
 434     public int ContainsCount(T item) { return innerlist.ContainsCount(item); }\r
 435 \r
 436     /// <summary>\r
 437     /// \r
 438     /// </summary>\r
 439     /// <returns></returns>\r
 440     public ICollectionValue<T> UniqueItems() { return innerlist.UniqueItems(); }\r
 441 \r
 442     /// <summary>\r
 443     /// \r
 444     /// </summary>\r
 445     /// <returns></returns>\r
 446     public ICollectionValue<KeyValuePair<T, int>> ItemMultiplicities() { return innerlist.ItemMultiplicities(); }\r
 447 \r
 448     /// <summary>\r
 449     /// \r
 450     /// </summary>\r
 451     /// <typeparam name="U"></typeparam>\r
 452     /// <param name="items"></param>\r
 453     /// <returns></returns>\r
 454     public bool ContainsAll<U>(System.Collections.Generic.IEnumerable<U> items) where U : T\r
 455     { return innerlist.ContainsAll(items); }\r
 456 \r
 457     /// <summary>\r
 458     /// \r
 459     /// </summary>\r
 460     /// <param name="item"></param>\r
 461     /// <returns></returns>\r
 462     public bool Find(ref T item) { return innerlist.Find(ref item); }\r
 463 \r
 464     /// <summary>\r
 465     /// \r
 466     /// </summary>\r
 467     /// <param name="item"></param>\r
 468     /// <returns></returns>\r
 469     public bool FindOrAdd(ref T item) { throw new FixedSizeCollectionException(); }\r
 470 \r
 471     /// <summary>\r
 472     /// \r
 473     /// </summary>\r
 474     /// <param name="item"></param>\r
 475     /// <returns></returns>\r
 476     public bool Update(T item) { throw new FixedSizeCollectionException(); }\r
 477 \r
 478     /// <summary>\r
 479     /// \r
 480     /// </summary>\r
 481     /// <param name="item"></param>\r
 482     /// <param name="olditem"></param>\r
 483     /// <returns></returns>\r
 484     public bool Update(T item, out T olditem) { throw new FixedSizeCollectionException(); }\r
 485 \r
 486     /// <summary>\r
 487     /// \r
 488     /// </summary>\r
 489     /// <param name="item"></param>\r
 490     /// <returns></returns>\r
 491     public bool UpdateOrAdd(T item) { throw new FixedSizeCollectionException(); }\r
 492 \r
 493     /// <summary>\r
 494     /// \r
 495     /// </summary>\r
 496     /// <param name="item"></param>\r
 497     /// <param name="olditem"></param>\r
 498     /// <returns></returns>\r
 499     public bool UpdateOrAdd(T item, out T olditem) { throw new FixedSizeCollectionException(); }\r
 500 \r
 501     /// <summary>\r
 502     /// \r
 503     /// </summary>\r
 504     /// <param name="item"></param>\r
 505     /// <returns></returns>\r
 506     public bool Remove(T item) { throw new FixedSizeCollectionException(); }\r
 507 \r
 508     /// <summary>\r
 509     /// \r
 510     /// </summary>\r
 511     /// <param name="item"></param>\r
 512     /// <param name="removeditem"></param>\r
 513     /// <returns></returns>\r
 514     public bool Remove(T item, out T removeditem) { throw new FixedSizeCollectionException(); }\r
 515 \r
 516     /// <summary>\r
 517     /// \r
 518     /// </summary>\r
 519     /// <param name="item"></param>\r
 520     public void RemoveAllCopies(T item) { throw new FixedSizeCollectionException(); }\r
 521 \r
 522     /// <summary>\r
 523     /// \r
 524     /// </summary>\r
 525     /// <typeparam name="U"></typeparam>\r
 526     /// <param name="items"></param>\r
 527     public void RemoveAll<U>(System.Collections.Generic.IEnumerable<U> items) where U : T { throw new FixedSizeCollectionException(); }\r
 528 \r
 529     /// <summary>\r
 530     /// \r
 531     /// </summary>\r
 532     public void Clear() { throw new FixedSizeCollectionException(); }\r
 533 \r
 534     /// <summary>\r
 535     /// \r
 536     /// </summary>\r
 537     /// <typeparam name="U"></typeparam>\r
 538     /// <param name="items"></param>\r
 539     public void RetainAll<U>(System.Collections.Generic.IEnumerable<U> items) where U : T { throw new FixedSizeCollectionException(); }\r
 540 \r
 541     #endregion\r
 542 \r
 543     #region IExtensible<T> Members\r
 544     /// <summary>\r
 545     /// \r
 546     /// </summary>\r
 547     /// <value></value>\r
 548     public object SyncRoot { get { return innerlist.SyncRoot; } }\r
 549 \r
 550     /// <summary>\r
 551     /// \r
 552     /// </summary>\r
 553     /// <value></value>\r
 554     public bool IsReadOnly { get { return true; } }\r
 555 \r
 556     /// <summary>\r
 557     /// \r
 558     /// </summary>\r
 559     /// <value></value>\r
 560     public bool AllowsDuplicates\r
 561     {\r
 562       get { return true; }\r
 563     }\r
 564 \r
 565     /// <summary>\r
 566     /// \r
 567     /// </summary>\r
 568     /// <value></value>\r
 569     public SCG.IEqualityComparer<T> EqualityComparer { get { return innerlist.EqualityComparer; } }\r
 570 \r
 571     /// <summary>\r
 572     /// \r
 573     /// </summary>\r
 574     /// <value></value>\r
 575     public bool DuplicatesByCounting\r
 576     {\r
 577       get { return false; }\r
 578     }\r
 579 \r
 580     /// <summary>\r
 581     /// \r
 582     /// </summary>\r
 583     /// <param name="item"></param>\r
 584     /// <returns></returns>\r
 585     public bool Add(T item)\r
 586     {\r
 587       throw new FixedSizeCollectionException();\r
 588     }\r
 589 \r
 590     /// <summary>\r
 591     /// \r
 592     /// </summary>\r
 593     /// <typeparam name="U"></typeparam>\r
 594     /// <param name="items"></param>\r
 595     public void AddAll<U>(System.Collections.Generic.IEnumerable<U> items) where U : T\r
 596     {\r
 597       throw new FixedSizeCollectionException();\r
 598     }\r
 599 \r
 600     /// <summary>\r
 601     /// \r
 602     /// </summary>\r
 603     /// <returns></returns>\r
 604     public bool Check()\r
 605     {\r
 606       return innerlist.Check() && (underlying == null || underlying.innerlist == innerlist.Underlying);\r
 607     }\r
 608 \r
 609     #endregion\r
 610 \r
 611     #region ICollectionValue<T> Members\r
 612     /// <summary>\r
 613     /// No listeners may be installed\r
 614     /// </summary>\r
 615     /// <value>0</value>\r
 616     public virtual EventTypeEnum ListenableEvents { get { return 0; } }\r
 617 \r
 618     /// <summary>\r
 619     /// No listeners ever installed\r
 620     /// </summary>\r
 621     /// <value>0</value>\r
 622     public virtual EventTypeEnum ActiveEvents { get { return 0; } }\r
 623 \r
 624     /// <summary>\r
 625     /// \r
 626     /// </summary>\r
 627     /// <value></value>\r
 628     public event CollectionChangedHandler<T> CollectionChanged\r
 629     {\r
 630       add { throw new UnlistenableEventException(); }\r
 631       remove { throw new UnlistenableEventException(); }\r
 632     }\r
 633 \r
 634     /// <summary>\r
 635     /// \r
 636     /// </summary>\r
 637     /// <value></value>\r
 638     public event CollectionClearedHandler<T> CollectionCleared\r
 639     {\r
 640       add { throw new UnlistenableEventException(); }\r
 641       remove { throw new UnlistenableEventException(); }\r
 642     }\r
 643 \r
 644     /// <summary>\r
 645     /// \r
 646     /// </summary>\r
 647     /// <value></value>\r
 648     public event ItemsAddedHandler<T> ItemsAdded\r
 649     {\r
 650       add { throw new UnlistenableEventException(); }\r
 651       remove { throw new UnlistenableEventException(); }\r
 652     }\r
 653 \r
 654     /// <summary>\r
 655     /// \r
 656     /// </summary>\r
 657     /// <value></value>\r
 658     public event ItemInsertedHandler<T> ItemInserted\r
 659     {\r
 660       add { throw new UnlistenableEventException(); }\r
 661       remove { throw new UnlistenableEventException(); }\r
 662     }\r
 663 \r
 664     /// <summary>\r
 665     /// \r
 666     /// </summary>\r
 667     /// <value></value>\r
 668     public event ItemsRemovedHandler<T> ItemsRemoved\r
 669     {\r
 670       add { throw new UnlistenableEventException(); }\r
 671       remove { throw new UnlistenableEventException(); }\r
 672     }\r
 673 \r
 674     /// <summary>\r
 675     /// \r
 676     /// </summary>\r
 677     /// <value></value>\r
 678     public event ItemRemovedAtHandler<T> ItemRemovedAt\r
 679     {\r
 680       add { throw new UnlistenableEventException(); }\r
 681       remove { throw new UnlistenableEventException(); }\r
 682     }\r
 683 \r
 684     /// <summary>\r
 685     /// \r
 686     /// </summary>\r
 687     /// <value></value>\r
 688     public bool IsEmpty { get { return innerlist.IsEmpty; } }\r
 689 \r
 690     /// <summary>\r
 691     /// \r
 692     /// </summary>\r
 693     /// <value></value>\r
 694     public int Count { get { return innerlist.Count; } }\r
 695 \r
 696     /// <summary>\r
 697     /// \r
 698     /// </summary>\r
 699     /// <value></value>\r
 700     public Speed CountSpeed { get { return innerlist.CountSpeed; } }\r
 701 \r
 702     /// <summary>\r
 703     /// \r
 704     /// </summary>\r
 705     /// <param name="array"></param>\r
 706     /// <param name="index"></param>\r
 707     public void CopyTo(T[] array, int index) { innerlist.CopyTo(array, index); }\r
 708 \r
 709     /// <summary>\r
 710     /// \r
 711     /// </summary>\r
 712     /// <returns></returns>\r
 713     public T[] ToArray() { return innerlist.ToArray(); }\r
 714 \r
 715     /// <summary>\r
 716     /// \r
 717     /// </summary>\r
 718     /// <param name="action"></param>\r
 719     public void Apply(Act<T> action) { innerlist.Apply(action); }\r
 720 \r
 721     /// <summary>\r
 722     /// \r
 723     /// </summary>\r
 724     /// <param name="predicate"></param>\r
 725     /// <returns></returns>\r
 726     public bool Exists(Fun<T, bool> predicate) { return innerlist.Exists(predicate); }\r
 727 \r
 728     /// <summary>\r
 729     /// \r
 730     /// </summary>\r
 731     /// <param name="predicate"></param>\r
 732     /// <param name="item"></param>\r
 733     /// <returns></returns>\r
 734     public bool Find(Fun<T, bool> predicate, out T item) { return innerlist.Find(predicate, out item); }\r
 735 \r
 736     /// <summary>\r
 737     /// \r
 738     /// </summary>\r
 739     /// <param name="predicate"></param>\r
 740     /// <returns></returns>\r
 741     public bool All(Fun<T, bool> predicate) { return innerlist.All(predicate); }\r
 742 \r
 743     /// <summary>\r
 744     /// \r
 745     /// </summary>\r
 746     /// <returns></returns>\r
 747     public T Choose() { return innerlist.Choose(); }\r
 748 \r
 749     /// <summary>\r
 750     /// \r
 751     /// </summary>\r
 752     /// <param name="filter"></param>\r
 753     /// <returns></returns>\r
 754     public SCG.IEnumerable<T> Filter(Fun<T, bool> filter) { return innerlist.Filter(filter); }\r
 755 \r
 756     #endregion\r
 757 \r
 758     #region IEnumerable<T> Members\r
 759 \r
 760     /// <summary>\r
 761     /// \r
 762     /// </summary>\r
 763     /// <returns></returns>\r
 764     public SCG.IEnumerator<T> GetEnumerator() { return innerlist.GetEnumerator(); }\r
 765     #endregion\r
 766 \r
 767     #region IShowable Members\r
 768 \r
 769     /// <summary>\r
 770     /// \r
 771     /// </summary>\r
 772     /// <param name="stringbuilder"></param>\r
 773     /// <param name="rest"></param>\r
 774     /// <param name="formatProvider"></param>\r
 775     /// <returns></returns>\r
 776     public bool Show(StringBuilder stringbuilder, ref int rest, IFormatProvider formatProvider)\r
 777     { return innerlist.Show(stringbuilder, ref  rest, formatProvider); }\r
 778 \r
 779     #endregion\r
 780 \r
 781     #region IFormattable Members\r
 782 \r
 783     /// <summary>\r
 784     /// \r
 785     /// </summary>\r
 786     /// <returns></returns>\r
 787     public override string ToString() { return innerlist.ToString(); }\r
 788 \r
 789 \r
 790     /// <summary>\r
 791     /// \r
 792     /// </summary>\r
 793     /// <param name="format"></param>\r
 794     /// <param name="formatProvider"></param>\r
 795     /// <returns></returns>\r
 796     public virtual string ToString(string format, IFormatProvider formatProvider) { return innerlist.ToString(format, formatProvider); }\r
 797 \r
 798     #endregion\r
 799 \r
 800     #region IDirectedCollectionValue<T> Members\r
 801 \r
 802     /// <summary>\r
 803     /// \r
 804     /// </summary>\r
 805     /// <returns></returns>\r
 806     public IDirectedCollectionValue<T> Backwards() { return innerlist.Backwards(); }\r
 807 \r
 808     /// <summary>\r
 809     /// \r
 810     /// </summary>\r
 811     /// <param name="predicate"></param>\r
 812     /// <param name="item"></param>\r
 813     /// <returns></returns>\r
 814     public bool FindLast(Fun<T, bool> predicate, out T item) { return innerlist.FindLast(predicate, out item); }\r
 815 \r
 816     #endregion\r
 817 \r
 818     #region IDirectedEnumerable<T> Members\r
 819 \r
 820     IDirectedEnumerable<T> IDirectedEnumerable<T>.Backwards() { return Backwards(); }\r
 821 \r
 822     /// <summary>\r
 823     /// \r
 824     /// </summary>\r
 825     /// <value></value>\r
 826     public EnumerationDirection Direction { get { return EnumerationDirection.Forwards; } }\r
 827 \r
 828     #endregion\r
 829 \r
 830     #region IDisposable Members\r
 831 \r
 832     /// <summary>\r
 833     /// Dispose this if a view else operation is illegal \r
 834     /// </summary>\r
 835     /// <exception cref="FixedSizeCollectionException">If not a view</exception>\r
 836     public void Dispose()\r
 837     {\r
 838       if (underlying == null)\r
 839         throw new FixedSizeCollectionException();\r
 840       else\r
 841         innerlist.Dispose();\r
 842     }\r
 843 \r
 844     #endregion\r
 845 \r
 846     #region ICloneable Members\r
 847 \r
 848     /// <summary>\r
 849     /// Make a shallow copy of this WrappedArray.\r
 850     /// \r
 851     /// \r
 852     /// </summary>\r
 853     /// <returns></returns>\r
 854     public virtual object Clone()\r
 855     {\r
 856       return new WrappedArray<T>(innerlist.ToArray());\r
 857     }\r
 858 \r
 859     #endregion\r
 860 \r
 861 \r
 862 \r
 863     #region IEnumerable Members\r
 864 \r
 865     System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()\r
 866     {\r
 867       throw new Exception("The method or operation is not implemented.");\r
 868     }\r
 869 \r
 870     #endregion\r
 871   }\r
 872 }
 873 #endif