@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (!(other instanceof State)) {
return false;
}
State so = (State) other;
if (this.numTotalObjets() != so.numTotalObjets()) {
return false;
}
Set<String> matchedObjects = new HashSet<String>();
for (List<ObjectInstance> objects : objectIndexByTrueClass.values()) {
String oclass = objects.get(0).getTrueClassName();
List<ObjectInstance> oobjects = so.getObjectsOfTrueClass(oclass);
if (objects.size() != oobjects.size()) {
return false;
}
for (ObjectInstance o : objects) {
boolean foundMatch = false;
for (ObjectInstance oo : oobjects) {
String ooname = oo.getName();
if (matchedObjects.contains(ooname)) {
continue;
}
if (o.valueEquals(oo)) {
foundMatch = true;
matchedObjects.add(ooname);
break;
}
}
if (!foundMatch) {
return false;
}
}
}
return true;
}
/**
* This method computes a matching from objects in the receiver to value-identical objects in the
* parameter state so. The matching is returned as a map from the object names in the receiving
* state to the matched objects in state so. If enforceStateExactness is set to true, then the
* returned matching will be an empty map if the two states are not OO-MDP-wise identical (i.e.,
* if there is a not a bijection between value-identical objects of the two states). If
* enforceExactness is false and the states are not identical, the the method will return the
* largest matching between objects that can be made.
*
* @param so the state to whose objects the receiving state's objects should be matched
* @param enforceStateExactness whether to require that states are identical to return a matching
* @return a matching from this receiving state's objects to objects in so that have identical
* values.
*/
public Map<String, String> getObjectMatchingTo(State so, boolean enforceStateExactness) {
Map<String, String> matching = new HashMap<String, String>();
if (this.numTotalObjets() != so.numTotalObjets() && enforceStateExactness) {
return new HashMap<String, String>(); // states are not equal and therefore cannot be matched
}
Set<String> matchedObs = new HashSet<String>();
for (List<ObjectInstance> objects : objectIndexByTrueClass.values()) {
String oclass = objects.get(0).getTrueClassName();
List<ObjectInstance> oobjects = so.getObjectsOfTrueClass(oclass);
if (objects.size() != oobjects.size() && enforceStateExactness) {
return new HashMap<
String, String>(); // states are not equal and therefore cannot be matched
}
for (ObjectInstance o : objects) {
boolean foundMatch = false;
for (ObjectInstance oo : oobjects) {
if (matchedObs.contains(oo.getName())) {
continue; // already matched this one; check another
}
if (o.valueEquals(oo)) {
foundMatch = true;
matchedObs.add(oo.getName());
matching.put(o.getName(), oo.getName());
break;
}
}
if (!foundMatch && enforceStateExactness) {
return new HashMap<
String, String>(); // states are not equal and therefore cannot be matched
}
}
}
return matching;
}