Mein Knecht: meine Env-Klasse (Datenstruktur)

Hallo Alle,

sicherlich, die erfahrene Programmierer haben schon mit eigenen
Datenstrukturen experimentiert und das habe ich auch.

Ich möchte also hier all denjenigen den es interessiert eine praktische
Datenstruktur vorstellen welches ich nicht mehr missen möchte:
Eine spezialisierung der Klasse java.util.Hashtable welches ich im Buch
"Professional Java XML Programming with Servlets and JSP" der Autoren
Alexander Nakhimovsky und Tom Myers entdeckt habe und für meine Belangen
erweitert habe.

Die Autoren nannten Ihre Klasse 'Env' (für Environment) weil sie damit
ursprunglich sowas wie Inidateien einlasen und diese in dieser Struktur
immer praktisch zur Vefügung standen.
Ich habe den Namen beibehalten, der ist fester Bestandteil meiner
Klassensammlung!

Wofür benutze ich Env?
1. Nun es gibt ne Menge Möglichkeiten, das Wichtigste ist aber dass ich mit
Env ein Datenkontainer habe womit ich einfach Daten von A, in B zur
Disposition stellen kann.

2. Weiter habe ich ein Konstrukt welches mir die Daten immer in eine bestimme
Weise darstellen kann.

3. Als Input kann ich diverse Formate und Datentypen übergeben

4. Weil ich schon 8 verschiedene Datensubstraktionsmethoden habe
und alle Methoden der HashTable-Klasse weiterhin nutzen kann

5. Mit einen Env kann ich bequem HTML-Tables etc. bauen

6. ...etc. , etc. , etc.

Sicherlich ist dieser mit noch weiteren interessanten Methoden zu erweiteren
und würde mich freuen wenn ein gewisses Feedback zustande kommt.


Schauen wir uns Env einfach mal an:

//package marloos.tools;    Anpassen!

import java.util.*;
import java.io.*;

public class Env extends Hashtable
{


/*-- Default --*/
   public Env()
   {}
   
/*-- Mit Hashtable --*/
   //Der Hahstable wird 1 zu 1 in unseren Env kopiert!
   public Env(Hashtable ht) throws Throwable
   {
    Enumeration e=ht.keys() ;
    while(e.hasMoreElements())
    {
      String s = (String)e.nextElement();
      put(s, ht.get(s));
    }
   }
   
   
/*-- Mit StringArray --*/
   //Die StringArray-Werte werden als Schlüssel genutzt
   public Env(String[] obj) throws Throwable
   {
   	for(int i=0;i<obj.length;i++)
    	{
      	put(obj[i], "");
      }
   }
   
/*-- Mit StringArray und Object-Array --*/
   //Die StringArray-Werte werden als Schlüssel genutzt
   //Die ObjectArray-Werte als Value
   public Env(String[] obj, Object[] obj2) throws Throwable
   {
   	if(obj.length==obj2.length)
   	{   
   		for(int i=0;i<obj.length;i++) put(obj[i], obj2[i]);
      	}
   }
   
/*-- Mit javax.servlet.http.HttpServletRequest --*/
  /* Sehr angenehme Sache im JSP: 
       Env env=new Env(request);
     und schon kann ich z.B.:
       if(env.getStr("action").equals("msgsenden"))
    mein Request abfragen 
    Siehe auch die GETTER's
  */
  
  public Env(javax.servlet.http.HttpServletRequest req)  throws Throwable
  {
   	Enumeration E = req.getParameterNames();
   	while(E.hasMoreElements())
   	{
   		String name = (String)E.nextElement();
   		String[] vals = req.getParameterValues(name);
   		if(vals.length!=1) //String array
   			this.put(name,vals);
   		else this.put(name,vals[0]); //single String
   	}
  }

/*-- Filename als Stringwert --*/
  /*Praktisch für Inidateien mit key/value in je eine Zeile
   z.B.
   driver
  	com.mysql.jdbc.Driver
  
   Dieser Konstruktor nutzt einen Service meiner Klasse FileServices welches
   einen BufferedReader zurückgibt.
   Über die eigene Methode readIn(StringBuffer ein) werden die key/values eingelesen
  */
  public Env(String filename)  throws Throwable
  {
  	BufferedReader ein = FileServices.getBufferedReader(filename);
  	readIn(ein);
  }
  
/*-- Mit BufferedReader --*/
  public Env(BufferedReader ein) throws Throwable
  {
	readIn(ein);
  }
  
/*-- Ende Konstruktoren --*/


/*-READIN'S-- 
   Hier wird ein BufferedReader eingelesen
   1. Zeile = Key
   2. Zeile = Valaue
   Zeilen die mit // beginnen werden als Kommentarzeilen erkannt
*/
 public void readIn(BufferedReader ein) throws Throwable
 {
    	String aLine = "" ;
    	while( (aLine = ein.readLine() )!= null )
    	{
    	 	aLine = aLine.trim();
    	 	if( aLine.length()>0 )
    	 	{
    		    	if( ! aLine.startsWith("//") )
	    		{
    		   		String s = ein.readLine().trim();
    		   		put(aLine,s);
    			}
    		}
    	}  
 }



/*-READOUT's --
   Eine formatierte ausgabe der Daten.
   Die Methode benutzt dazu Services meiner Klasse Ersetzen welche ich an
   dieser Stelle nicht erklären möchte, dennoch kann man sich schon 
   hinein denken
*/

  protected static int indent=-3;
  protected int width=30;
  protected String basic=Ersetzen.getStringVon(".",width);

 public String toString()
 {
    StringBuffer sb = new StringBuffer();
    Enumeration   E = keys();
  
    while(E.hasMoreElements())
    {
  	String key = (String)E.nextElement();
  	
        sb.append("\n").append(key);
    	sb.append(basic.substring( 0 ,  width - key.length() ) + " "  );
    	sb.append(get(key).toString()) ;
    }
    return sb.toString();
 }


/*-DO's--*/

/* -- Werte löschen und durch einen definierten Wert ersetzen weil ich
      in meine Anwendung keine leere Werte möchte.
*/
 public void resetValues() throws Throwable
 {
 	Enumeration E=keys();
 	while ( E.hasMoreElements())
 	{
 		String k = (String)E.nextElement();
 		put(k,"NV");
 	}
 }
 public void resetValues(Object obj) throws Throwable
 {
 	Enumeration E=keys();
 	while ( E.hasMoreElements())
 	{
 		String k = (String)E.nextElement();
 		put(k,obj);
 	}
 }

/*-GET's--*/
 
 /* -- Gibt garantiert ein Integerwert zurück -- */
 public int getInt(String key) throws Throwable
 {
 	Object obj = this.get(key);
 	if( obj instanceof String)
 	{
 		try{
 			return new Integer( (String)obj).intValue();
 		}catch(Throwable t){return -1;}
 	}
 	else return 0;
 }

/* -- Gibt garantiert ein Stringwert zurück -- */
 public String getStr(String key) throws Throwable
 {
 	Object obj = this.get(key);
 	if( obj instanceof String) return (String)obj;
 	else return "";
 }

/* -- Gibt garantiert ein StringArray von Stringwerte zurück -- */
 public String[] getStrSeq(String key) throws Throwable
 {
 	Object obj = this.get(key);
 	if( obj instanceof String[]) return (String[])obj;
 	else if ( obj instanceof String) return new String[]{(String)obj};
 	else return new String[]{};
 }
 
 /* -- Gibt garantiert ein StringArray der Keys zurück -- */
 public String[] getKeyStringSeq() throws Throwable
 {
    String[] ret=new String[size()];
    Enumeration E = keys();
    int z=0;
    while(E.hasMoreElements())ret[z++]=(String)E.nextElement();
    return ret;
 }

/* -- Gibt garantiert ein StringArray der Value zurück -- */
 public String[] getValStringSeq() throws Throwable
 {
    String[] ret=new String[size()];
    Enumeration E = keys();
    int z=-1;
    while(E.hasMoreElements())
    {
    	String k=  (String)E.nextElement();
    	ret[++z] = getStr(k);
    }
    return ret;
 }

/* -- Behält nur die welche im Value, Werte v enthalten -- */
 public void retainAllValuesThatContains(Object v) throws Throwable
 {
 	Env v2 = (Env)this.clone();
 	Enumeration E=v2.keys();
 	while(E.hasMoreElements())
 	{
 		String k=(String)E.nextElement();
 		Object obj=v2.get(k);

 		if( (obj instanceof String && v instanceof String) && !obj.equals(v) ) this.remove(k);
 		if( (obj instanceof String[] && v instanceof String[]) && !obj.equals(v) ) this.remove(k);
 		if( (obj.getClass()!=v.getClass()) ) this.remove(k); //ObjectClass

 	}
 	v=null;
 }

/* -- Behält nur die welche im Key, Werte wie  v enthalten -- */
 public void retainAllKeysThatContains(String v) throws Throwable
 {
 	Env v2 = (Env)this.clone();
 	Enumeration E=v2.keys();
 	while(E.hasMoreElements())
 	{
 		String k=(String)E.nextElement();
 		if(k.indexOf(v)==-1) remove(k);
 	}
 	v=null;
 }

/* -- Behalte nur die welche im Key oder im Value v enthalten -- */
 public void retainAllThatContains(String v) throws Throwable
 {
        Env e1=null;
 	Env v2 = (Env)this.clone();
 	Enumeration E=v2.keys();
 	while(E.hasMoreElements())
 	{
 		String k=(String)E.nextElement();
 		Object obj=get(k);
 		
 		if(obj instanceof Hashtable)
 		{
 			e1=new Env((Hashtable)obj);
 			if(k.indexOf(v)==-1 && e1.toString().indexOf(v)==-1 ) remove(k);
 		}
 		if(obj instanceof Env)
 		{
 			if(k.indexOf(v)==-1 && ((Env)obj).toString().indexOf(v)==-1 ) remove(k);
 		}
 		if(obj instanceof String)
 		{
 			if(k.indexOf(v)==-1 && ((String)obj).indexOf(v)==-1 ) remove(k);
 		}
 		if(obj instanceof  java.lang.reflect.Array)
 		{
 			e1=new Env();
                	String kStr[]=new String[java.lang.reflect.Array.getLength(obj)];
 			for(int i=0;i<kStr.length ;i++) kStr[i]=""+i;
 			
 			e1.put( kStr, obj);
			if(k.indexOf(v)==-1 && ((Env)e1).toString().indexOf(v)==-1 ) remove(k);
 		}
 	}
 	v=null;
 }
}