* @param configurationAttributes die zu speichernden Attribute
	 *
	 * @throws ConfigurationChangeException Falls die Menge der Attribute nicht am Konfigurationsobjekt gespeichert werden konnte.
	 */
	private void setAttributeObjectSet(ConfigurationArea configurationArea, ConfigurationObject object, AttributeProperties[] configurationAttributes)
			throws ConfigurationChangeException {
		// Menge "Attribute" erzeugen, falls es sie noch nicht gibt
		NonMutableSet objectSet = (NonMutableSet)object.getObjectSet("Attribute");
		if(objectSet == null) {
			// Menge erzeugen
			final ConfigurationObjectType setType = (ConfigurationObjectType)_dataModel.getType(Pid.SetType.ATTRIBUTES);
			objectSet = (NonMutableSet)configurationArea.createConfigurationObject(setType, "", "Attribute", null);
			// Menge "Attribute" am KonfigurationsObjekt speichern
			object.addSet(objectSet);
			_debug.finer("Die Menge der Attribute wurde erzeugt.");
		}
		else {
			setSystemObjectKeeping(objectSet);
		}

		// prüfen, ob zwei Attribute mit gleichem Namen versehen wurden
		final Set<String> attributeNames = new HashSet<String>();

		// erhält alle neu erzeugten Attribute dieser Attributgruppe
		final List<Attribute> newAttributes = new ArrayList<Attribute>();

		ConfigurationObjectType attType = (ConfigurationObjectType)_dataModel.getType(Pid.Type.ATTRIBUTE);
		short position = 1;
		for(AttributeProperties configurationAttribute : configurationAttributes) {
			SystemObjectInfo info;
			String name;
			int maxCount;
			boolean isCountVariable;
			AttributeType attributeType;
			String attributeTypePid = "";
			String aDefault = null;

			if(configurationAttribute instanceof ListAttributeProperties) {
				ListAttributeProperties attributeList = (ListAttributeProperties)configurationAttribute;
				info = attributeList.getInfo();
				name = attributeList.getName();
				maxCount = attributeList.getMaxCount();
				isCountVariable = (attributeList.getTargetValue() == TargetValue.VARIABLE);
				attributeTypePid = attributeList.getAttributeTypePid();
				attributeType = (AttributeType)getObject(attributeTypePid);
			}
			else {
				PlainAttributeProperties attribute = (PlainAttributeProperties)configurationAttribute;
				info = attribute.getInfo();
				name = attribute.getName();
				maxCount = attribute.getMaxCount();
				isCountVariable = (attribute.getTargetValue() == TargetValue.VARIABLE);
				attributeTypePid = attribute.getAttributeTypePid();
				attributeType = (AttributeType)getObject(attributeTypePid);
				aDefault = attribute.getDefault();
			}

			// Name darf nicht doppelt vergeben werden
			final boolean isNewElement = attributeNames.add(name);
			if(!isNewElement) {
				throw new IllegalStateException("Doppelten Attributnamen '" + name + "' vergeben.");
			}

			if(attributeType == null) {
				throwNoObjectException(attributeTypePid);
			}

			// gibt es das Attribut bereits?
			Attribute att = null;
			for(SystemObject systemObject : objectSet.getElementsInModifiableVersion()) {
				if(systemObject.getName().equals(name)) {
					att = (Attribute)systemObject;
					break;
				}
			}
			// prüfen, ob das Attribut geändert werden darf, wenn es geändert werden muss, oder ob ein neues angelegt wird!
			if(att != null) {
				if(_objectDiffs.isAttributeProcessable(configurationAttribute, att, position)) {
					// Attribut kann weiterverarbeitet werden
					// Info überprüfen
					if(_objectDiffs.isInfoDifferent(info, att.getInfo())) {
						setInfo(att, info);
					}
					// Attribut-Eigenschaften überprüfen
					if((maxCount != att.getMaxCount() || isCountVariable != att.isCountVariable() || attributeType != att.getAttributeType())
					   || position != att.getPosition()) {
						setAttributeProperties(att, position, maxCount, isCountVariable, attributeType);
					}
					// Default-Wert überprüfen
					if(_objectDiffs.isDefaultDifferent(att, aDefault)) {
						setDefault(att, aDefault);
					}
				}
				else {
					// Das Attribut kann nicht weiterverarbeitet werden - muss je nach Referenzierungsart auf veraltet gesetzt oder gelöscht werden.
					if(objectSet.getObjectSetType().getReferenceType() == ReferenceType.ASSOCIATION && !objectSet.getObjectSetType().isMutable()) {
						// ein bestehendes Objekt wird auf veraltet gesetzt
						objectSet.remove(att);
//						att.invalidate();
					}
					else {
						objectSet.remove(att);
					}
					att = null;	// Neues Attribut muss angelegt werden
				}
			}
			if(att == null) {
				// neues Attribut erzeugen und speichern
				att = (Attribute)configurationArea.createConfigurationObject(attType, "", name, null);
				setInfo(att, info);
				setAttributeProperties(att, position, maxCount, isCountVariable, attributeType);
				setDefault(att, aDefault);
				objectSet.add(att);	// neues Attribut wird hinzugefügt
				_debug.finer("Neues Attribut '" + name + "' wird erstellt.");
			}
			else {
				setSystemObjectKeeping(att);
			}
			// dies ist ein importiertes Attribut
			newAttributes.add(att);
			position++;
		}

		// nur die importierten Attribute dürfen in der Menge vorhanden sein
		final List<SystemObject> elementsInVersion = objectSet.getElementsInModifiableVersion();
		for(SystemObject systemObject : elementsInVersion) {
			Attribute att = (Attribute)systemObject;
			if(!newAttributes.contains(att)) {
				objectSet.remove(att);
			}
		}
	}