Ejemplo n.º 1
0
  /**
   * 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;
  }
Ejemplo n.º 2
0
 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;
 }
Ejemplo n.º 3
0
  /**
   * 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());
    }
  }
Ejemplo n.º 4
0
  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;
  }
Ejemplo n.º 5
0
 private void start(ObjectInstance instance) {
   try {
     factory.startQBean(this, instance.getObjectName());
   } catch (Exception e) {
     getLog().warn("start", e);
   }
 }
Ejemplo n.º 6
0
  @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;
  }
Ejemplo n.º 7
0
  /**
   * 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);
  }
Ejemplo n.º 8
0
  /**
   * 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);
  }
Ejemplo n.º 9
0
  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);
    }
  }
Ejemplo n.º 10
0
  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);
    }
  }
Ejemplo n.º 11
0
  /**
   * 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;
  }
Ejemplo n.º 12
0
 /**
  * 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);
 }
Ejemplo n.º 13
0
 /**
  * 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);
 }
Ejemplo n.º 14
0
 public ObjectName getObjectName() {
   return instance != null ? instance.getObjectName() : null;
 }