#919 - io.ebean package initial

src/main/java/io/ebeaninternal/server/cache/CachedBeanData.java

@@ -0,0 +1,139 @@
+package io.ebeaninternal.server.cache;
+
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Data held in the bean cache for cached beans.
+ */
+public class CachedBeanData implements Externalizable {
+
+  private long whenCreated;
+  private long version;
+  private String discValue;
+  private Map<String, Object> data;
+
+  /**
+   * The sharable bean is effectively transient (near cache only).
+   */
+  private transient Object sharableBean;
+
+  /**
+   * Construct from a loaded bean.
+   */
+  public CachedBeanData(Object sharableBean, String discValue, Map<String, Object> data, long version) {
+    this.whenCreated = System.currentTimeMillis();
+    this.sharableBean = sharableBean;
+    this.discValue = discValue;
+    this.data = data;
+    this.version = version;
+  }
+
+  /**
+   * Construct from serialisation.
+   */
+  public CachedBeanData() {
+  }
+
+  @Override
+  public void writeExternal(ObjectOutput out) throws IOException {
+    out.writeLong(version);
+    out.writeLong(whenCreated);
+    boolean hasDisc = discValue != null;
+    out.writeBoolean(hasDisc);
+    if (hasDisc) {
+      out.writeUTF(discValue);
+    }
+    out.writeInt(data.size());
+    for (Map.Entry<String, Object> entry : data.entrySet()) {
+      out.writeUTF(entry.getKey());
+      out.writeObject(entry.getValue());
+    }
+  }
+
+  @Override
+  public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+    version = in.readLong();
+    whenCreated = in.readLong();
+    if (in.readBoolean()) {
+      discValue = in.readUTF();
+    }
+    data = new LinkedHashMap<>();
+    int count = in.readInt();
+    for (int i = 0; i < count; i++) {
+      String key = in.readUTF();
+      Object val = in.readObject();
+      data.put(key, val);
+    }
+  }
+
+  public String toString() {
+    return data.toString();
+  }
+
+  /**
+   * Create and return a new version of CachedBeanData based on this
+   * entry applying the given changes.
+   */
+  public CachedBeanData update(Map<String, Object> changes, long version) {
+
+    Map<String, Object> copy = new HashMap<>();
+    copy.putAll(data);
+    copy.putAll(changes);
+    return new CachedBeanData(null, discValue, copy, version);
+  }
+
+  /**
+   * Return when the cached data was created.
+   */
+  public long getWhenCreated() {
+    return whenCreated;
+  }
+
+  /**
+   * Return the version value.
+   */
+  public long getVersion() {
+    return version;
+  }
+
+  /**
+   * Return the raw discriminator value.
+   */
+  public String getDiscValue() {
+    return discValue;
+  }
+
+  /**
+   * Return a sharable (immutable read only) bean. Near cache only use.
+   */
+  public Object getSharableBean() {
+    return sharableBean;
+  }
+
+  /**
+   * Return true if the property is held.
+   */
+  public boolean isLoaded(String propertyName) {
+    return data.containsKey(propertyName);
+  }
+
+  /**
+   * Return the value for a given property name.
+   */
+  public Object getData(String propertyName) {
+    return data.get(propertyName);
+  }
+
+  /**
+   * Return all the property data.
+   */
+  public Map<String, Object> getData() {
+    return data;
+  }
+}