de.invation.code.toval.misc.soabase.SOABase Maven / Gradle / Ivy
package de.invation.code.toval.misc.soabase;
import java.awt.Window;
import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import de.invation.code.toval.graphic.dialog.DialogObject;
import de.invation.code.toval.misc.NamedComponent;
import de.invation.code.toval.properties.PropertyException;
import de.invation.code.toval.validate.CompatibilityException;
import de.invation.code.toval.validate.InconsistencyException;
import de.invation.code.toval.validate.ParameterException;
import de.invation.code.toval.validate.ParameterException.ErrorCode;
import de.invation.code.toval.validate.Validate;
public class SOABase implements NamedComponent, Cloneable, DialogObject, SOABaseEditingInterface {
public static final String DEFAULT_NAME = "Context";
public static final String DEFAULT_SUBJECT_DESCRIPTOR = "Subject;Subjects";
public static final String DEFAULT_OBJECT_DESCRIPTOR = "Object;Objects";
public static final String DEFAULT_ACTIVITY_DESCRIPTOR = "Activity;Activities";
private static final String descriptorFormat = "%s;%s";
protected String name;
protected Set subjects;
protected Set objects;
protected Set activities;
protected String subjectDescriptorSingular;
protected String subjectDescriptorPlural;
protected String objectDescriptorSingular;
protected String objectDescriptorPlural;
protected String activityDescriptorSingular;
protected String activityDescriptorPlural;
protected SOABaseListenerSupport contextListenerSupport;
public SOABase() {
this(DEFAULT_NAME);
}
public SOABase(String name) {
initialize();
setName(name, false);
}
protected void initialize() {
subjects = new HashSet();
objects = new HashSet();
activities = new HashSet();
contextListenerSupport = new SOABaseListenerSupport();
setActivityDescriptor(DEFAULT_ACTIVITY_DESCRIPTOR);
setSubjectDescriptor(DEFAULT_SUBJECT_DESCRIPTOR);
setObjectDescriptor(DEFAULT_OBJECT_DESCRIPTOR);
}
public SOABase(SOABaseProperties properties) throws PropertyException {
Validate.notNull(properties);
initialize();
setName(properties.getName());
Set subjects = properties.getSubjects();
if (subjects != null) {
setSubjects(subjects);
}
Set objects = properties.getObjects();
if (objects != null) {
setObjects(objects);
}
Set activities = properties.getActivities();
if (activities != null) {
setActivities(activities);
}
}
public boolean addContextListener(SOABaseListener listener) {
return contextListenerSupport.addListener(listener);
}
public boolean removeContextListener(SOABaseListener listener) {
return contextListenerSupport.removeListener(listener);
}
public String getSubjectDescriptor() {
return String.format(descriptorFormat, getSubjectDescriptorSingular(), getSubjectDescriptorPlural());
}
public String getSubjectDescriptorSingular() {
return subjectDescriptorSingular;
}
public String getSubjectDescriptorPlural() {
return subjectDescriptorPlural;
}
public void setSubjectDescriptor(String subjectDescriptor) {
validateDescriptor(subjectDescriptor);
this.subjectDescriptorSingular = subjectDescriptor.substring(0, subjectDescriptor.indexOf(';'));
this.subjectDescriptorPlural = subjectDescriptor.substring(subjectDescriptor.indexOf(';') + 1, subjectDescriptor.length());
}
public String getObjectDescriptor() {
return String.format(descriptorFormat, getObjectDescriptorSingular(), getObjectDescriptorPlural());
}
public String getObjectDescriptorSingular() {
return objectDescriptorSingular;
}
public String getObjectDescriptorPlural() {
return objectDescriptorPlural;
}
public void setObjectDescriptor(String objectDescriptor) {
validateDescriptor(objectDescriptor);
this.objectDescriptorSingular = objectDescriptor.substring(0, objectDescriptor.indexOf(';'));
this.objectDescriptorPlural = objectDescriptor.substring(objectDescriptor.indexOf(';') + 1, objectDescriptor.length());
}
private void validateDescriptor(String descriptor) {
if (!descriptor.contains(";")) {
throw new ParameterException("Descriptor must contain two values separated with ';'");
}
if (descriptor.indexOf(';') == descriptor.length() - 1) {
throw new ParameterException("Descriptor must contain two values separated with ';'");
}
}
public String getActivityDescriptor() {
return String.format(descriptorFormat, getActivityDescriptorSingular(), getActivityDescriptorPlural());
}
public String getActivityDescriptorSingular() {
return activityDescriptorSingular;
}
public String getActivityDescriptorPlural() {
return activityDescriptorPlural;
}
public void setActivityDescriptor(String activityDescriptor) {
validateDescriptor(activityDescriptor);
this.activityDescriptorSingular = activityDescriptor.substring(0, activityDescriptor.indexOf(';'));
this.activityDescriptorPlural = activityDescriptor.substring(activityDescriptor.indexOf(';') + 1, activityDescriptor.length());
}
public String getName() {
return name;
}
public void setName(String name) {
setName(name, true);
}
public void setName(String name, boolean notifyListeners) {
Validate.notNull(name);
Validate.notEmpty(name);
if (this.name != null && this.name.equals(name)) {
return;
}
String oldName = this.name;
this.name = name;
if (notifyListeners) {
contextListenerSupport.notifyNameChange(oldName, name);
}
}
public Set getSubjects() {
return Collections.unmodifiableSet(subjects);
}
public boolean containsSubjects() {
return !subjects.isEmpty();
}
public boolean containsSubject(String subject) {
return subjects.contains(subject);
}
public void addSubjects(Collection subjects) {
addSubjects(subjects, true);
}
public void addSubjects(Collection subjects, boolean notifyListeners) {
Validate.notNull(subjects);
if (subjects.isEmpty()) {
return;
}
for (String subject : subjects) {
addSubject(subject, notifyListeners);
}
}
public boolean addSubject(String subject) {
return addSubject(subject, true);
}
protected boolean addSubject(String subject, boolean notifyListeners) {
Validate.notNull(subject);
if (subjects.add(subject)) {
if (notifyListeners) {
contextListenerSupport.notifySubjectAdded(subject);
}
return true;
}
return false;
}
public void setSubjects(Collection subjects) {
setSubjects(subjects, true);
}
public void setSubjects(String... subjects) {
setSubjects(Arrays.asList(subjects));
}
public void setSubjects(Collection subjects, boolean notifyListeners) {
Validate.notNull(subjects);
if (subjects.isEmpty()) {
removeSubjects();
return;
}
Set newSubjects = new HashSet(subjects);
newSubjects.removeAll(getSubjects());
Set obsoleteSubjects = new HashSet(getSubjects());
obsoleteSubjects.removeAll(subjects);
addSubjects(newSubjects, notifyListeners);
removeSubjects(obsoleteSubjects, notifyListeners);
}
public void removeSubjects() {
removeSubjects(true);
}
public void removeSubjects(boolean notifyListeners) {
List subjects = new ArrayList(getSubjects());
SOABaseChangeDecision changeDecision = contextListenerSupport.subjectRemovalAllowed(getSubjects());
if (!changeDecision.decision) {
throw new InconsistencyException("Cannot remove all " + getSubjectDescriptorPlural().toLowerCase() + ".\n" + changeDecision.vetoObject.getListenerDescription() + " prevented removal of " + getSubjectDescriptorSingular().toLowerCase() + " " + changeDecision.changeObject + " due to inconsistencies.");
}
this.subjects.clear();
if (notifyListeners) {
for (String subject : subjects) {
contextListenerSupport.notifySubjectRemoved(subject);
}
}
}
public void removeSubjects(Collection subjects) {
removeSubjects(subjects, true);
}
public void removeSubjects(Collection subjects, boolean notifyListeners) {
Validate.notNull(subjects);
if (subjects.isEmpty()) {
return;
}
SOABaseChangeDecision changeDecision = contextListenerSupport.subjectRemovalAllowed(subjects);
if (!changeDecision.decision) {
throw new InconsistencyException("Cannot remove all " + getSubjectDescriptorPlural().toLowerCase() + ".\n" + changeDecision.vetoObject.getListenerDescription() + " prevented removal of " + getSubjectDescriptorSingular().toLowerCase() + " " + changeDecision.changeObject + " due to inconsistencies.");
}
for (String subject : subjects) {
removeSubject(subject, notifyListeners);
}
}
public boolean removeSubject(String subject) {
return removeSubject(subject, true);
}
protected boolean removeSubject(String subject, boolean notifyListeners) {
SOABaseChangeDecision changeDecision = contextListenerSupport.subjectRemovalAllowed(subject);
if (!changeDecision.decision) {
throw new InconsistencyException(getSubjectDescriptorSingular() + "\"" + subject + "\" cannot be removed.\n" + changeDecision.vetoObject.getListenerDescription() + " prevented removal due to inconsistencies.");
}
if (subjects.remove(subject)) {
if (notifyListeners) {
contextListenerSupport.notifySubjectRemoved(subject);
}
return true;
}
return false;
}
public Set getActivities() {
return Collections.unmodifiableSet(activities);
}
public boolean containsActivities() {
return !activities.isEmpty();
}
public boolean containsActivity(String activity) {
return activities.contains(activity);
}
public void setActivities(Collection activities) {
setActivities(activities, true);
}
public void setActivities(String... activities) {
setActivities(Arrays.asList(activities));
}
public void setActivities(Collection activities, boolean notifyListeners) {
Validate.notNull(activities);
if (activities.isEmpty()) {
removeActivities();
return;
}
Set newActivities = new HashSet(activities);
newActivities.removeAll(getActivities());
Set obsoleteActivities = new HashSet(getActivities());
obsoleteActivities.removeAll(activities);
addActivities(newActivities, notifyListeners);
removeActivities(obsoleteActivities, notifyListeners);
}
public void addActivities(Collection activities) {
addActivities(activities, true);
}
public void addActivities(Collection activities, boolean notifyListeners) {
Validate.notNull(activities);
if (activities.isEmpty()) {
return;
}
for (String activity : activities) {
addActivity(activity, notifyListeners);
}
}
public boolean addActivity(String activity) {
return addActivity(activity, true);
}
public boolean addActivity(String activity, boolean notifyListeners) {
Validate.notNull(activity);
if (activities.add(activity)) {
if (notifyListeners) {
contextListenerSupport.notifyActivityAdded(activity);
}
return true;
}
return false;
}
public void removeActivities() {
removeActivities(true);
}
public void removeActivities(boolean notifyListeners) {
List activities = new ArrayList(getActivities());
SOABaseChangeDecision changeDecision = contextListenerSupport.activityRemovalAllowed(getActivities());
if (!changeDecision.decision) {
throw new InconsistencyException("Cannot remove all " + getActivityDescriptorPlural().toLowerCase() + ".\n" + changeDecision.vetoObject.getListenerDescription() + " prevented removal of " + getActivityDescriptorSingular().toLowerCase() + " " + changeDecision.changeObject + " due to inconsistencies.");
}
this.activities.clear();
if (notifyListeners) {
for (String activity : activities) {
contextListenerSupport.notifyActivityRemoved(activity);
}
}
}
public void removeActivities(Collection activities) {
removeActivities(activities, true);
}
public void removeActivities(Collection activities, boolean notifyListeners) {
Validate.notNull(activities);
if (activities.isEmpty()) {
return;
}
SOABaseChangeDecision changeDecision = contextListenerSupport.activityRemovalAllowed(activities);
if (!changeDecision.decision) {
throw new InconsistencyException("Cannot remove all " + getActivityDescriptorPlural().toLowerCase() + ".\n" + changeDecision.vetoObject.getListenerDescription() + " prevented removal of " + getActivityDescriptorSingular().toLowerCase() + " " + changeDecision.changeObject + " due to inconsistencies.");
}
for (String activity : activities) {
removeActivity(activity, notifyListeners);
}
}
public boolean removeActivity(String activity) {
return removeActivity(activity, true);
}
protected boolean removeActivity(String activity, boolean notifyListeners) throws InconsistencyException {
SOABaseChangeDecision changeDecision = contextListenerSupport.activityRemovalAllowed(activity);
if (!changeDecision.decision) {
throw new InconsistencyException(getActivityDescriptorSingular() + "\"" + activity + "\" cannot be removed.\n" + changeDecision.vetoObject.getListenerDescription() + " prevented removal due to inconsistencies.");
}
if (activities.remove(activity)) {
if (notifyListeners) {
contextListenerSupport.notifyActivityRemoved(activity);
}
return true;
}
return false;
}
public Set getObjects() {
return Collections.unmodifiableSet(objects);
}
public boolean containsObjects() {
return !objects.isEmpty();
}
public boolean containsObject(String object) {
return objects.contains(object);
}
public void setObjects(Collection objects) {
setObjects(objects, true);
}
public void setObjects(String... objects) {
setObjects(Arrays.asList(objects));
}
public void setObjects(Collection objects, boolean notifyListeners) {
Validate.notNull(objects);
if (objects.isEmpty()) {
removeObjects();
return;
}
Set newObjects = new HashSet(objects);
newObjects.removeAll(getObjects());
Set obsoleteObjects = new HashSet(getObjects());
obsoleteObjects.removeAll(objects);
addObjects(newObjects, notifyListeners);
removeObjects(obsoleteObjects, notifyListeners);
}
public void addObjects(Collection objects) {
addObjects(objects, true);
}
public void addObjects(Collection objects, boolean notifyListeners) {
Validate.notNull(objects);
if (objects.isEmpty()) {
return;
}
for (String object : objects) {
addObject(object, notifyListeners);
}
}
public boolean addObject(String object) {
return addObject(object, true);
}
protected boolean addObject(String object, boolean notifyListeners) {
Validate.notNull(object);
if (objects.add(object)) {
if (notifyListeners) {
contextListenerSupport.notifyObjectAdded(object);
}
return true;
}
return false;
}
public void removeObjects() {
removeObjects(true);
}
public void removeObjects(boolean notifyListeners) {
List objects = new ArrayList(getObjects());
SOABaseChangeDecision changeDecision = contextListenerSupport.objectRemovalAllowed(getObjects());
if (!changeDecision.decision) {
throw new InconsistencyException("Cannot remove all " + getObjectDescriptorPlural().toLowerCase() + ".\n" + changeDecision.vetoObject.getListenerDescription() + " prevented removal of " + getObjectDescriptorSingular().toLowerCase() + " " + changeDecision.changeObject + " due to inconsistencies.");
}
this.objects.clear();
if (notifyListeners) {
for (String object : objects) {
contextListenerSupport.notifyObjectRemoved(object);
}
}
}
public void removeObjects(Collection objects) {
removeObjects(objects, true);
}
public void removeObjects(Collection objects, boolean notifyListeners) {
Validate.notNull(objects);
if (objects.isEmpty()) {
return;
}
SOABaseChangeDecision changeDecision = contextListenerSupport.objectRemovalAllowed(objects);
if (!changeDecision.decision) {
throw new InconsistencyException("Cannot remove all " + getObjectDescriptorPlural().toLowerCase() + ".\n" + changeDecision.vetoObject.getListenerDescription() + " prevented removal of " + getObjectDescriptorSingular().toLowerCase() + " " + changeDecision.changeObject + " due to inconsistencies.");
}
for (String object : objects) {
removeObject(object, notifyListeners);
}
}
public boolean removeObject(String object) {
return removeObject(object, true);
}
protected boolean removeObject(String object, boolean notifyListeners) {
SOABaseChangeDecision changeDecision = contextListenerSupport.objectRemovalAllowed(object);
if (!changeDecision.decision) {
throw new InconsistencyException(getObjectDescriptorSingular() + "\"" + object + "\" cannot be removed.\n" + changeDecision.vetoObject.getListenerDescription() + " prevented removal due to inconsistencies.");
}
if (objects.remove(object)) {
if (notifyListeners) {
contextListenerSupport.notifyObjectRemoved(object);
}
return true;
}
return false;
}
public boolean isEmpty() {
return activities.isEmpty() && subjects.isEmpty() && objects.isEmpty();
}
public void validateSubject(String subject) throws CompatibilityException {
Validate.notNull(subject);
if (!subjects.contains(subject)) {
throw new CompatibilityException("Unknown " + getSubjectDescriptorSingular().toLowerCase() + ": " + subject);
}
}
public void validateSubjects(Collection subjects) throws CompatibilityException {
Validate.notNull(subjects);
for (String subject : subjects) {
validateSubject(subject);
}
}
public void validateActivity(String activity) throws CompatibilityException {
Validate.notNull(activity);
if (!activities.contains(activity)) {
throw new CompatibilityException("Unknown " + getActivityDescriptor().toLowerCase() + ": " + activity);
}
}
public void validateActivities(Collection activities) throws CompatibilityException {
Validate.notNull(activities);
for (String activity : this.activities) {
validateActivity(activity);
}
}
public void validateObject(String object) throws CompatibilityException {
Validate.notNull(object);
if (!objects.contains(object)) {
throw new CompatibilityException("Unknown " + getObjectDescriptor().toLowerCase() + ": " + object);
}
}
public void validateObjects(Collection objects) throws CompatibilityException {
Validate.notNull(objects);
for (String object : objects) {
validateObject(object);
}
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Context{");
builder.append('\n');
addStringContent(builder);
builder.append('}');
builder.append('\n');
return builder.toString();
}
protected void addStringContent(StringBuilder builder) {
builder.append(" name: ");
builder.append(getName());
builder.append('\n');
if (containsSubjects()) {
builder.append(" " + getSubjectDescriptorPlural().toLowerCase() + ": ");
builder.append(getSubjects());
builder.append('\n');
}
if (containsObjects()) {
builder.append(" " + getObjectDescriptorPlural().toLowerCase() + ": ");
builder.append(getObjects());
builder.append('\n');
}
if (containsActivities()) {
builder.append(getActivityDescriptorPlural().toLowerCase() + ": ");
builder.append(getActivities());
builder.append('\n');
}
}
protected Class getPropertiesClass() {
return SOABaseProperties.class;
}
public SOABaseProperties getProperties() throws PropertyException {
if (!isValid()) {
throw new ParameterException(ErrorCode.INCONSISTENCY, "Cannot extract properties in invalid state!");
}
SOABaseProperties properties = null;
try {
properties = (SOABaseProperties) getPropertiesClass().getConstructor().newInstance();
} catch (Exception e) {
throw new ParameterException(ErrorCode.TYPE, "Cannot create properties instance.\nReason: " + e.getMessage());
}
properties.setBaseClass(this.getClass());
properties.setPropertiesClass(getPropertiesClass());
properties.setName(getName());
properties.setSubjects(getSubjects());
properties.setObjects(getObjects());
properties.setActivities(getActivities());
return properties;
}
@Override
public void takeoverValues(SOABase context) throws Exception {
takeoverValues(context, false);
}
public void takeoverValues(SOABase context, boolean notifyListeners) throws Exception {
Validate.notNull(context);
if (this == context) {
return;
}
if (notifyListeners) {
setName(context.getName());
setActivities(context.getActivities());
setSubjects(context.getSubjects());
setObjects(context.getObjects());
setActivityDescriptor(context.getActivityDescriptor());
setSubjectDescriptor(context.getSubjectDescriptor());
setObjectDescriptor(context.getObjectDescriptor());
} else {
this.name = context.getName();
Set otherActivities = context.getActivities();
if (otherActivities != null) {
activities.clear();
activities.addAll(otherActivities);
}
Set otherSubjects = context.getSubjects();
if (otherSubjects != null) {
subjects.clear();
subjects.addAll(otherSubjects);
}
Set otherAttributes = context.getObjects();
if (otherAttributes != null) {
objects.clear();
objects.addAll(otherAttributes);
}
}
}
@Override
public SOABase clone() {
SOABase result = null;
try {
result = SOABase.this.getClass().newInstance();
result.takeoverValues(this, false);
} catch (Exception e) {
e.printStackTrace();
return null;
}
return result;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((activities == null) ? 0 : activities.hashCode());
result = prime * result + ((activityDescriptorPlural == null) ? 0 : activityDescriptorPlural.hashCode());
result = prime * result + ((activityDescriptorSingular == null) ? 0 : activityDescriptorSingular.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((objectDescriptorPlural == null) ? 0 : objectDescriptorPlural.hashCode());
result = prime * result + ((objectDescriptorSingular == null) ? 0 : objectDescriptorSingular.hashCode());
result = prime * result + ((objects == null) ? 0 : objects.hashCode());
result = prime * result + ((subjectDescriptorPlural == null) ? 0 : subjectDescriptorPlural.hashCode());
result = prime * result + ((subjectDescriptorSingular == null) ? 0 : subjectDescriptorSingular.hashCode());
result = prime * result + ((subjects == null) ? 0 : subjects.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
SOABase other = (SOABase) obj;
if (activities == null) {
if (other.activities != null) {
return false;
}
} else if (!activities.equals(other.activities)) {
return false;
}
if (activityDescriptorPlural == null) {
if (other.activityDescriptorPlural != null) {
return false;
}
} else if (!activityDescriptorPlural.equals(other.activityDescriptorPlural)) {
return false;
}
if (activityDescriptorSingular == null) {
if (other.activityDescriptorSingular != null) {
return false;
}
} else if (!activityDescriptorSingular.equals(other.activityDescriptorSingular)) {
return false;
}
if (name == null) {
if (other.name != null) {
return false;
}
} else if (!name.equals(other.name)) {
return false;
}
if (objectDescriptorPlural == null) {
if (other.objectDescriptorPlural != null) {
return false;
}
} else if (!objectDescriptorPlural.equals(other.objectDescriptorPlural)) {
return false;
}
if (objectDescriptorSingular == null) {
if (other.objectDescriptorSingular != null) {
return false;
}
} else if (!objectDescriptorSingular.equals(other.objectDescriptorSingular)) {
return false;
}
if (objects == null) {
if (other.objects != null) {
return false;
}
} else if (!objects.equals(other.objects)) {
return false;
}
if (subjectDescriptorPlural == null) {
if (other.subjectDescriptorPlural != null) {
return false;
}
} else if (!subjectDescriptorPlural.equals(other.subjectDescriptorPlural)) {
return false;
}
if (subjectDescriptorSingular == null) {
if (other.subjectDescriptorSingular != null) {
return false;
}
} else if (!subjectDescriptorSingular.equals(other.subjectDescriptorSingular)) {
return false;
}
if (subjects == null) {
if (other.subjects != null) {
return false;
}
} else if (!subjects.equals(other.subjects)) {
return false;
}
return true;
}
//------- Validity --------------------------------------------------------------------------------------------------
/**
* Checks if the context is in a valid state.
* A context is valid, if every activity is executable, i.e. there exists at
* least one subject that is permitted to execute it.
*
* @return true if the context is valid;
* false otherwise.
*/
public boolean isValid() {
return true;
}
@Override
public boolean showDialog(Window parent) throws Exception {
return SOABaseDialog.showDialog(parent, this);
}
public static SOABase createFromFile(File file) throws Exception {
return createFromProperties(SOABaseProperties.loadPropertiesFromFile(file));
}
public static SOABase createFromProperties(SOABaseProperties properties) throws Exception {
Validate.notNull(properties);
Class baseClass = properties.getBaseClass();
// Try to get constructor
Constructor constructor = null;
try {
constructor = baseClass.getConstructor(properties.getClass());
} catch (SecurityException e) {
e.printStackTrace();
throw new Exception("Cannot extract SOABase constructor.\nReason: " + e.getMessage());
} catch (NoSuchMethodException e) {
e.printStackTrace();
throw new Exception("Cannot extract SOABase constructor.\nReason: " + e.getMessage());
}
Object newInstance = null;
try {
newInstance = constructor.newInstance(properties);
} catch (IllegalArgumentException e) {
e.printStackTrace();
throw new Exception("Cannot create SOABase instance.\nReason: " + e.getMessage());
} catch (InstantiationException e) {
e.printStackTrace();
throw new Exception("Cannot create SOABase instance.\nReason: " + e.getMessage());
} catch (IllegalAccessException e) {
e.printStackTrace();
throw new Exception("Cannot create SOABase instance.\nReason: " + e.getMessage());
} catch (InvocationTargetException e) {
e.printStackTrace();
throw new Exception("Cannot create SOABase instance.\nReason: " + e.getMessage());
}
return (SOABase) newInstance;
}
public static SOABase createSOABase(String name, int activities, int subjects, int objects) {
SOABase result = new SOABase(name);
String activityPrefix = "act";
String objectPrefix = "obj";
String subjectPrefix = "subj";
for (int i = 0; i < activities; i++) {
result.addActivity(String.format("%s_%s", activityPrefix, i));
}
for (int j = 0; j < subjects; j++) {
result.addSubject(String.format("%s_%s", subjectPrefix, j));
}
for (int k = 0; k < objects; k++) {
result.addObject(String.format("%s_%s", objectPrefix, k));
}
return result;
}
// public static void main(String[] args) throws Exception {
// SOABase c = new SOABase("Base");
// c.setSubjects(new HashSet(Arrays.asList("subj1", "subj2", "subj3")));
// c.setObjects(new HashSet(Arrays.asList("obj1", "obj2", "obj3")));
// c.setActivities(new HashSet(Arrays.asList("t1", "t2", "t3")));
// c.getProperties().store("/Users/stocker/Desktop/Base");
//
// SOABaseProperties properties = new SOABaseProperties();
// properties.load("/Users/stocker/Desktop/Base");
// SOABase c1 = SOABaseProperties.createFromProperties(properties);
// System.out.println(c1);
// System.out.println(c1.equals(c));
// System.out.println(properties.getBaseClass());
// }
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy