Source code: CSServerTree/CSServerTree.java
1 package CSServerTree;
2
3 import java.io.*;
4 import java.net.*;
5 import java.util.*;
6 import jcsq.CSServer;
7 import jcsq.player.Player;
8 import jcsq.serverinfo.ServerInfo;
9 import jcsq.rules.Rules;
10
11 import CSServerTree.CSServerNode.*;
12 /**
13 The <code>CSServerTree</code> object creates a binary search tree (BST) out of CounterStrike game servers. The servers can
14 be sorted with by: name, IP, ping, players, max players, and mapname.
15 (c) 2002 Mitch Davis
16 @author Mitch Davis
17 @version 0.2a
18 @see <a href="http://sourceforge.net/projects/jcsgp/">JCSGP Project</a>
19 */
20
21 public class CSServerTree
22 {
23 /**
24 Default constructor, initializes to a <code>null</code> tree and sets the size to zero
25 */
26 public CSServerTree()
27 {
28 head = null;
29 size = 0;
30 currentSort = 1;
31 }
32
33 /**
34 Constructor sets the head of the BST to a CSServerNode object with <code>server</code> and <code>info</code> stored
35
36 @param server the <code>CSServer</code> object to insert in the BST
37 @param info the <code>ServerInfo</code> object to insert in the BST alongside CSServer
38 */
39 public CSServerTree( CSServer server, ServerInfo info )
40 {
41 head = new CSServerNode( server, info );
42 head.setLeft(null);
43 head.setRight(null);
44 head.setParent(null);
45 size = 1;
46 currentSort=1;
47 }
48
49 /**
50 adds a CSServer/SeverInfo data pair into the BST
51
52 @param server the <code>CSServer</code> object to insert in the BST
53 @param info the <code>ServerInfo</code> object to insert in the BST
54 */
55 public void add( CSServer server, ServerInfo info )
56 {
57 size++;
58 CSServerNode temp = new CSServerNode( server, info );
59 CSServerNode point = head;
60 addR( point, temp );
61 }
62
63
64 /**
65 use for array-type access in the BST
66
67 @param index is a value from 0 to size-1, specifies which <code>CSServer</code> object to return
68 @return a <code>CSServer<code> object specified by <code>index</code>
69 */
70 public CSServer getServer( int index )
71 {
72 if( index >= 0 & index < size )
73 {
74 ArrayList list = getServerList();
75
76 return (CSServer)list.get(index);
77 }
78 else
79 return null;
80 }
81
82 /**
83 use for array-type access in the BST
84
85 @param index is a value from 0 to size-1, specifies which <code>ServerInfo</code> object to return
86 @return a <code>ServerInfo</code> object specified by <code>index</code>
87 */
88 public ServerInfo getInfo( int index )
89 {
90 if( index >= 0 & index < size )
91 {
92 ArrayList list = getInfoList();
93
94 return (ServerInfo)list.get(index);
95 }
96 else
97 return null;
98 }
99
100 /**
101 @return a <code>CSServer[]</code> object array in a sorted format
102 */
103 public CSServer[] getServerArray()
104 {
105 ArrayList serverList = getServerList();
106 return (CSServer[])serverList.toArray();
107 }
108
109 /**
110 @return an <code>ArrayList</code> of <code>CSServer</code> objects in a sorted format
111 */
112 public ArrayList getServerList()
113 {
114 ArrayList serverList = new ArrayList(size);
115 CSServerNode point = new CSServerNode();
116 point = head;
117
118 lister( point, serverList );
119
120 return serverList;
121 }
122
123 /**
124 @return an <code>ArrayList</code> of <code>ServerInfo</code> objects in a sorted format
125 */
126 public ArrayList getInfoList()
127 {
128 ArrayList infoList = new ArrayList(size);
129 CSServerNode point = new CSServerNode();
130 point = head;
131
132 lister_i( point, infoList );
133
134 return infoList;
135 }
136
137 /**
138 @return a <code>ServerInfo[]</code> array of <code>ServerInfo</code> objects in a sorted format
139 */
140 public ServerInfo[] getInfoArray()
141 {
142 ArrayList infoList = getInfoList();
143 return (ServerInfo[])infoList.toArray();
144 }
145
146 /**
147 re-hash the servers, use values for <code>sortMethod</code> as the following:
148 1 - server name
149 2 - IP
150 3 - ping
151 4 - players connected
152 5 - max players
153 6 - mapname
154 @param sortMethod an integer representing how to sort the servers
155 */
156 public void sortBy( int sortMethod )
157 {
158 ArrayList serverList = getServerList();
159 ArrayList infoList = getInfoList();
160 currentSort = sortMethod;
161 CSServerNode temp;
162
163 head = new CSServerNode();
164 head = null;
165
166
167 for( int i = 0; i < serverList.size(); i++ )
168 {
169 add( (CSServer)serverList.get(i), (ServerInfo)infoList.get(i) );
170 }
171 }
172
173 //recursive traversal function
174 private void lister( CSServerNode point, ArrayList list )
175 {
176 if( point != null )
177 {
178 if( point.getLeft() != null )
179 {
180 lister( point.getLeft(), list );
181 list.add( point.getServer() );
182 lister( point.getRight(), list);
183 }
184 else if( point.getRight() != null )
185 {
186 lister( point.getRight(), list );
187 }
188 else
189 {
190 list.add( point.getServer() );
191 }
192 }
193 return;
194 }
195
196 //another recursive traversal functoin
197 private void lister_i( CSServerNode point, ArrayList list )
198 {
199 if( point != null )
200 {
201 if( point.getLeft() != null )
202 {
203 lister_i( point.getLeft(), list );
204 list.add( point.getInfo() );
205 lister_i( point.getRight(), list );
206 }
207 else if( point.getRight() != null )
208 {
209 lister_i( point.getRight(), list );
210 }
211 else
212 {
213 list.add( point.getInfo() );
214 }
215 }
216 return;
217 }
218
219 //recursive function for inserting elements
220 private void addR( CSServerNode point, CSServerNode toAdd )
221 {
222 if( point != null )
223 {
224 if( compare( point.getServer(), point.getInfo(), toAdd.getServer(), toAdd.getInfo(), currentSort ) < 0 )
225 {
226 if( point.getRight() != null )
227 {
228 addR( point.getRight(), toAdd );
229 }
230 else
231 {
232 point.setRight(toAdd);
233 size++;
234 }
235 }
236 else
237 {
238 if( point.getLeft() != null )
239 {
240 addR( point.getLeft(), toAdd );
241 }
242 else
243 {
244 point.setLeft(toAdd);
245 size++;
246 }
247 }
248 }
249 else
250 {
251 head = toAdd;
252 size++;
253 }
254 }
255
256 //used for sorting
257 private int compare( CSServer server1, ServerInfo info1, CSServer server2, ServerInfo info2, int compareType )
258 {
259 switch (compareType)
260 {
261 case 1: //compare server name
262 return info1.getServerName().compareTo(info2.getServerName());
263 case 2: //compare server IP
264 return info1.getIp().compareTo(info2.getIp());
265 case 3: //comapre server Ping
266 if( server1.ping() > server2.ping() )
267 return 1;
268 else if( server1.ping() < server2.ping() )
269 return -1;
270 else
271 return 0;
272 case 4: //compare total players
273 if( info1.getPlayers() > info2.getPlayers() )
274 return 1;
275 else if( info1.getPlayers() < info2.getPlayers() )
276 return -1;
277 else
278 return 0;
279 case 5: //compare maximum players
280 if( info1.getMaxPlayers() > info2.getMaxPlayers() )
281 return 1;
282 else if( info1.getMaxPlayers() < info2.getMaxPlayers() )
283 return -1;
284 else
285 return 0;
286 case 6: //compare map
287 return info1.getMap().compareTo(info2.getMap());
288 }
289 return 0;
290 }
291
292
293
294
295 private CSServerNode head;
296 private int size;
297 private int currentSort;
298 }