Source Code Cross Referenced for TKVector.java in  » Content-Management-System » webman » com » teamkonzept » lib » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » Content Management System » webman » com.teamkonzept.lib 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


001:package com.teamkonzept.lib;
002:
003:import java.util.*;
004:import com.oroinc.text.regex.*;
005:import org.apache.log4j.Category;
006:
007:/**
008: * @author  $Author: mischa $
009: * @version $Revision: 1.8 $
010: */
011:public class TKVector extends Vector
012:{
013:
014:    private static final Category CATEGORY = Category.getInstance(TKVector.class);
015:	
016:	/**
017:	 * Konstruktor1 
018:	 */
019:	public TKVector()
020:	{
021:	}
022:	
023:	/**
024:	 * Konstruktor2 
025:	 */
026:	public TKVector( int initialCapacity )
027:	{
028:		super ( initialCapacity );
029:	}
030:	
031:	/****************************************************************
032:	/**
033:	 * Konstruktor3
034:	 */
035:	public TKVector( int initialCapacity, int capacityIncrement )
036:	{
037:		super ( initialCapacity, capacityIncrement );
038:	}
039:	
040:	/****************************************************************
041:	/**
042:	 * Konstruktor4 
043:	 * Ein Array wird uebergeben und in ein TK-Vector-Objekt
044:	 * ueberfuehrt.
045:	 *
046:	 * @param Object init[], ein Array
047:	 */
048:	public TKVector( Object init[] )
049:	{
050:		this ( (init == null) ? 1 : init.length );
051:		for( int i=0; i<init.length; i++ ) {
052:			addElement( init[i] );
053:		}
054:	}
055:
056:    /**
057:     * konstruktor nach jdk 1.2
058:     */
059:    public TKVector( Collection c ){
060:        super ( c );
061:    }
062:    
063:	
064:	/****************************************************************
065:	/**
066:	 * Liefert ein Element in einem verschachtelten Vector.
067:	 * Ein Element eines Vectors kann wiederum ein Vector sein usw.
068:	 * Die Laenge des Arrays gibt die Tiefe der Suche an und der Wert
069:	 * den Index des jeweiligen Vectors.
070:	 *
071:	 * @param int idxList[], Indexliste 
072:	 * @return Element des Vectors
073:	 */
074:		public Object elementAt( int[] idxList )
075:	{
076:		Vector curr = this ;
077:		int toScan = idxList.length-1;
078:		for( int i=0; i<toScan; i++ ){
079:			curr = (Vector) curr.elementAt( idxList[i] );
080:		}
081:		return curr.elementAt( idxList[toScan] );
082:	}
083:
084:	/****************************************************************
085:	/**
086:	 * Das Element des uebergebenen Index wird zuruexkgegeben
087:	 *
088:	 * @param int idx, ein Index
089:	 * @return ein Element des Vectors
090:	 */
091:	public Object get( int idx )
092:	{
093:		if( idx >= size() ) return null;
094:		return elementAt( idx );
095:	}
096:	
097:	/****************************************************************
098:	/**
099:	 * Liefert ein Element in einem verschachtelten Vector.
100:	 * Ein Element eines Vectors kann wiederum ein Vector sein usw.
101:	 * Die Laenge des Arrays gibt die Tiefe der Suche an und der Wert
102:	 * den Index des jeweiligen Vectors.
103:	 *
104:	 * @param int idxList[], Indexliste
105:	 * @return Element des Vectors
106:	 */
107:	public Object get( int[] idxList )
108:	{
109:		Object curr = this ;
110:		for( int i=0; i<idxList.length; i++ ){
111:			int idx = idxList[i];
112:			if( curr instanceof  Vector && idx < ((Vector)curr).size() ){
113:				curr = ((Vector)curr).elementAt( idxList[i] );
114:			}
115:			else{
116:				return null;
117:			}
118:		}
119:		return curr;
120:	}
121:	
122:	
123:	/****************************************************************
124:	/**
125:	 * Innerhalb eines verschachtelten Vactors wird ein Objekt gestezt. 
126:	 * Die Laenge des Arrays gibt die Tiefe an und der Wert
127:	 * den Index des jeweiligen Vectors. 
128:	 *
129:	 * @param Object obj, das zu setzende Element 
130:	 * @param int idxList[], Indexliste
131:	 */	
132:	public void setElementAt( Object obj, int[] idxList )
133:	{
134:		Vector curr = this ;
135:		int toScan = idxList.length-1;
136:		for( int i=0; i<toScan; i++){
137:			int idx = idxList[i];
138:			Object next = curr.elementAt( idx );
139:			if( (next == null) || ! (next instanceof  Vector) ) {
140:				next = new TKVector( idxList[i+1]+1 );
141:				((Vector)curr).setElementAt( next, idx );
142:			}
143:			curr = (Vector)next;
144:		}
145:		int idx = idxList[toScan];
146:		curr.setElementAt( obj, idx );
147:	}
148:	
149:	/****************************************************************	
150:	/**
151:	 * Ein Object wird auf der ersten Ebene an den 
152:	 * uebergebenen Index eingefuegt.
153:	 *
154:	 * @param Object obj, das zu setzende Element 
155:	 * @param int idx, der Index
156:	 */	
157:	public void put( int idx, Object obj )
158:	{
159:		if( idx >= size() ) setSize( idx+1 );
160:		setElementAt( obj, idx );
161:	}
162:	
163:	/****************************************************************
164:	/**
165:	 * Innerhalb eines verschachtelten Vactors wird ein Objekt eingefuegt. 
166:	 * Die Laenge des Arrays gibt die Tiefe an und der Wert
167:	 * den Index des jeweiligen Vectors. 
168:	 *
169:	 * @param Object obj, das zu setzende Element 
170:	 * @param int idxList[], Indexliste
171:	 */	
172:	public void put( int[] idxList, Object obj )
173:	{
174:		TKVector curr = this ;
175:		int toScan = idxList.length-1;
176:		for( int i=0; i<toScan; i++){
177:			int idx = idxList[i];
178:			Object next = curr.get( idx );
179:			if( (next == null) || ! (next instanceof  TKVector) ) {
180:				next = new TKVector( idxList[i+1]+1 );
181:				curr.setElementAt( next, idx );
182:			}
183:			curr = (TKVector)next;
184:		}
185:		int idx = idxList[toScan];
186:		curr.put( idx, obj );
187:	}
188:	/****************************************************************	
189:	/**
190:	 * Jedes Element des Enumerationsobjektes wird in den Vector
191:	 * eingefuegt
192:	 *
193:	 * @param Enumeration enum, enthaelt die zu setzenden Elemente 
194:	 */	
195:	public void fill( Enumeration enum )
196:	{
197:		while( enum.hasMoreElements() ) {
198:			addElement( enum.nextElement() );
199:		}
200:	}
201:
202:	/****************************************************************
203:	/**
204:	 * Sotiert einen Vector (Quick-Sort)
205:	 *
206:	 * @return den sortierten Vector 
207:	 */
208:	public TKVector sort()
209:	{
210:		Object[] array = new Object[ size() ];
211:		copyInto( array );
212:		TKLib.qsort( array );
213:		return new TKVector( array );
214:	}
215:
216:	/****************************************************************
217:	/**
218:	 * Sotiert einen Vector rueckwarts (Quick-Sort)
219:	 *
220:	 * @return den sortierten Vector 
221:	 */
222:	public TKVector rsort()
223:	{
224:		Object[] array = new Object[ size() ];
225:		copyInto( array );
226:		TKLib.qrsort( array );
227:		return new TKVector( array );
228:	}
229:
230:	/****************************************************************	
231:	/**
232:	 * Mehrfach vorkommende Elemente in einem Vector werden
233:	 * auf ein element reduziert
234:	 *
235:	 * @return den gsauberten Vector
236:	 */
237:	public TKVector unique()
238:	{
239:		TKVector result = sort();
240:		Object pre = (size() > 0 ? result.get(0) : null );
241:		for( int i=1; i<result.size(); ) {
242:			Object curr = result.get(i);
243:			if( pre == curr || pre.equals( curr ) ) {
244:				result.removeElementAt( i );
245:			}
246:			else {
247:				pre = curr;
248:				i++;
249:			}
250:		}
251:		return result;
252:	}
253:	
254:	/****************************************************************
255:	/**
256:	 * Wird ein Vector oder ein Array con Objekten uebergeben, 
257:	 * so wird jedes Element des Vectors an
258:	 * den aktuellen angehaengt, nicht der uebergebene Vector oder das
259:	 * Objekt-Array selbst.
260:	 * 
261:	 *
262:	 * @param Object add, das an den aktuellen TKVector anzuhaengende Objekt
263:	 */
264:	public void concat( Object add )
265:	{
266:		if( add == null || add instanceof  TKNull ) return;
267:		
268:		if( add instanceof  Vector ) {
269:			Vector vec = (Vector) add;
270:			int size = vec.size();
271:			if( size == 0 ) return;
272:			ensureCapacity( size() + size );
273:			for( int i=0; i<size; i++ ) {
274:				addElement( vec.elementAt( i ) );
275:			}
276:		}
277:		else if( add instanceof  Object[] ) {
278:			Object vec[] = (Object[]) add;
279:			int size = vec.length;
280:			if( size == 0 ) return;
281:			ensureCapacity( size() + size );
282:			for( int i=0; i<size; i++ ) {
283:				concat( vec[i] );
284:			}
285:		}
286:		else {
287:			addElement( add );
288:		}
289:	}
290:	
291:	/****************************************************************
292:	/**
293:	 * Zwei Vectoren werden zu einem zusammengefasst
294:	 *
295:	 * 
296:	 * @param TKVector h1, Vector 1
297:	 * @param TKVector h2, Vector 2
298:	 */
299:	public static TKVector concat( TKVector h1, TKVector h2 )
300:	{
301:		if( h1 == null ) {
302:			if( h2 == null ) {
303:				return null;
304:			}
305:			return (TKVector) h2.clone();
306:		}
307:		TKVector res = (TKVector) h1.clone();
308:		res.concat( h2 );
309:		return res;
310:	}
311:
312:	/****************************************************************
313:	/**
314:	 * Erzeugt einen String, der die Liste in perl-Notation enthält
315:	 */
316:	public String toPerlString()
317:	{
318:		return toPerlString(0, true);
319:	}
320:	
321:	/****************************************************************
322:	/**
323:	 * Erzeugt einen String, der die Liste in perl-Notation enthält
324:	 *
325:	 * @param int indentCount
326:	 * @param boolean withNewline, soll ein Newline zeichen verwendet werden?
327:	 */
328:	public String toPerlString(int indentCount, boolean withNewline)
329:	{
330:		String result = "";
331:		String indent = "";
332:                String newline = "";
333:		if( withNewline ) {
334:                    newline = System.getProperty("line.separator");
335:                    for( int i=0; i<=indentCount; i++ ){
336:                        indent += "    ";
337:                    }
338:		}
339:		
340:		Enumeration keys = elements();
341:
342:		while( keys.hasMoreElements() ) {
343:			Object val = keys.nextElement();
344:			result += indent
345:				+ ( val instanceof  TKHashtable 
346:				  ? ((TKHashtable)val).toPerlString( indentCount+1, withNewline )
347:				  : ( val instanceof  TKVector
348:				    ? ((TKVector)val).toPerlString( indentCount+1, withNewline )
349:				    : "'"+val.toString()+"'"
350:				    )
351:				  )
352:				+ ( keys.hasMoreElements() ? "," : "" )
353:				+ newline;
354:		}
355:		return "[" + newline + result + indent + "]";
356:
357:	}
358:	
359:	/****************************************************************
360:	/**
361:	 * Entfernt letztes Element
362:	 *
363:	 * @param TKVector aVector, Vector 1
364:	 */
365:	public TKVector pop () {
366:
367:		int lastIndex = this .size()-1;	
368:		this .removeElementAt(lastIndex);
369:		return this ;
370:	}
371:	
372:	/****************************************************************
373:	/**
374:	 * Auftrennen:
375:	 * Vector:	["Anna","Ute","Karin","Susi"]
376:	 * Array:	idx[]= {1,3}
377:	 * Result:	["Ute","Susi"]
378:	 *
379:	 * @param int idx[], der Array enthaelt Indizes
380:	 * @return einen neuen Teil-Vector 
381:	 */
382:	public TKVector select (int idx[]) {
383:		
384:		if(idx.length > 0 && this .size() > 0) { 
385:			TKVector resultVector = new TKVector();	
386:			for(int v=0; v < this .size(); v++) {
387:				for(int i=0; i< idx.length; i++) {
388:					if( idx[i] == v) {
389:						resultVector.addElement(this .elementAt(v));
390:					}
391:				}
392:			}
393:			return resultVector;
394:		}
395:		else return null;
396:	}
397:
398:	/****************************************************************
399:	/**
400:	 * Umdrehen
401:	 *
402:	 * @return den umgedrehten Vektor
403:	 */
404:	public TKVector reverse() {
405:	
406:		if(this .size() > 0 ) {
407:			TKVector resultVector = new TKVector();
408:			for(int i=this .size()-1; i>=0 ; i--) {
409:				resultVector.addElement(this .elementAt(i));
410:			}
411:			return resultVector;
412:		}
413:		else return null;
414:	}
415:
416:	/****************************************************************
417:	/**
418:	 * Auswahl durch Suchmuster
419:	 *
420:	 * Beispiel:
421:	 * Vector:		["Lara","Ute","Karin","Susi"]
422:	 * thePattern:	"ar"
423:	 * Result:		["Lara","Karin"]
424:	 *
425:	 * @param 	String thePattern, jedes Vektorelement, das diesen
426:	 *			String enthaelt wird in einen neuen Vector gepackt
427:	 * @return 	den Vektor mit den Elementen, die den Pattern enthalten
428:	 */
429:	public TKVector grep(String thePattern) {
430:	
431:		Pattern pattern = null;
432:		PatternCompiler compiler = TKReg.getCompiler();	
433:		PatternMatcher matcher = TKReg.getMatcher();
434:		
435:		try {
436:			pattern	= compiler.compile(thePattern, Perl5Compiler.CASE_INSENSITIVE_MASK);
437:		} catch(MalformedPatternException e) {
438:			CATEGORY.error("Bad pattern.", e);
439:		}
440:
441:		
442:		if(this .size() > 0 ) {
443:			TKVector resultVector = new TKVector();		
444:			
445:			for(int i= 0; i < this .size(); i++) {
446:				String element = this .elementAt(i).toString();
447:
448:				 if(matcher.contains(element, pattern)) {
449:				 	resultVector.addElement(element);
450:
451:				}
452:			}
453:			return resultVector;
454:		}
455:		else return null;
456:	}
457:
458:	/****************************************************************
459:	/**
460:	 * Berreich eines Vektors als neuen Vektor zurueckgeben
461:	 *
462:	 * @param int begin
463:	 * @param int end
464:	 * @return den Vektor mit den Elementen, die im Bereich lagen
465:	 */
466:	public TKVector area(int begin, int end) {
467:	
468:		if( (begin > end) || (begin > this .size()-1) ) return null;
469:		if(end > this .size()-1) end = this .size()-1;
470:		
471:		if(this .size() > 0 ) {
472:			TKVector resultVector = new TKVector();		
473:			for(int i=begin; i <= end; i++) {
474:				resultVector.addElement(this.elementAt(i));	
475:			}
476:			return resultVector;
477:		}
478:		else return null;
479:	}
480:}
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.