001 //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/model/table/DefaultTable.java $
002 /*----------------------------------------------------------------------------
003 This file is part of deegree, http://deegree.org/
004 Copyright (C) 2001-2009 by:
005 Department of Geography, University of Bonn
006 and
007 lat/lon GmbH
008
009 This library is free software; you can redistribute it and/or modify it under
010 the terms of the GNU Lesser General Public License as published by the Free
011 Software Foundation; either version 2.1 of the License, or (at your option)
012 any later version.
013 This library is distributed in the hope that it will be useful, but WITHOUT
014 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
015 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
016 details.
017 You should have received a copy of the GNU Lesser General Public License
018 along with this library; if not, write to the Free Software Foundation, Inc.,
019 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
020
021 Contact information:
022
023 lat/lon GmbH
024 Aennchenstr. 19, 53177 Bonn
025 Germany
026 http://lat-lon.de/
027
028 Department of Geography, University of Bonn
029 Prof. Dr. Klaus Greve
030 Postfach 1147, 53001 Bonn
031 Germany
032 http://www.geographie.uni-bonn.de/deegree/
033
034 e-mail: info@deegree.org
035 ----------------------------------------------------------------------------*/
036 package org.deegree.model.table;
037
038 import java.util.ArrayList;
039 import java.util.HashMap;
040
041 /**
042 *
043 *
044 *
045 * @author <a href="mailto:poth@lat-lon.de">Andreas Poth</a>
046 * @author last edited by: $Author: mschneider $
047 *
048 * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $
049 */
050 public class DefaultTable implements Table {
051
052 private String tableName = "";
053
054 private ArrayList<ArrayList<Object>> rows = null;
055
056 private String[] columnNames = null;
057
058 private int[] columnTypes = null;
059
060 private HashMap<String, Integer> columnNamesMap = new HashMap<String, Integer>();
061
062 /**
063 * @param tableName
064 * @param columnNames
065 * @param columnTypes
066 * @throws TableException
067 */
068 public DefaultTable( String tableName, String[] columnNames, int[] columnTypes ) throws TableException {
069 setTableName( tableName );
070
071 if ( columnTypes == null )
072 throw new TableException( "Invalid column types. Column types = null" );
073
074 this.columnTypes = columnTypes;
075
076 if ( columnNames == null ) {
077 this.columnNames = new String[columnTypes.length];
078 for ( int i = 0; i < this.columnNames.length; i++ ) {
079 this.columnNames[i] = "";
080 }
081 } else {
082 this.columnNames = new String[columnNames.length];
083 for ( int i = 0; i < columnNames.length; i++ ) {
084 this.columnNames[i] = columnNames[i].toUpperCase();
085 columnNamesMap.put( this.columnNames[i], new Integer( i ) );
086 }
087 }
088
089 if ( columnTypes.length != this.columnNames.length ) {
090 throw new TableException( "column names and types are not of the " + "same length" );
091 }
092
093 rows = new ArrayList<ArrayList<Object>>( 1000 );
094 }
095
096 /**
097 * @param tableName
098 * @param columnNames
099 * @param columnTypes
100 * @param data
101 * @throws TableException
102 */
103 public DefaultTable( String tableName, String[] columnNames, int[] columnTypes, Object[][] data )
104 throws TableException {
105 this( tableName, columnNames, columnTypes );
106
107 rows = new ArrayList<ArrayList<Object>>( data.length );
108 for ( int i = 0; i < data.length; i++ ) {
109 appendRow( data[i] );
110 }
111 }
112
113 /**
114 * @param tableName
115 * @param columnNames
116 * @param columnTypes
117 * @param initialCapacity
118 * @throws TableException
119 */
120 public DefaultTable( String tableName, String[] columnNames, int[] columnTypes, int initialCapacity )
121 throws TableException {
122 this( tableName, columnNames, columnTypes );
123 rows.ensureCapacity( initialCapacity );
124 }
125
126 /**
127 * returns the name of the table. If the table hasn't a name an empty string ("") will be
128 * returned.
129 *
130 */
131 public String getTableName() {
132 return tableName;
133 }
134
135 /**
136 * @see org.deegree.model.table.DefaultTable#getTableName()
137 *
138 */
139 public void setTableName( String tableName ) {
140 this.tableName = tableName;
141 }
142
143 /**
144 * returns the value of the table field indexed by <tt>row</tt> and <tt>col</tt>
145 */
146 public Object getValueAt( int row, int col ) {
147 ArrayList tmp = rows.get( row );
148 return tmp.get( col );
149 }
150
151 /**
152 * set a value at the table field indexed by <tt>row</tt> and <tt>col</tt>
153 */
154 public void setValueAt( Object value, int row, int col ) {
155 ArrayList<Object> tmp = rows.get( row );
156 tmp.set( col, value );
157 }
158
159 /**
160 * returns the data of the row'th row of the table
161 */
162 public Object[] getRow( int row ) {
163 ArrayList<Object> tmp = rows.get( row );
164 return tmp.toArray();
165 }
166
167 /**
168 * sets the data of the row'th row
169 */
170 public void setRow( Object[] data, int row )
171 throws TableException {
172 if ( this.getColumnCount() != data.length ) {
173 throw new TableException( "submitted row doesn't have the same length" + " as the table has columns." );
174 }
175 ArrayList<Object> tmp = rows.get( row );
176
177 for ( int i = 0; i < data.length; i++ ) {
178 tmp.set( i, data[i] );
179 }
180 }
181
182 /**
183 * appends a row to the table and sets its data
184 */
185 public void appendRow( Object[] data )
186 throws TableException {
187 if ( this.getColumnCount() != data.length ) {
188 throw new TableException( "submitted row doesn't have the same length" + " as the table has columns." );
189 }
190 ArrayList<Object> tmp = new ArrayList<Object>( data.length );
191 for ( int i = 0; i < data.length; i++ ) {
192 tmp.add( data[i] );
193 }
194 rows.add( tmp );
195 }
196
197 /**
198 * returns the number rows of the table
199 */
200 public int getRowCount() {
201 return rows.size();
202 }
203
204 /**
205 * adds a new column to the table. for this a computional expensive operation this method should
206 * be used with care.
207 */
208 public void addColumn( String name, int type ) {
209 String[] s1 = new String[columnNames.length + 1];
210 int[] s2 = new int[columnNames.length + 1];
211 for ( int i = 0; i < columnNames.length; i++ ) {
212 s1[i] = columnNames[i];
213 s2[i] = columnTypes[i];
214 }
215 s1[s1.length - 1] = name;
216 s2[s2.length - 1] = type;
217 columnNames = s1;
218 columnTypes = s2;
219
220 for ( int i = 0; i < rows.size(); i++ ) {
221 ArrayList<Object> tmp = rows.get( i );
222 tmp.add( "" );
223 }
224
225 }
226
227 /**
228 * returns the number columns of the table
229 */
230 public int getColumnCount() {
231 return columnNames.length;
232 }
233
234 /**
235 * returns the names of all table columns. If a column hasn't a name a empty String ("") will be
236 * returned.
237 *
238 */
239 public String[] getColumnNames() {
240 return columnNames;
241 }
242
243 /**
244 * returns the name of the specified column. If a column hasn't a name a empty String ("") will
245 * be returned.
246 */
247 public String getColumnName( int col ) {
248 return columnNames[col];
249 }
250
251 /**
252 * returns the names of all column types. For each column a type (name of a java class) has to
253 * be defined.
254 *
255 */
256 public int[] getColumnTypes() {
257 return columnTypes;
258 }
259
260 /**
261 * returns the name of the type of the specifies column. For each column a type (name of a java
262 * class) has to be defined.
263 */
264 public int getColumnType( int col ) {
265 return columnTypes[col];
266 }
267
268 /**
269 * sets the type of a column.
270 */
271 public void setColumnType( int col, int type )
272 throws TableException {
273 columnTypes[col] = type;
274 }
275
276 /**
277 * sets the name of a column.
278 */
279 public void setColumnName( int col, String name ) {
280 columnNames[col] = name;
281 }
282
283 /**
284 * removes a row from the table
285 *
286 * @param index
287 * @return removed row
288 */
289 public Object[] removeRow( int index ) {
290 ArrayList<Object> list = rows.remove( index );
291 return list.toArray();
292 }
293
294 /**
295 * returns the index of the submitted columns name. If no column with that name if present -1
296 * will be returned. the test is not case sensitive
297 *
298 * @param columnName
299 */
300 public int getColumnIndex( String columnName ) {
301 Integer index = columnNamesMap.get( columnName.toUpperCase() );
302 return index.intValue();
303 }
304
305 /**
306 * @return string representation
307 */
308 public String toString() {
309 StringBuffer sb = new StringBuffer( 100000 );
310 for ( int i = 0; i < getRowCount(); i++ ) {
311 sb.append( "row: " + i );
312 for ( int c = 0; c < getColumnCount(); c++ ) {
313 sb.append( getColumnName( c ) + ": " + getValueAt( i, c ) );
314 }
315 }
316 return sb.toString();
317 }
318 }