2-APL UPC project.
1package blockworld.lib;
2
3/*
4 This file is part of the Bushfire project.
5
6 Copyright 2003, M. Albers, H Boros, R Burema, N. Goh, J. Herold, B.
7 Maassen, R. Peek, J. Priem, Bas Steunebrink, P. van de Werken.
8
9 The Bushfire project is free software; you can redistribute it
10 and/or modify it under the terms of the GNU General Public License
11 as published by the Free Software Foundation; either version 2 of
12 the License, or (at your option) any later version.
13
14 The Bushfire project is distributed in the hope that it will be
15 useful, but WITHOUT ANY WARRANTY; without even the implied warranty
16 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with the Bushfire project; if not, write to the Free Software Foundation,
21 Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22
23 $Id: ObsVect.java,v 1.4 2004/09/14 10:58:06 cvs-3apl Exp $
24 */
25
26import java.util.Collection;
27import java.util.Iterator;
28import java.util.Observable;
29import java.util.Observer;
30import java.util.Vector;
31
32/**
33 * Any methods that have not been overwritten do not need to be, because those
34 * methods only call overwritten methods anyway.
35 */
36public class ObsVect extends Vector {
37
38 private static final long serialVersionUID = 1140345853942753525L;
39
40 protected static final int ADD = 0, REMOVE = 1;
41
42 transient protected MyObservable _observable = new MyObservable();
43
44 public ObsVect() {
45 super();
46 }
47
48 public ObsVect( Collection c ) {
49 super( c );
50 }
51
52 public ObsVect( int initialCapacity ) {
53 super( initialCapacity );
54 }
55
56 public ObsVect( int initialCapacity, int capacityIncrement ) {
57 super( initialCapacity, capacityIncrement );
58 }
59
60 public ObsVect( ObsVectListener l, int initialCapacity ) {
61 super( initialCapacity );
62 addListener( l );
63 }
64
65 public ObsVect( ObsVectListener l, int initialCapacity,
66 int capacityIncrement ) {
67 super( initialCapacity, capacityIncrement );
68 addListener( l );
69 }
70
71 public ObsVect( ObsVectListener l ) {
72 super();
73 addListener( l );
74 }
75
76 public ObsVect( ObsVectListener l, Collection c ) {
77 super( c );
78 addListener( l );
79 }
80
81 public boolean add( Object obj ) {
82 addElement( obj );
83 return true;
84 }
85
86 public void addElement( Object obj ) {
87 synchronized(this) {
88 super.addElement( obj );
89 }
90 Object[] data = new Object[ 3 ];
91 data[ 0 ] = new Integer( ADD );
92 data[ 1 ] = new Integer( size() - 1 );
93 data[ 2 ] = obj;
94 _observable.setChanged();
95 _observable.notifyObservers( data );
96 }
97
98 public boolean addAll( Collection c ) {
99 return addAll( size(), c );
100 }
101
102 public boolean addAll( int index, Collection c ) {
103 boolean result;
104 synchronized(this) {
105 result = super.addAll( index, c );
106 }
107 if( result ) {
108 Object[] data = new Object[ 3 ];
109 data[ 0 ] = new Integer( ADD );
110 Iterator iter = c.iterator();
111 int i = 0;
112 while( iter.hasNext() ) {
113 data[ 1 ] = new Integer( ++i );
114 data[ 2 ] = iter.next();
115 _observable.setChanged();
116 _observable.notifyObservers( data );
117 }
118 return true;
119 }
120 return false;
121 }
122
123 public void insertElementAt( Object obj, int index ) {
124 synchronized(this) {
125 super.insertElementAt( obj, index );
126 }
127 Object[] data = new Object[ 3 ];
128 data[ 0 ] = new Integer( ADD );
129 data[ 1 ] = new Integer( index );
130 data[ 2 ] = obj;
131 _observable.setChanged();
132 _observable.notifyObservers( data );
133 }
134
135 public synchronized Object remove( int index ) {
136 Object obj = get( index );
137 removeElementAt( index );
138 return obj;
139 }
140
141 public synchronized void removeAllElements() {
142 Iterator iter = iterator();
143 while( iter.hasNext() ) {
144 iter.next();
145 iter.remove();
146 }
147 }
148
149 public void removeElementAt( int index ) {
150 Object obj;
151 synchronized (this) {
152 obj = get( index );
153 super.removeElementAt( index );
154 }
155
156 Object[] data = new Object[ 3 ];
157 data[ 0 ] = new Integer( REMOVE );
158 data[ 1 ] = new Integer( index );
159 data[ 2 ] = obj;
160 _observable.setChanged();
161 _observable.notifyObservers( data );
162 }
163
164 public Object set( int index, Object element ) {
165 Object removed;
166 synchronized(this) {
167 removed = get( index );
168 super.set( index, element );
169 }
170 Object[] data = new Object[ 3 ];
171 data[ 0 ] = new Integer( REMOVE );
172 data[ 1 ] = new Integer( index );
173 data[ 2 ] = removed;
174 _observable.setChanged();
175 _observable.notifyObservers( data );
176 data[ 0 ] = new Integer( ADD );
177 data[ 1 ] = new Integer( index );
178 data[ 2 ] = element;
179 _observable.setChanged();
180 _observable.notifyObservers( data );
181 return removed;
182 }
183
184 public void setElementAt( Object obj, int index ) {
185 Object removed;
186 synchronized(this) {
187 removed = get( index );
188 super.setElementAt( obj, index );
189 }
190 Object[] data = new Object[ 3 ];
191 data[ 0 ] = new Integer( REMOVE );
192 data[ 1 ] = new Integer( index );
193 data[ 2 ] = removed;
194 _observable.setChanged();
195 _observable.notifyObservers( data );
196 data[ 0 ] = new Integer( ADD );
197 data[ 1 ] = new Integer( index );
198 data[ 2 ] = obj;
199 _observable.setChanged();
200 _observable.notifyObservers( data );
201 }
202
203 public synchronized void setSize( int newSize ) {
204 if( newSize < size() ) {
205 Iterator iter = listIterator( newSize );
206 while( iter.hasNext() ) {
207 iter.next();
208 iter.remove();
209 }
210 }
211 else
212 super.setSize( newSize );
213 }
214
215 public void addListener( ObsVectListener listener ) {
216 _observable.addObserver( new ObsVectAdapter( listener ) );
217 }
218
219 public void removeListener( ObsVectListener listener ) {
220 _observable.deleteObserver( new ObsVectAdapter( listener ) );
221 }
222
223 private class MyObservable extends Observable {
224 /**
225 * we must create a public setChanged because that method is protected
226 * in Observable
227 */
228 public void setChanged() {
229 super.setChanged();
230 }
231 }
232
233 protected class ObsVectAdapter implements Observer {
234 protected ObsVectListener _listener;
235
236 public ObsVectAdapter( ObsVectListener listener ) {
237 _listener = listener;
238 }
239
240 public void update( Observable o, Object arg ) {
241 Object[] _arg = (Object[]) arg;
242 switch( ((Integer) _arg[ 0 ]).intValue() ) {
243 case ADD:
244 _listener.onAdd( ((Integer) _arg[ 1 ]).intValue(), _arg[ 2 ] );
245 break;
246
247 case REMOVE:
248 _listener
249 .onRemove( ((Integer) _arg[ 1 ]).intValue(), _arg[ 2 ] );
250 break;
251 }
252 }
253
254 public boolean equals( Object o ) {
255 return o instanceof ObsVectAdapter
256 && _listener.equals( ((ObsVectAdapter) o)._listener );
257 }
258 }
259}