--- a/flys-artifacts/src/main/java/de/intevation/flys/artifacts/FLYSArtifact.java	Fri Jun 17 13:00:54 2011 +0000
+++ b/flys-artifacts/src/main/java/de/intevation/flys/artifacts/FLYSArtifact.java	Fri Jun 17 16:17:03 2011 +0000
@@ -4,6 +4,7 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.TreeMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -12,6 +13,8 @@
 
 import gnu.trove.TDoubleArrayList;
 
+import net.sf.ehcache.Cache;
+
 import org.apache.log4j.Logger;
 
 import org.w3c.dom.Document;
@@ -28,6 +31,7 @@
 import de.intevation.artifactdatabase.DefaultArtifact;
 import de.intevation.artifactdatabase.data.DefaultStateData;
 import de.intevation.artifactdatabase.data.StateData;
+import de.intevation.artifactdatabase.state.Facet;
 import de.intevation.artifactdatabase.state.State;
 import de.intevation.artifactdatabase.state.StateEngine;
 import de.intevation.artifactdatabase.transition.TransitionEngine;
@@ -40,11 +44,14 @@
 
 import de.intevation.flys.artifacts.context.FLYSContext;
 
+import de.intevation.flys.artifacts.cache.CacheFactory;
+
 import de.intevation.flys.artifacts.model.DischargeTables;
 import de.intevation.flys.artifacts.model.RiverFactory;
 import de.intevation.flys.artifacts.model.Segment;
 
 import de.intevation.flys.artifacts.states.DefaultState;
+import de.intevation.flys.artifacts.states.DefaultState.ComputeType;
 import de.intevation.flys.artifacts.states.LocationDistanceSelect;
 
 
@@ -59,6 +66,8 @@
     private static Logger logger = Logger.getLogger(FLYSArtifact.class);
 
 
+    public static final String COMPUTING_CACHE = "computed.values";
+
     /** The XPath that points to the input data elements of the FEED document.*/
     public static final String XPATH_FEED_INPUT =
         "/art:action/art:data/art:input";
@@ -93,13 +102,17 @@
     /** The data that have been inserted into this artifact.*/
     protected Map<String, StateData> data;
 
+    /** The list of facets supported by this artifact.*/
+    protected Map<String, List<Facet>> facets;
+
 
     /**
      * The default constructor that creates an empty FLYSArtifact.
      */
     public FLYSArtifact() {
-        data             = new HashMap<String, StateData>();
+        data             = new TreeMap<String, StateData>();
         previousStateIds = new ArrayList<String>();
+        facets           = new HashMap<String, List<Facet>>();
     }
 
 
@@ -182,6 +195,9 @@
 
         try {
             saveData(target, XPATH_FEED_INPUT, context);
+
+            compute(context, ComputeType.FEED);
+
             return describe(target, context);
         }
         catch (IllegalArgumentException iae) {
@@ -228,6 +244,9 @@
 
             setCurrentStateId(targetState);
 
+            logger.debug("Compute data for state: " + targetState);
+            compute(context, ComputeType.ADVANCE);
+
             return describe(target, context);
         }
         else if (isPreviousState(targetState, context)) {
@@ -241,6 +260,7 @@
                 String prev = prevs.get(i);
                 logger.debug("Remove state id '" + prev + "'");
                 prevs.remove(prev);
+                facets.remove(prev);
             }
 
             setCurrentStateId(targetState);
@@ -338,6 +358,23 @@
     }
 
 
+    public Facet getNativeFacet(Facet facet) {
+        String name  = facet.getName();
+        int    index = facet.getIndex();
+
+        for (Map.Entry<String, List<Facet>> entry: facets.entrySet()) {
+            for (Facet f: entry.getValue()) {
+                if (f.getIndex() == index && f.getName().equals(name)) {
+                    return f;
+                }
+            }
+        }
+
+        logger.warn("Could not find facet: " + name + " at " + index);
+        return null;
+    }
+
+
     /**
      * This method stores the data that is contained in the FEED document.
      *
@@ -673,8 +710,16 @@
      * @return the gauges based on the selected kilometer range.
      */
     public List<Gauge> getGauges() {
-        River    river = getRiver();
-        double[] dist  = getDistance();
+
+        River river = getRiver();
+        if (river == null) {
+            return null;
+        }
+
+        double [] dist  = getDistance();
+        if (dist == null) {
+            return null;
+        }
 
         return river.determineGauges(dist[0], dist[1]);
     }
@@ -1023,6 +1068,117 @@
     }
 
     /**
+     * Computes the hash code of the entered values.
+     *
+     * @return a hash code.
+     */
+    @Override
+    public String hash() {
+        Set<Map.Entry<String, StateData>> entries = data.entrySet();
+
+        int hash  = 0;
+        int shift = 3;
+
+        for (Map.Entry<String, StateData> entry: entries) {
+            String key   = entry.getKey();
+            Object value = entry.getValue().getValue();
+
+            hash ^= (key.hashCode() << shift) | (value.hashCode() << 2 * shift);
+            shift += 2;
+        }
+
+        return getCurrentStateId() + hash;
+    }
+
+
+    /**
+     * Dispatches the computation request to compute(CallContext context, String
+     * hash) with the current hash value of the artifact which is provided by
+     * hash().
+     *
+     * @param context The CallContext.
+     */
+    public Object compute(CallContext context, ComputeType type) {
+        return compute(context, hash(), type);
+    }
+
+
+    /**
+     * Dispatches computation requests to the current state which needs to
+     * implement a createComputeCallback(String hash, FLYSArtifact artifact)
+     * method.
+     *
+     * @param context The CallContext.
+     * @param hash The hash value which is used to fetch computed data from
+     * cache.
+     *
+     * @return the computed data.
+     */
+    public Object compute(CallContext context, String hash, ComputeType type) {
+        DefaultState current = (DefaultState) getCurrentState(context);
+
+        logger.debug("Create ComputeCallback for state: " + current.getID());
+
+        return compute(context, hash, current, type);
+    }
+
+
+    public Object compute(
+        CallContext   context,
+        String        key,
+        DefaultState  state,
+        ComputeType   type
+    ) {
+        String stateID = state.getID();
+
+        List<Facet> fs = new ArrayList<Facet>();
+
+        try {
+            Cache cache = CacheFactory.getCache(COMPUTING_CACHE);
+
+            Object old = null;
+
+            if (cache != null) {
+                net.sf.ehcache.Element element = cache.get(key);
+                if (element != null) {
+                    logger.debug("Got computation result from cache.");
+                    old = element.getValue();
+                }
+            }
+
+            Object res;
+            switch (type) {
+                case FEED:
+                    res = state.computeFeed(this, key, context, fs, old);
+                    break;
+                case ADVANCE:
+                    res = state.computeAdvance(this, key, context, fs, old);
+                    break;
+                default:
+                    res = null;
+            }
+
+            if (cache != null && old != res && res != null) {
+                logger.debug("Store computation result to cache.");
+                net.sf.ehcache.Element element =
+                    new net.sf.ehcache.Element(key, res);
+                cache.put(element);
+            }
+
+            return res;
+        }
+        finally {
+            if (fs.isEmpty()) {
+                facets.remove(stateID);
+            }
+            else {
+                facets.put(stateID, fs);
+            }
+        }
+    }
+
+
+    /**
      * Method to dump the artifacts state/data.
      */
     protected void dumpArtifact() {