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:}
|