f87f14d194e1b60132266e5ffe5161c5000e3159
[phpeclipse.git] / archive / net.sourceforge.phpeclipse.quantum.sql / src / com / quantum / util / StringMatrix.java
1 /*
2  * Created on 8/04/2003
3  *
4  */
5 package com.quantum.util;
6
7 import java.util.Vector;
8
9 /**
10  * @author jparrai
11  * Generic class to hold a Matrix of Strings, that is a Vector of Vectors of Strings.
12  * The first Vector "line" is supposed to have headers to the values of the rest.
13  * Those headers will always be case insensitive
14  */
15 public class StringMatrix {
16         private final int DEFAULT_COLUMNS = 10;
17         private final int DEFAULT_ROWS = 10;
18         private final int DEFAULT_INCREMENT = 10;
19         
20         private Vector header = new Vector(DEFAULT_COLUMNS,DEFAULT_INCREMENT);
21         private Vector matrix = new Vector(DEFAULT_ROWS,DEFAULT_INCREMENT);
22         
23         /**
24          * Adds a String to the end of the header keys
25          * @param header : The string to be added
26          */
27         public void addHeader(String header) {
28                         this.header.add(header);
29         }
30         /**
31          * Adds a whole vector to the header
32          * @param header
33          */
34         private void addVectorHeader(Vector header){
35                         this.header.addAll(header);
36                         for (int i = 0; i < this.header.size(); i++) {
37                                 String element = (String) this.header.get(i);
38                                 this.header.setElementAt(element, i);                   
39                         }
40         }
41         /**
42          * Adds a whole matrix to the header
43          * @param header
44          */
45         public void addMatrixHeader(String header[]){
46                         for (int i = 0; i < header.length; i++) {       
47                                 String element = (String) header[i];
48                                 this.header.add(element);                       
49                         }
50         }
51         /**
52          * Adds a String to the end of the row indicated
53          * @param value : The string to be added
54          * @param row : The row to 
55          */
56         public void add(String value, int row) {
57                 grow(row);
58                 Vector rowVector = (Vector) matrix.get(row);
59                 rowVector.add(value);
60         }
61         /**
62          * Adds a StringMatrix to the end of the row indicated
63          * @param value : The string to be added
64          * @param row : The row to 
65          */
66         public void add(StringMatrix value) {
67                 int row = matrix.size();
68                 for (int i = 0; i < value.size(); i++){
69                         grow(row);
70                         for (int j = 0; j < value.getNumColumns(); j++){
71                                 String header = value.getHeaderColumn(j); 
72                                 addAt(header, value.get(header,i), row);
73                         }
74                         row++;
75                 }
76                 Vector rowVector = (Vector) matrix.get(row);
77                 rowVector.add(value);
78         }
79         
80         /**
81          * Converts the StringMatrix into a copy of the given
82          * @param origin - The StringMatrix to be copied
83          */
84         public void copy(StringMatrix origin) {
85                 clear();
86                 add(origin);
87         }
88         
89         /**
90          * Clears (emtpies) the StringMatrix
91          */
92         public void clear(){
93                 header.clear();
94                 matrix.clear();
95         }
96         /**
97         * Adds a String to the row indicated, to the column that matches the key 
98         * @param value : The string to be added
99         * @param row : The row to 
100         */
101         public void addAt(String key, String value, int row) {
102                 grow(row);
103                 Vector rowVector = (Vector) matrix.get(row);
104                 int ind = header.indexOf(key);
105                 if (ind < 0) return;
106                 if (rowVector.size() < ind+1) rowVector.setSize(ind);
107                 rowVector.add(ind, value);
108         }
109         /**
110          * Adds a whole vector to the end of the row indicated
111          * @param value : The vector to be added
112          * @param row : The row to 
113          */
114         private void addVector(Vector value, int row){
115                 grow(row);
116                 Vector rowVector = (Vector) matrix.get(row);
117                 rowVector.addAll(value);
118         }
119         
120         /**
121          * Tells if you have that particular key in your StringMatrix
122          * @param key
123          * @return 
124          */
125         public boolean contains(String key){
126                 return (findKey(key) >= 0);
127         }
128         /**
129          * Gets a String value from the row indicated, from the column that matches the key
130          * @param key
131          * @param row
132          * @return
133          */
134         public String get(String key, int row){
135                 if (matrix.size() <= row) return null;
136                 int col = findKey(key);
137                 if (col < 0) return null; 
138                 Vector rowVector = (Vector) matrix.get(row);
139                 if (rowVector ==  null) return null;
140                 return (String) rowVector.get(col);
141         }
142         /**
143          * Finds the key in the header
144          * @param key
145          * @return
146          */
147         private int findKey(String key) {
148                 for (int i = 0; i < header.size(); i++) {
149                         String element = (String) header.get(i);
150                         if (element.equalsIgnoreCase(key)) return i;
151                 }
152                 return -1;
153         }
154         /**
155          * @param key: selects the column
156          * @return a Vector with all the values in the selected column; null if empty
157          */
158         public Vector getColumn(String key){
159                 if (size() < 1 ) return null;
160                 Vector result = new Vector(size(),1);
161                 for (int i = 0; i < size(); i++){
162                         result.add(get(key, i));
163                 }
164                 return result;
165         }
166         /**
167          * @param key: selects the column
168          * @return a Vector with all the values in the selected column, dropping duplicates; null if empty
169          */
170         public Vector getUniqueColumn(String key){
171                 if (size() < 1 ) return null;
172                 Vector result = new Vector(size(),1);
173                 for (int i = 0; i < size(); i++){
174                         if (!result.contains(get(key, i))) result.add(get(key, i));
175                 }
176                 return result;
177         }
178         /**
179          * @param key: selects the column
180          * @return a Vector of Integers with all the indexes of the rows
181          * matching the selected column, dropping duplicates; null if empty
182          */
183         public Vector getIndexes(String key, String value){
184                 Vector result = new Vector();
185                 for (int i = 0; i < size(); i++){
186                         if (get(key, i).equals(value))
187                                 result.add(new Integer(i));
188                 }
189                 return result;
190         }
191         /**
192          * Deletes all the rows that matches the value for the key
193          * @param key: selects the column
194          */
195         public void dropMatching(String key, String value){
196                 for (int i = 0; i < size(); i++){
197                         if (get(key, i).equals(value)) deleteRow(i);
198                 }
199         }
200         /**
201          * Returns a StringMatrix with all the complete rows that match the key - value pair
202          * @param key The column key
203          * @param value The value to match
204          * @return a StringMatrix with only the rows where the key equals the value
205          */
206         public StringMatrix select(String key, String value){
207                 StringMatrix result = new StringMatrix();
208                 result.addVectorHeader(header);
209                 int j = 0;
210                 for (int i = 0; i < size(); i++){
211                         if (get(key, i).equals(value)) {
212                                 result.addVector((Vector)matrix.get(i), j);
213                                 j++;
214                         } 
215                 }
216                 return result;
217         }
218
219         // Private functions
220         /**
221          * Grows the StringMatrix till it's able to hold "row" rows.
222          * @param row : The number of rows that must hold
223          */
224         private void grow(int row) {
225                 if (matrix.size() <= row)
226                         for (int i = matrix.size(); i <= row; i++) {
227                                 matrix.add(new Vector(header.size(), 1));
228                         }
229         }
230         /**
231          * Gets a String value from the row indicated , from the column number
232          * @param col : 0-index column 
233          * @param row : 0-index column
234          * @return
235          */
236         private String get(int col, int row){
237                 if (col < 0 || row < 0) return null; 
238                 Vector rowVector = (Vector) matrix.get(row);
239                 if (rowVector ==  null) return null;
240                 return (String) rowVector.get(col);
241         }
242         
243         // Generic interfaces
244         /**
245          * @param i
246          * @return : a StringMatrix with only one row, the selected by i
247          */
248         public StringMatrix rowMatrix(int i){
249                 StringMatrix result = new StringMatrix();
250                 result.addVectorHeader(header);
251                 result.addVector((Vector)matrix.get(i),0);
252                 return result;
253         }
254         
255         /**
256          * Resturns a String[] with the selected row
257          * @param i The index of the row
258          * @return
259          */
260         public String[] getRow(int i) {
261                 if (i < matrix.size()) {
262                         String[] result = new String[header.size()];
263                         Vector resVector = (Vector)matrix.get(i);
264                         resVector.toArray(result); 
265                         return result;
266                 }
267                 return null;
268                 
269         }
270
271
272         /**
273          * @return the number of rows
274          */
275         public int size() {
276                 return matrix.size();
277         }
278         public int getNumColumns() {
279                 return header.size();
280         }
281         public String getHeaderColumn(int i){
282                 return (String) header.get(i);
283         }
284         public void deleteRow(int i){
285                 matrix.remove(i);
286         }
287
288
289         // Common Object interface
290         /* (non-Javadoc)
291          * @see java.lang.Object#clone()
292          */
293         public Object clone() {
294                 // Deep clone
295                 StringMatrix matrix = new StringMatrix();
296                 matrix.copy(this);
297                 return matrix;
298         }
299
300         /* (non-Javadoc)
301          * @see java.lang.Object#toString()
302          */
303         public String toString() {
304                 String result = "";
305                 for (int j = 0; j < header.size(); j++){
306                         result += (String) header.get(j);
307                         result += "\t";
308                 }
309                 result += "\n";
310                 // Write the lines
311                 for (int i = 0; i < matrix.size(); i++){
312                         for (int j = 0; j < header.size(); j++){
313                                 result += get(j,i);
314                                 result += "\t";
315                         }
316                         result += "\n";
317                 }
318                 return result;
319         }
320
321         /* (non-Javadoc)
322          * @see java.lang.Object#equals(java.lang.Object)
323          */
324         public boolean equals(Object obj) {
325                 if (!(obj instanceof StringMatrix)) return false;
326                 StringMatrix sm = (StringMatrix) obj;
327                 if (!header.equals(sm.header)) return false;
328                 if (matrix.size() != sm.matrix.size()) return false;
329                 for (int i = 0; i < matrix.size(); i++){
330                         Vector row = (Vector) matrix.get(i);
331                         Vector smRow = (Vector) sm.matrix.get(i);
332                         if (!(row.equals(smRow))) return false;
333                 }
334                 return true;
335         }
336
337         /**
338          * @return
339          */
340         public Vector getMatrix() {
341                 return matrix;
342         }
343         /**
344          * @return
345          */
346         public String[] getHeader() {
347                 String[] result = new String[header.size()];
348                 header.toArray(result);
349                 return result;
350         }
351
352 }