/**
* Creates a new Property Group object, sets its name, and fires the add group method that takes a
* group object as a first argument. This method makes other methods easier to read and
* understand.
*
* @param ofName The name of the group to be created
* @param to The parent group the new group will be added to
*/
private void _addGroup(String ofName, PropertyGroup to) {
PropertyGroup group = new PropertyGroup();
group.setName(ofName);
recent = group;
_addGroup(group, to);
}
private void removeFromAllValidIfNeeded(E element) {
if (allValid != null) {
if (element instanceof Property<?>) {
allValid.remove((Property<?>) element);
} else if (element instanceof Model) {
allValid.remove(((Model) element).allValid());
}
}
}
private void addToAllValidIfNeeded(E element) {
if (allValid != null) {
if (element instanceof Property<?>) {
allValid.add((Property<?>) element);
} else if (element instanceof Model) {
allValid.add(((Model) element).allValid());
}
}
}
/**
* Finds the list of data objects that are associated with properties in this template.
*
* @return the list of referenced data objects.
*/
public List<DataObject> findReferencedDataObjects() {
List<DataObject> result = new ArrayList<DataObject>();
for (PropertyGroup propertyGroup : getPropertyGroups()) {
for (Property property : propertyGroup.getProperties()) {
DataObject dataObject = property.getDataObject();
if (dataObject != null) {
result.add(dataObject);
}
}
}
return result;
}
/** {@inheritDoc} */
@Override
public void accept(BaseTemplateMarshaller marshaller) throws WorkflowException {
try {
marshaller.visit(this);
marshaller.visitInputs(inputs);
marshaller.leaveInputs(inputs);
for (PropertyGroup propertyGroup : propertyGroups) {
propertyGroup.accept(marshaller);
}
marshaller.leave(this);
} catch (Exception ex) {
throw new WorkflowException(ex.getMessage(), ex);
}
}
/**
* Creates a new Property Pool object and performs the initial set up.
*
* <p>The initial set up consists of instantiating the history stack, creating a new Property
* Group object to be used as the parent group, and then pushing this new group to the top of the
* currently empty history stack.
*
* <p>This ensures that any added base-level Property Groups will not be met with an empty history
* stack and no parent to attach themselves to.
*/
public PropertyPool() {
history = new Stack<PropertyGroup>();
parent = new PropertyGroup();
parent.setName("parent");
history.push(parent);
}
public JailProperty(
String outsideName, String jailName, PropertyGroup group, int jailFee, int doubleAttempts) {
super(outsideName);
this.jailName = jailName;
this.group = group;
this.jailFee = jailFee;
this.doubleAttempts = doubleAttempts;
group.addProperty(this);
}
/**
* @return a property that, if we contain properties or models, will be true if all contains
* properties/models (as well as ourself) are valid.
*/
public Property<Boolean> allValid() {
if (allValid == null) {
allValid = new PropertyGroup(getValueObject().getName() + ".allValid");
allValid.add(this);
for (E element : getDirect()) {
addToAllValidIfNeeded(element);
}
}
return allValid;
}
/**
* Creates a new XML document from the Property Poo's structure and content.
*
* @return An XML document representing the Property Pool
*/
public Document toXMLDocument() {
try {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.newDocument();
/* Get the base parent group */
PropertyGroup parentGroup = getParent();
/* Create XML element for the parent group and append it to the XML document */
// Element parent = doc.createElement("DOC_DIRECT_CHILD");
// doc.appendChild(parent);
/* Start chain reaction of writing functions */
parentGroup.write(doc, null);
return doc;
} catch (ParserConfigurationException e) {
e.printStackTrace();
return null;
}
}
public PropertyGroup removeLocalPG(PropertyGroup pg) {
Class pgc = pg.getPrimaryClass();
if (AirLiftPG.class.equals(pgc)) {
PropertyGroup removed = myAirLiftPG;
myAirLiftPG = null;
return removed;
} else if (AirVehiclePG.class.equals(pgc)) {
PropertyGroup removed = myAirVehiclePG;
myAirVehiclePG = null;
return removed;
} else if (AirSelfPropulsionPG.class.equals(pgc)) {
PropertyGroup removed = myAirSelfPropulsionPG;
myAirSelfPropulsionPG = null;
return removed;
} else {
}
return super.removeLocalPG(pg);
}
/**
* Adds the new group as a child of the current group, which is the group located on the top of
* the history stack, and then pushes this new group to the top of the history stack, thus making
* it the new current group.
*
* @param group The group to be added
* @param to The parent group the new group will be added to
*/
private void _addGroup(PropertyGroup group, PropertyGroup to) {
group.setParent(history.peek());
history.peek().addChild(group);
history.push(group);
}
/** Visualizes and prints the structure currently held by the Property Pool. */
public void show() {
parent.print(0);
}
public T in(final PropertyGroup group) {
group.add(this);
return getThis();
}
