source/mir/entity/EntityList.java

   1 /*
   2  * put your module comment here
   3  */
   4
   5
   6 package  mir.entity;
   7
   8 import java.lang.*;
   9 import java.util.*;
  10 import mir.misc.*;
  11
  12
  13 /**
  14  *
  15  * abstrakte Containerklasse für Listen von Entities.
  16  *
  17  * @author <RK>
  18  * @version     27.6.1999
  19  */
  20 public class EntityList {
  21                 private static Logfile     theLog;
  22                 private ArrayList          theEntityArrayList;
  23                 private String             whereClause;
  24                 private String             orderClause;
  25                 private int                count;
  26                 private int                offset;
  27                 private int                offsetnext = -1;
  28                 private int                offsetprev = -1;
  29
  30         /**
  31          * Konstruktor für leere Liste von Entities
  32          */
  33                 public EntityList(){
  34                         this.theEntityArrayList = new ArrayList();
  35                         if (theLog == null)
  36                          this.theLog = Logfile.getInstance(Configuration.getProperty("Home") + Configuration.getProperty("Entity.Logfile"));
  37                 }
  38
  39         /**
  40          * Setzt die WhereClause, mit der die Entitis dieser Liste geholt wurden.
  41          * @param wc
  42          */
  43                 public void setWhere(String wc) {
  44                         this.whereClause = wc;
  45                 }
  46
  47         /**
  48          * Liefert die WhereClause zurueck, mit der die Entities geholt wurden.
  49          * @return whereClause
  50          */
  51                 public String getWhere() {
  52                         return whereClause;
  53                 }
  54
  55         /**
  56          * Setzt das Sortierkriterium fest, mit der die Entities in die Liste
  57          * gestellt wurden.
  58          *
  59          * @param oc
  60          */
  61                 public void setOrder(String oc) {
  62                         this.orderClause = oc;
  63                 }
  64
  65         /**
  66          * Liefert das Sortierkriterium der Liste zurueck.
  67          * @return orderClause
  68          */
  69                 public String getOrder() {
  70                         return orderClause;
  71                 }
  72
  73         /**
  74          * Setzt die Anzahl der Datensätze fest, die WhereClause erfüllen.
  75          * @param i
  76          */
  77                 public void setCount(int i) {
  78                         this.count = i;
  79                 }
  80
  81         /**
  82          * Liefert Anzahle der Datensätze, die WhereClause erfüllen.
  83          * @return
  84          */
  85                 public int getCount() {
  86                         return count;
  87                 }
  88
  89         /**
  90          * Setzt den Offset fest.
  91          * @param i
  92          */
  93                 public void setOffset(int i) {
  94                         offset = i;
  95                 }
  96
  97         /**
  98          * Liefert den Offset zurueck
  99          * @return offset
 100          */
 101                 public int getOffset() {
 102                         return offset;
 103                 }
 104
 105         /**
 106          * Setzt den offset für das naechste Batch von Entities fest.
 107          * @param i
 108          */
 109                 public void setNextBatch(int i) {
 110                         offsetnext = i;
 111                 }
 112
 113         /**
 114          * Liefert den offset für das naechste Batch von Entities
 115          * @return offset für naechstes Batch
 116          */
 117                 public int getNextBatch() {
 118                         return offsetnext;
 119                 }
 120
 121         /**
 122          * Fragt ab, ob es noch nachfolgendes Batch innerhalb der WhereClause gibt
 123          * @return
 124          */
 125                 public boolean hasNextBatch() {
 126                         return (offsetnext >= 0);
 127                 }
 128
 129         /**
 130          * Setzt offset des vorhergehenden Batches fest.
 131          * @param i
 132          */
 133                 public void setPrevBatch(int i) {
 134                         offsetprev = i;
 135                 }
 136
 137         /**
 138          * Liefert offset des vorhergehenden Batches zurueck.
 139          * @return offset des vorhergehenden Batches.
 140          */
 141                 public int getPrevBatch() {
 142                         return offsetprev;
 143                 }
 144
 145         /**
 146          * Fragt ab, ob es ein vorhergehendes Batch gibt
 147          * @return true wenn ja, sont false
 148          */
 149                 public boolean hasPrevBatch() {
 150                         return (offsetprev >= 0);
 151                 }
 152
 153         /**
 154          * Liefert den Startindex des Batches zurueck.
 155          * @return
 156          */
 157                 public int getFrom() {
 158                         return offset+1;
 159                 }
 160
 161         /**
 162          * Liefert den Endindex des Batches zurueck.
 163          * @return
 164          */
 165                 public int getTo() {
 166         if (hasNextBatch())
 167                         return offsetnext;
 168         else
 169                         return count;
 170                 }
 171
 172         /**
 173          * Fügt eine Entity in die Liste ein
 174          * @param anEntity
 175          */
 176         public void add (Entity anEntity) {
 177         if (anEntity!=null)
 178                         theEntityArrayList.add(anEntity);
 179         else
 180                         theLog.printWarning("add (EntityList) mit leerer Entity");
 181                 }
 182
 183         /**
 184          * @return Anzahl der Entities in der Liste
 185          */
 186                 public int size() {
 187         return theEntityArrayList.size();
 188                 }
 189
 190
 191
 192
 193
 194
 195                 public Entity elementAt(int i) {
 196                         return (Entity)theEntityArrayList.get(i);
 197                 }
 198
 199 }