private Collection<DataAndATGUsageInformation> convertConfigurationData(
final Map<PidAttributeGroupUsage, Data> allConfigurationData) {
final Collection<DataAndATGUsageInformation> dataList =
new ArrayList<DataAndATGUsageInformation>();
for (final Map.Entry<PidAttributeGroupUsage, Data> entry : allConfigurationData.entrySet()) {
final PidAttributeGroupUsage attributeGroupUsagePids = entry.getKey();
final SystemObject attributeGroup =
_connection.getDataModel().getObject(attributeGroupUsagePids.getAttributeGroupPid());
final SystemObject aspect =
_connection.getDataModel().getObject(attributeGroupUsagePids.getAspectPid());
if (attributeGroup != null
&& attributeGroup instanceof AttributeGroup
&& aspect != null
&& aspect instanceof Aspect) {
final AttributeGroupUsage attributeGroupUsage =
((AttributeGroup) attributeGroup).getAttributeGroupUsage((Aspect) aspect);
if (attributeGroupUsage != null) {
Data data = entry.getValue();
if (!(data instanceof KExDaVAttributeGroupData)) {
data = new KExDaVAttributeGroupData(data, _manager);
}
dataList.add(
new DataAndATGUsageInformation(
attributeGroupUsage,
((KExDaVAttributeGroupData) data).toData(_connection.getDataModel())));
}
}
}
return dataList;
}
/**
* Prüft, ob der angegebene Typ <code>ancestorType</code> in der Typhierarchie oberhalb
* angegebenen Typs <code>derivedType</code> vorkommt. Dies ist dann der Fall, wenn <code>
* derivedType</code> direkt oder indirekt <code>ancestorType</code> erweitert und damit dessen
* Eigenschaften erbt.
*
* @param derivedType Zu prüfender abgeleiteter Typ
* @param ancestorType Zu prüfender übergeordneter Typ
* @return <code>true</code> wenn <code>derivedType</code> direkt oder indirekt <code>ancestorType
* </code> erweitert, sonst <code>false</code>.
*/
public boolean inheritsFrom(
final SystemObjectType derivedType, final SystemObjectType ancestorType) {
final Collection<SystemObjectType> superTypes = getSuperTypes(derivedType);
// direkte Vererbung
if (superTypes.contains(ancestorType)) return true;
// indirekte Vererbung
for (SystemObjectType superType : superTypes) {
if (inheritsFrom(superType, ancestorType)) return true;
}
return false;
}
/**
* Liefert eine Liste der Typ-Objekte die von dem angegebenen Typ-Objekt erweitert werden.
*
* @return Liste von {@link SystemObjectType Typ-Objekten}
*/
public Collection<SystemObjectType> getSuperTypes(final SystemObjectType type) {
Collection<SystemObjectType> superTypes = new ArrayList<SystemObjectType>();
NonMutableSet set = (NonMutableSet) type.getObjectSet("SuperTypen");
if (set != null) {
final Collection<SystemObject> elements = getElements(set);
for (SystemObject systemObject : elements) {
superTypes.add((SystemObjectType) systemObject);
}
}
return superTypes;
}
/**
* Erstellt einen Listener auf die Löschung dieses Objekts
*
* @param e Callback
*/
public void removeExistenceListener(final ExistenceListener e) {
_existenceListeners.remove(e);
}
/**
* Erstellt einen Listener auf die Erstellung dieses Objekts
*
* @param e Callback
*/
public void addExistenceListener(final ExistenceListener e) {
_existenceListeners.add(e);
}
