source/mir/entity/AbstractEntity.java

   1 /**
   2  * <b>abstrakte Basisklasse der Entity-Klassen</b><p>
   3  */
   4
   5
   6 package  mir.entity;
   7
   8 import java.lang.*;
   9 import java.io.*;
  10 import java.util.*;
  11 import java.sql.*;
  12
  13 import mir.storage.*;
  14 import mir.misc.*;
  15
  16 /**
  17  * abstrakte Basisklasse der Entity-Klassen
  18  *
  19  * @author RK
  20  * @version     29.6.1999
  21  *
  22  */
  23
  24 public class AbstractEntity implements Entity
  25 {
  26         private boolean             changed;
  27         protected HashMap           theValuesHash;   // tablekey / value
  28         protected StorageObject     theStorageObject;
  29         protected static Logfile    theLog;
  30         protected ArrayList         streamedInput=null;
  31         private static int instances = 0;
  32                 static {
  33                         theLog = Logfile.getInstance(MirConfig.getProp("Home") + MirConfig.getProp("Entity.Logfile"));
  34                 }
  35
  36                 public AbstractEntity() {
  37                         this.changed = false;
  38                         instances++;
  39                 }
  40
  41         /**
  42          * Konstruktor
  43          */
  44         public AbstractEntity (StorageObject StorageObject) {
  45                 this();
  46                 setStorage(StorageObject);
  47         }
  48
  49         /*
  50          * Setzt das StorageObject der Entity.
  51          */
  52         public void setStorage (StorageObject storage) {
  53                 this.theStorageObject = storage;
  54         }
  55
  56         /**
  57          * Setzt die Werte der Entity
  58          * @param theStringValues
  59          */
  60
  61         public void setValues(HashMap theStringValues)
  62         {
  63                 /** @todo should be synchronized */
  64                 theValuesHash = new HashMap();
  65                 String aKey;
  66                 Set set = theStringValues.keySet();
  67                 Iterator it = set.iterator();
  68                 int size = set.size();
  69                 for (int i = 0; i < size; i++) {
  70                         aKey = (String)it.next();
  71                         theValuesHash.put(aKey, (String)theStringValues.get(aKey));
  72                 }
  73  }
  74
  75         /**
  76          * Liefert boolschen Wert, ob sich der Inhalt der Entity geändert hat.
  77          * @return true wenn ja, sonst false
  78          */
  79         public boolean changed () {
  80                 return  changed;
  81         }
  82
  83         /**
  84          * Liefert den Primärschluessel der Entity zurueck
  85          * @return String Id
  86          */
  87         public String getId () {
  88                 return  (String)getValue(theStorageObject.getIdName());
  89         }
  90
  91         /**
  92          * Setzt den Primaerschluessel der Entity
  93          * @param id
  94          */
  95         public void setId (String id) {
  96                 theValuesHash.put(theStorageObject.getIdName(), id);
  97                         }
  98
  99         /**
 100          * Liefert den Wert für einen Feldnamen zurueck
 101          * @param theFieldString
 102          * @return Wert für Feld
 103          */
 104         public String getValue (String theFieldString) {
 105                 return  (String)theValuesHash.get(theFieldString);
 106                 }
 107
 108         /**
 109          * Fügt Entity via StorageObject in Datenbank ein.
 110          * @return Primary Key der Entity
 111          * @exception StorageObjectException
 112          */
 113         public String insert () throws StorageObjectException {
 114                 theLog.printDebugInfo("Entity: trying to insert ...");
 115                 if (theStorageObject != null) {
 116                         return  theStorageObject.insert((Entity)this);
 117                 }
 118                 else
 119                         throw  new StorageObjectException("Kein StorageObject gesetzt!");
 120         }
 121
 122         /**
 123          * Aktualisiert Aenderungen an der Entity in der Datenbank
 124          * @exception StorageObjectException
 125          */
 126         public void update () throws StorageObjectException {
 127                 theStorageObject.update((Entity)this);
 128         }
 129
 130         /**
 131          * Setzt den Wert fuer ein Feld
 132          * @param theProp
 133          * @param theValue
 134          * @exception StorageObjectException
 135          */
 136         public void setValueForProperty (String theProp, String theValue) throws StorageObjectException {
 137                 this.changed = true;
 138                 if (isField(theProp))
 139                         theValuesHash.put(theProp, theValue);
 140                 else
 141                         theLog.printWarning("Property not found: " + theProp+theValue);
 142
 143         }
 144
 145         /**
 146          * Gibt die Feldnamen der Entity als ArrayList zurueck
 147          * @return ArrayList mit Feldnamen
 148          * @exception StorageObjectException wird geworfen, wenn kein Zugriff auf die Datenbank
 149          *    möglich.
 150          */
 151         public ArrayList getFields () throws StorageObjectException {
 152                 return  theStorageObject.getFields();
 153                 }
 154
 155         /**
 156          * Liefert ein int[] mit den Typen der Felder zurueck
 157          * @return int[] mit den Feldtypen
 158          * @exception StorageObjectException
 159          */
 160         public int[] getTypes () throws StorageObjectException {
 161                 return  theStorageObject.getTypes();
 162                 }
 163
 164         /**
 165          * Liefert ArrayListe mit Feldnamen zurueck.
 166          * @return Liste mit Feldnamen
 167          * @exception StorageObjectException
 168          */
 169         public ArrayList getLabels () throws StorageObjectException {
 170                 return  theStorageObject.getLabels();
 171                 }
 172
 173         /**
 174          * Liefert eine Hashmap mit allen Werten der Entity zurueck
 175          * @return HashMap mit Feldname/Wert
 176          */
 177                 public HashMap getValues() {
 178                         return theValuesHash;
 179                 }
 180
 181                 /**
 182                  *  Liefert einen ArrayList mit allen Datenbankfeldern, die
 183                  *  als streamedInput ausgelesen werden muessen.
 184                  *  Waere automatisierbar ueber die types (blob, etc.)
 185                  *  Bisher manuell anzulegen in der erbenden Klasse
 186                  */
 187
 188         public ArrayList streamedInput() {
 189                 return streamedInput;
 190         }
 191
 192          /* Fragt ab, ob fieldName einem Feld entspricht
 193          * @param fieldName
 194          * @return true, wennn ja, sonst false
 195          * @exception StorageObjectException
 196          */
 197         public boolean isField (String fieldName) throws StorageObjectException {
 198                 return  theStorageObject.getFields().contains(fieldName);
 199         }
 200
 201          /** Liefert Anzahl der Instanzen zurück
 202          * @return int
 203          */
 204         public int getInstances() {
 205      return instances;
 206   }
 207         /**
 208          * Gibt eine Instanz frei
 209          */
 210         public void finalize () {
 211     instances--;
 212     try {
 213       super.finalize();
 214     } catch (Throwable t) {
 215       System.err.println(t.toString());
 216     }
 217   }
 218 }
 219