/**
* Returns a string representation of this state using only observable object instances.
*
* @return a string representation of this state using only observable object instances.
*/
public String getStateDescription() {
String desc = "";
for (ObjectInstance o : objectInstances) {
desc = desc + o.getObjectDescription() + "\n";
}
return desc;
}
private List<ObjectInstance> objectListDifference(
List<ObjectInstance> objects, List<String> toRemove) {
List<ObjectInstance> remaining = new ArrayList<ObjectInstance>(objects.size());
for (ObjectInstance oi : objects) {
String oname = oi.getName();
if (!toRemove.contains(oname)) {
remaining.add(oi);
}
}
return remaining;
}
/**
* Initializes this state as a deep copy of the object instances in the provided source state s
*
* @param s the source state from which this state will be initialized.
*/
public State(State s) {
this.initDataStructures();
for (ObjectInstance o : s.objectInstances) {
this.addObject(o.copy());
}
for (ObjectInstance o : s.hiddenObjectInstances) {
this.addObject(o.copy());
}
}
private List<ObjectInstance> objectsMatchingClass(List<ObjectInstance> sourceObs, String cname) {
List<ObjectInstance> res = new ArrayList<ObjectInstance>(sourceObs.size());
for (ObjectInstance o : sourceObs) {
if (o.getTrueClassName().equals(cname)) {
res.add(o);
}
}
return res;
}
private void start(ObjectInstance instance) {
try {
factory.startQBean(this, instance.getObjectName());
} catch (Exception e) {
getLog().warn("start", e);
}
}
@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;
}
/**
* Adds object instance o to this state.
*
* @param o the object instance to be added to this state.
*/
public void addObject(ObjectInstance o) {
String oname = o.getName();
if (objectMap.containsKey(oname)) {
return; // don't add an object that conflicts with another object of the same name
}
objectMap.put(oname, o);
if (o.getObjectClass().hidden) {
hiddenObjectInstances.add(o);
} else {
objectInstances.add(o);
}
this.addObjectClassIndexing(o);
}
/**
* Removes the object instance o from this state.
*
* @param o the object instance to remove from this state.
*/
public void removeObject(ObjectInstance o) {
if (o == null) {
return;
}
String oname = o.getName();
if (!objectMap.containsKey(oname)) {
return; // make sure we're removing something that actually exists in this state!
}
if (o.getObjectClass().hidden) {
hiddenObjectInstances.remove(o);
} else {
objectInstances.remove(o);
}
objectMap.remove(oname);
this.removeObjectClassIndexing(o);
}
private void removeObjectClassIndexing(ObjectInstance o) {
String otclass = o.getTrueClassName();
List<ObjectInstance> classTList = objectIndexByTrueClass.get(otclass);
// if this index has more than one entry, then we can just remove from it and be done
if (classTList.size() > 1) {
classTList.remove(o);
} else {
// otherwise we have to remove class entries for it
objectIndexByTrueClass.remove(otclass);
}
}
private void addObjectClassIndexing(ObjectInstance o) {
String otclass = o.getTrueClassName();
// manage true indexing
if (objectIndexByTrueClass.containsKey(otclass)) {
objectIndexByTrueClass.get(otclass).add(o);
} else {
ArrayList<ObjectInstance> classList = new ArrayList<ObjectInstance>();
classList.add(o);
objectIndexByTrueClass.put(otclass, classList);
}
}
/**
* 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;
}
/**
* Renames the identifier for object instance o in this state to newName.
*
* @param o the object instance to rename in this state
* @param newName the new name of the object instance
*/
public void renameObject(ObjectInstance o, String newName) {
String originalName = o.getName();
o.setName(newName);
objectMap.remove(originalName);
objectMap.put(newName, o);
}
/**
* Renames the identifier for the object instance currently named originalName with the name
* newName.
*
* @param originalName the original name of the object instance to be renamed in this state
* @param newName the new name of the object instance
*/
public void renameObject(String originalName, String newName) {
ObjectInstance o = objectMap.get(originalName);
o.setName(newName);
objectMap.remove(originalName);
objectMap.put(newName, o);
}
public ObjectName getObjectName() {
return instance != null ? instance.getObjectName() : null;
}