b73ed65d50903c9a409edfc33ca8980ca88eaa6d
[phpeclipse.git] /
1 /**********************************************************************
2  * Copyright (c) 2003 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  *
8  * Contributors:
9  *    IBM - Initial API and implementation
10  **********************************************************************/
11 package net.sourceforge.phpdt.monitor.ui.internal.view;
12
13 import java.util.List;
14 import java.util.ArrayList;
15 import java.util.Iterator;
16
17 import net.sourceforge.phpdt.monitor.core.IRequest;
18 import net.sourceforge.phpdt.monitor.core.MonitorCore;
19
20 import org.eclipse.jface.viewers.Viewer;
21 import org.eclipse.jface.viewers.ITreeContentProvider;
22 /**
23  * Content provider for the monitor server view.
24  */
25 public class MonitorTreeContentProvider implements ITreeContentProvider {
26         protected static final String ROOT = "root";
27
28         protected boolean sortByResponseTime;
29
30         /**
31          * ProxyTreeContentProvider constructor comment.
32          */
33         public MonitorTreeContentProvider() {
34                 super();
35         }
36         
37         /**
38          * Disposes of this content provider.
39          * <p>
40          * [Issue: This method should be changed to take a Viewer,
41          * renamed and repurposed to disconnect a content provider from
42          * a viewer. This is over and above what inputChanged does,
43          * which is disconnecting a content provider from the viewer's
44          * input (but not the viewer itself).
45          * ]
46          * </p>
47          */
48         public void dispose() { }
49         
50         /**
51          * Returns an iterator over the child elements of the given element.
52          * <p>
53          * Note: The difference between this method and 
54          * <code>IStructuredContentProvider.getElements</code> is
55          * that <code>getElements</code> is called to obtain the 
56          * tree viewer's root elements, whereas <code>getChildren</code> is used
57          * to obtain the children of a given node in the tree
58          * (including a root).
59          * </p>
60          * <p>
61          * [Issue: Don't know what above is trying to say.
62          *  See IStructuredContentProvider.getElements.
63          * ]
64          * </p>
65          *
66          * @param element the element
67          * @return an iterator over the child elements 
68          *    (element type: <code>Object</code>)
69          */
70         public Object[] getChildren(Object element) {
71                 if (element instanceof Integer) {
72                         Integer in = (Integer) element;
73                         List list = new ArrayList();
74                         Iterator iterator = MonitorCore.getRequests().iterator();
75                         while (iterator.hasNext()) {
76                                 IRequest call = (IRequest) iterator.next();
77                                 if (call.getLocalPort() == in.intValue())
78                                         list.add(call);
79                         }
80                         if (sortByResponseTime)
81                                 sortByResponseTime(list);
82                         return list.toArray();
83                 }
84                 return null;
85         }
86         
87         /**
88          * Returns an iterator over the elements belonging to the
89          * given element. These elements can be presented as rows in a table,
90          * items in a list, etc.
91          * <p>
92          * [Issue: Should return Object[] rather than Iterator.
93          * ]
94          * </p>
95          * <p>
96          * [Issue: Not clear what "belonging to the given element"
97          *  means. See ITreeContentProvider.getChildren.
98          * ]
99          * </p>
100          *
101          * @param element the element
102          * @return an iterator over the elements 
103          *    (element type: <code>Object</code>)
104          */
105         public Object[] getElements(Object element) {
106                 if (ROOT.equals(element)) {
107                         List list = new ArrayList();
108                         Iterator iterator = MonitorCore.getRequests().iterator();
109                         while (iterator.hasNext()) {
110                                 IRequest call = (IRequest) iterator.next();
111                                 Integer in = new Integer(call.getLocalPort());
112                                 if (!list.contains(in))
113                                         list.add(in);
114                         }
115         
116                         if (sortByResponseTime)
117                                 sortByResponseTime(list);
118         
119                         return list.toArray();
120                 } else
121                         return null;
122         }
123         
124         /**
125          * Returns the parent for the given element, or <code>null</code> 
126          * indicating that the parent can't be computed. 
127          * In this case the tree-structured viewer can't expand
128          * a given node correctly if requested.
129          *
130          * @param element the element
131          * @return the parent element, or <code>null</code> if it
132          *   has none or if the parent cannot be computed
133          */
134         public Object getParent(Object element) {
135                 if (element != null) {
136                         if (element instanceof Integer)
137                                 return ROOT;
138                         else {
139                                 IRequest call = (IRequest) element;
140                                 return new Integer(call.getLocalPort());
141                         }
142                 } else
143                         return null;
144         }
145         
146         /**
147          * Returns true if the elements are currently being sorted by response time.
148          * @return boolean
149          */
150         public boolean getSortByResponseTime() {
151                 return sortByResponseTime;
152         }
153         
154         /**
155          * Returns whether the given element has children.
156          * <p>
157          * [Issue: This method may not be warranted if getChildren
158          *  return Object[].
159          * ]
160          * </p>
161          *
162          * @param element the element
163          * @return <code>true</code> if the given element has children,
164          *  and <code>false</code> if it has no children
165          */
166         public boolean hasChildren(Object element) {
167                 return (element instanceof Integer);
168         }
169         
170         /**
171          * Notifies this content provider that the given viewer's input
172          * has been switched to a different element.
173          * <p>
174          * A typical use for this method is registering the content provider as a listener
175          * to changes on the new input (using model-specific means), and deregistering the viewer 
176          * from the old input. In response to these change notifications, the content provider
177          * propagates the changes to the viewer.
178          * </p>
179          *
180          * @param viewer the viewer
181          * @param oldInput the old input element, or <code>null</code> if the viewer
182          *   did not previously have an input
183          * @param newInput the new input element, or <code>null</code> if the viewer
184          *   does not have an input
185          */
186         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {}
187         
188         /**
189          * Sets the sort by response time option.
190          * @param b boolean
191          */
192         public void setSortByResponseTime(boolean b) {
193                 sortByResponseTime = b;
194         }
195         
196         /**
197          * 
198          */
199         protected void sortByResponseTime(List list) {
200                 int size = list.size();
201                 for (int i = 0; i < size - 1; i++) {
202                         for (int j = i + 1; j < size; j++) {
203                                 IRequest c1 = (IRequest) list.get(i);
204                                 IRequest c2 = (IRequest) list.get(j);
205                                 if (c1.getResponseTime() < c2.getResponseTime()) {
206                                         list.set(i, c2);
207                                         list.set(j, c1);
208                                 }
209                         }
210                 }
211                 
212         }
213 }