getRawData() {
return data;
}
/**
* @see IUpgradeableData#loadData(Object)
*/
@Override
@SuppressWarnings("unchecked")
public void loadData(final Object data) {
// By creating a new LinkedHashMap (Base64GetHashMap) here we slip through a possible upgrade issue when upgrading
// from older implementation that used a plain HashMap instead.
// Both newer and older versions can be casted to HashMap.
this.data = new Base64GetHashMap((HashMap)data);
if(Float.compare(getLatestVersion(), getVersion()) > 0) {
upgrade();
upgraded = true;
}
}
/** So you can poll to see if the data has been upgraded
*
* @return true if data has been upgraded, false otherwise
*/
public boolean isUpgraded() {
return upgraded;
}
/**
* Function that should handle the update if of the data in the class so it's up to date with
* the latest version. An update is only done when needed.
*/
@Override
public abstract void upgrade();
/** Create a Map with the differences between the current object and the parameter object.
* Puts the result in a new Map with keys:
*
* changed:key, changedvalue
* remove:key, removedvalue
* added:key, addedvalue
*
*
* @param newobj The "changed" object for which we want to get the changes compared to this object
* @return Map object with difference as described above
*/
public Map diff(UpgradeableDataHashMap newobj) {
@SuppressWarnings("unchecked")
Map newmap = (Map)newobj.saveData();
return diffMaps(data, newmap);
}
/** Create a Map with the differences between the two input objects.
* Puts the result in a new Map with keys:
*
* changed:key, changedvalue
* remove:key, removedvalue
* added:key, addedvalue
*
*
* @param oldmap
* @param newmap
* @return Map with difference
*/
public static Map diffMaps(Map oldmap, Map newmap) {
Map result = new LinkedHashMap();
for (Object key : oldmap.keySet()) {
if (newmap.containsKey(key)) {
// Check if the value is the same
Object value = oldmap.get(key);
if (value == null) {
if (newmap.get(key) != null) {
result.put("addedvalue:"+key, newmap.get(key));
}
} else if (!value.equals(newmap.get(key))) {
Object val = newmap.get(key);
if (val == null) {
val = "";
}
result.put("changed:"+key, getVal(val));
}
} else {
// Value removed
Object val = oldmap.get(key);
if (val == null) {
val = "";
}
result.put("removed:"+key, getVal(val));
}
}
// look for added properties
for (Object key : newmap.keySet()) {
if (!oldmap.containsKey(key)) {
Object val = newmap.get(key);
if (val == null) {
val = "";
}
result.put("added:"+key, getVal(val));
}
}
return result;
}
/** helper method to get nice output from types that do
* not work nicely with Object.toString()
*/
private static String getVal(Object o) {
StringBuilder b = new StringBuilder();
if (o instanceof String[]) {
b.append('[');
String[] arr = (String[]) o;
for (String s: arr) {
if (b.length() > 1) {
b.append(", ");
}
b.append(s);
}
b.append(']');
} else {
b.append(o);
}
return b.toString();
}
// Helper methods for interacting with the stored data
/**
* Retrieve a boolean value from the data map in a safe manner.
* @param key the key for the value to retrieve
* @param defaultValue the default value to return if the value with the specified key does
* not exist in the map or cannot be cast to a boolean
* @return the value mapped to the key specified as first parameter or the default value
* specified as second parameter if retrieval failed
*/
protected boolean getBoolean(final String key, final boolean defaultValue) {
final Object object = data.get(key);
if (object == null || !(object instanceof Boolean)) {
return defaultValue;
}
return (Boolean) object;
}
/**
* Retrieve a non-null string value from the data map in a safe manner.
* @param key the key for the value to retrieve
* @param defaultValue the default value to return if the value with the specified key does
* not exist in the map or cannot be cast to a string
* @return the value mapped to the key specified as first parameter or the default value
* specified as second parameter if retrieval failed
*/
protected String getString(final String key, final String defaultValue) {
final Object object = data.get(key);
if (object == null || !(object instanceof String)) {
return defaultValue;
}
return (String) object;
}
/** Set the value for the specified key as a primitive (never null) boolean */
protected void putBoolean(final String key, final boolean value) {
data.put(key, Boolean.valueOf(value));
}
/**
* @return a deep copy of this hashmap's data object, for cloning purposes.
*/
protected LinkedHashMap getClonedData() {
// We need to make a deep copy of the hashmap here
LinkedHashMap clonedData = new LinkedHashMap<>(data.size());
for (final Entry entry : data.entrySet()) {
Object value = entry.getValue();
if (value instanceof ArrayList) {
// We need to make a clone of this object, but the stored immutables can still be referenced
value = ((ArrayList)value).clone();
}
clonedData.put(entry.getKey(), value);
}
return clonedData;
}
}