gee/readonlylist.vala

   1 /* readonlylist.vala
   2  *
   3  * Copyright (C) 2007-2008  Jürg Billeter
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  18  *
  19  * Author:
  20  *      Jürg Billeter <j@bitron.ch>
  21  */
  22
  23 using GLib;
  24
  25 /**
  26  * Represents a read-only collection of items in a well-defined order.
  27  */
  28 public class Vala.ReadOnlyList<G> : CollectionObject, Iterable<G>, Collection<G>, List<G> {
  29         public int size {
  30                 get { return _list.size; }
  31         }
  32
  33         public List<G> list {
  34                 set { _list = value; }
  35         }
  36
  37         private List<G> _list;
  38
  39         public ReadOnlyList (List<G>? list = null) {
  40                 this.list = list;
  41         }
  42
  43         public Type get_element_type () {
  44                 return typeof (G);
  45         }
  46
  47         public Vala.Iterator<G> iterator () {
  48                 if (_list == null) {
  49                         return new Iterator<G> ();
  50                 }
  51
  52                 return _list.iterator ();
  53         }
  54
  55         public bool contains (G item) {
  56                 if (_list == null) {
  57                         return false;
  58                 }
  59
  60                 return _list.contains (item);
  61         }
  62
  63         public int index_of (G item) {
  64                 if (_list == null) {
  65                         return -1;
  66                 }
  67
  68                 return _list.index_of (item);
  69         }
  70
  71         public bool add (G item) {
  72                 assert_not_reached ();
  73         }
  74
  75         public bool remove (G item) {
  76                 assert_not_reached ();
  77         }
  78
  79         public void insert (int index, G item) {
  80                 assert_not_reached ();
  81         }
  82
  83         public void remove_at (int index) {
  84                 assert_not_reached ();
  85         }
  86
  87         public G? get (int index) {
  88                 if (_list == null) {
  89                         return null;
  90                 }
  91
  92                 return _list.get (index);
  93         }
  94
  95         public void set (int index, G o) {
  96                 assert_not_reached ();
  97         }
  98
  99         public void clear () {
 100                 assert_not_reached ();
 101         }
 102
 103         class Iterator<G> : CollectionObject, Vala.Iterator<G> {
 104                 public bool next () {
 105                         return false;
 106                 }
 107
 108                 public G? get () {
 109                         return null;
 110                 }
 111         }
 112 }
 113