KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > jetspeed > portal > portlets > browser > DatabaseBrowserIterator


1 /*
2  * Copyright 2000-2001,2004 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package org.apache.jetspeed.portal.portlets.browser;
18
19 import org.apache.jetspeed.portal.portlets.browser.BrowserIterator;
20 import org.apache.jetspeed.services.logging.JetspeedLogFactoryService;
21 import org.apache.jetspeed.services.logging.JetspeedLogger;
22
23 import java.util.List JavaDoc;
24 import java.util.Collections JavaDoc;
25 import java.sql.Types JavaDoc;
26
27 /**
28  * A class for iterating over the window. The window constitutes the selection
29  * of rows being displayed to the user from the List storing all the ResultSet.
30  *
31  * @author <a HREF="mailto:taylor@apache.org">David Sean Taylor</a>
32  * @version $Id: DatabaseBrowserIterator.java,v 1.11 2004/02/23 03:26:43 jford Exp $
33  *
34 */
35 public class DatabaseBrowserIterator implements BrowserIterator
36 {
37
38     /**
39      * Static initialization of the logger for this class
40      */
41     private static final JetspeedLogger logger = JetspeedLogFactoryService.getLogger(DatabaseBrowserIterator.class.getName());
42     
43     private static final String JavaDoc VELOCITY_NULL_ENTRY = "-";
44
45     int top = 0;
46     int index = 0;
47
48     int bottom = -1;
49     int windowSize = -1;
50     int rsListSize = -1;
51
52     boolean ascendingOrder = true;
53
54     String JavaDoc sortColumnName = null;
55
56     List JavaDoc rsList;
57     List JavaDoc rsTitleList;
58     List JavaDoc rsTypeList;
59
60     /**
61      * Constructor for the database browser iterator
62      *
63      * @param result The List containg all the rows from the resultSet.
64      * @param columnTitles The List containg all the columnLabels from a resultSet.
65      * @param pageSize The number of rows to be displayed in a window configured by the user.
66      */
67     public DatabaseBrowserIterator(List JavaDoc result, List JavaDoc columnTitles,
68                                    List JavaDoc columnTypes, int pageSize)
69     {
70       this.rsList = result;
71       this.rsTitleList= columnTitles;
72       this.rsTypeList = columnTypes;
73       this.windowSize = pageSize;
74       this.rsListSize = result.size();
75       setBottom();
76     }
77
78     /**
79      * This method returns the result set.
80      *
81      */
82     public List JavaDoc getResultSet()
83     {
84         return rsList;
85     }
86
87     /**
88      * This method returns the number of rows in the result set.
89      *
90      */
91     public int getResultSetSize()
92     {
93         return rsListSize;
94     }
95
96     /**
97      * This method returns the List containg the column labels of the result set.
98      *
99      */
100     public List JavaDoc getResultSetTitleList()
101     {
102         return rsTitleList;
103     }
104     /**
105      * This method returns the List containg the column type names of the result set.
106      *
107      *@see java.sql.Types
108      */
109     public List JavaDoc getResultSetTypesList()
110     {
111         return rsTypeList;
112     }
113
114     /**
115      * This method returns the index of the row to which the cursor is pointing at.
116      *
117      */
118     public int getTop()
119     {
120         return top;
121     }
122
123     /**
124      * This method points the cursor to the index provided.
125      *
126      * @param start Index to which cursor should point to
127      */
128     public void setTop(int start)
129     {
130         top = start;
131         index = top;
132         setBottom();
133     }
134
135     /**
136      * This method returns the last index of the row in the window displayed.
137      *
138      */
139     public int getBottom()
140     {
141         return bottom;
142     }
143
144     /**
145      * This method returns the window size.
146      *
147      */
148     public int getWindowSize()
149     {
150         return windowSize;
151     }
152
153     /**
154      * This method sets the bottom based on which index the cursor points to and
155      * the size of the result set.
156      *
157      */
158     private void setBottom()
159     {
160         bottom = top + windowSize;
161         if( bottom > rsListSize )
162         {
163             bottom = rsListSize;
164         }
165     }
166
167     /**
168      * Returns true if the iteration has more elements
169      */
170     public boolean hasNext()
171     {
172         if(index <= rsListSize && index < bottom)
173         {
174             return true;
175         }
176         return false;
177     }
178
179     /**
180      * Returns the next element in the iteration
181      */
182     public Object JavaDoc next()
183     {
184         index = index + 1;
185         return rsList.get(index - 1);
186     }
187
188     /**
189      * Logs as info - since remove operation is not supported
190      * by this Iterator.
191      */
192     public void remove()
193     {
194         logger.info("The remove operation is not supported.");
195     }
196
197     /**
198      * This method sorts the result set according to the value of the column as
199      * specified by the parameter column name.
200      * Changes the order of the result set vector.
201      *
202      *@param String sortColumnName
203      */
204     public void sort(String JavaDoc columnName)
205     {
206         //System.out.println("current columnName="+columnName);
207 //System.out.println("old columnName="+sortColumnName);
208 if( columnName != null )
209         {
210             if( sortColumnName != null && sortColumnName.equals(columnName) )
211             {
212                 ascendingOrder = !ascendingOrder;
213             }
214             else
215             {
216                 ascendingOrder= true;
217                 sortColumnName = columnName;
218             }
219             Collections.sort( rsList, this);
220         }
221     }
222
223     /*
224      * Compares its two arguments for order.
225      *
226      */
227     public int compare(Object JavaDoc obj1, Object JavaDoc obj2)
228     {
229         int idx = rsTitleList.indexOf(sortColumnName);
230         int order = 0;
231
232         if( idx != -1 )
233         {
234             Object JavaDoc col1 = ((List JavaDoc)obj1).get(idx);
235             Object JavaDoc col2 = ((List JavaDoc)obj2).get(idx);
236
237             if( (col1).equals(VELOCITY_NULL_ENTRY) )
238             {
239                 if( (col2).equals(VELOCITY_NULL_ENTRY))
240                 {
241                     order = 0;
242                 }
243                 else
244                 {
245                     order = -1;
246                 }
247             }
248             else if( (col2).equals(VELOCITY_NULL_ENTRY) )
249             {
250                 order = 1;
251             }
252             else
253             {
254                 int type = Integer.parseInt((String JavaDoc)rsTypeList.get(idx));
255                 switch (type)
256                 {
257
258                 case Types.NUMERIC:
259                     order = ( ((java.math.BigDecimal JavaDoc)col1).compareTo((java.math.BigDecimal JavaDoc)col2) );
260                     break;
261
262                 case Types.DECIMAL:
263                     order = ( ((java.math.BigDecimal JavaDoc)col1).compareTo((java.math.BigDecimal JavaDoc)col2) );
264                     break;
265
266                 case Types.TINYINT:
267                     order = ( ((Byte JavaDoc)col1).compareTo((Byte JavaDoc)col2) );
268                     break;
269
270                 case Types.SMALLINT:
271                     order = ( ((Short JavaDoc)col1).compareTo((Short JavaDoc)col2) );
272                     break;
273
274                 case Types.INTEGER:
275                     order = ( ((Integer JavaDoc)col1).compareTo((Integer JavaDoc)col2) );
276                     break;
277
278                 case Types.BIGINT:
279                     order = ( ((Long JavaDoc)col1).compareTo((Long JavaDoc)col2) );
280                     break;
281
282                 case Types.REAL:
283                     order = ( ((Float JavaDoc)col1).compareTo((Float JavaDoc)col2) );
284                     break;
285
286                 case Types.FLOAT:
287                     order = ( ((Double JavaDoc)col1).compareTo((Double JavaDoc)col2) );
288                     break;
289
290                 case Types.DOUBLE:
291                     order = ( ((Double JavaDoc)col1).compareTo((Double JavaDoc)col2) );
292                     break;
293
294                 case Types.DATE:
295                     order = ( ((java.sql.Date JavaDoc)col1).compareTo((java.sql.Date JavaDoc)col2) );
296                     break;
297
298                 case Types.TIME:
299                     order = ( ((java.sql.Time JavaDoc)col1).compareTo((java.sql.Time JavaDoc)col2) );
300                     break;
301
302                 case Types.TIMESTAMP:
303                     order = ( ((java.sql.Timestamp JavaDoc)col1).compareTo((java.sql.Timestamp JavaDoc)col2) );
304                     break;
305
306                 case Types.CHAR:
307                     order = ( ((String JavaDoc)col1).compareTo((String JavaDoc)col2) );
308                     break;
309
310                 case Types.VARCHAR:
311                     order = ( ((String JavaDoc)col1).compareTo((String JavaDoc)col2) );
312                     break;
313
314                 case Types.LONGVARCHAR:
315                     order = ( ((String JavaDoc)col1).compareTo((String JavaDoc)col2) );
316                     break;
317
318                 default:
319                     logger.info("DatabaseBrowserIterator.compare DataType mapping not found"+
320                              " in DatabaseBrowserIterator. "+
321                              "Hence cannot sort based on provided column.");
322                     break;
323                 }
324             }
325         }
326         //System.out.println("index of type= "+idx +", order= "+order+", ascending= "+ascendingOrder);
327 if(!ascendingOrder)
328         {
329             order = 0-order;
330         }
331         return order;
332     }
333
334
335 }
336
Popular Tags