/**
  * Erstellt dieses Objekt
  *
  * @param configurationArea Konfigurationsbereich
  * @param pid
  * @param typePid Objekt-Typ-Pid
  * @param objectName Objekt-name falls vorhanden
  * @param allConfigurationData Konfigurationsdaten
  * @param origId
  * @param origConfigAuthority
  * @throws MissingObjectException Falls der angegebene Typ nicht existiert oder nicht vom Typ
  *     DynamicObjectType ist.
  * @throws ConfigurationChangeException Falls die Konfigurationsänderung nicht durchgeführt werden
  *     konnte
  */
 public void create(
     final ConfigurationArea configurationArea,
     final String pid,
     final String typePid,
     final String objectName,
     final Map<PidAttributeGroupUsage, Data> allConfigurationData,
     final long origId,
     final String origConfigAuthority)
     throws MissingObjectException, ConfigurationChangeException,
         MissingKExDaVAttributeGroupException {
   final SystemObject type = _connection.getDataModel().getObject(typePid);
   if (type == null) throw new MissingObjectException(type + " konnte nicht gefunden werden");
   if (!(type instanceof DynamicObjectType)) {
     throw new MissingObjectException(type + " ist kein Typ für dynamische Objekte");
   }
   final Map<PidAttributeGroupUsage, Data> map =
       new HashMap<PidAttributeGroupUsage, Data>(allConfigurationData);
   if (_connection.getDataModel().getAttributeGroup(Constants.Pids.AttributeGroupKExDaVConfigData)
       == null) {
     throw new MissingKExDaVAttributeGroupException();
   }
   if (origConfigAuthority != null) {
     map.put(
         new PidAttributeGroupUsage(
             Constants.Pids.AttributeGroupKExDaVConfigData, Constants.Pids.AspectProperties),
         createProperties(origId, origConfigAuthority));
   }
   final Collection<DataAndATGUsageInformation> dataList = convertConfigurationData(map);
   _manager.addMessage(
       Message.newInfo("Erstelle Objekt: " + (pid.length() == 0 ? '[' + origId + ']' : pid)));
   final DynamicObject dynamicObject =
       configurationArea.createDynamicObject((DynamicObjectType) type, pid, objectName, dataList);
   setWrappedObject(dynamicObject);
 }
 /**
  * Sendet Daten an das Objekt
  *
  * @param senderObject Sender-Objekt
  * @param data Daten
  * @param dataTime Zeit des Datensatzes
  */
 public void sendData(final KExDaVSender senderObject, final Data data, final long dataTime) {
   final SystemObject systemObject = getWrappedObject();
   if (systemObject == null) return;
   try {
     final InnerSender sender = _senders.get(senderObject);
     if (sender == null) throw new IllegalStateException("Sender wurde noch nicht angemeldet");
     sender.sendData(systemObject, data, dataTime);
   } catch (SendSubscriptionNotConfirmed sendSubscriptionNotConfirmed) {
     _manager.addMessage(
         Message.newMajor("Kann derzeit nicht senden", sendSubscriptionNotConfirmed));
   }
 }
    public void sendData(final SystemObject systemObject, Data data, final long dataTime)
        throws SendSubscriptionNotConfirmed {
      final ResultData resultData;
      if (data != null) {
        if (!(data instanceof KExDaVAttributeGroupData)) {
          data = new KExDaVAttributeGroupData(data, _manager);
        }
        resultData =
            ((KExDaVAttributeGroupData) data)
                .toResultData(systemObject, _dataDescription, dataTime);
      } else {
        resultData = new ResultData(systemObject, _dataDescription, dataTime, null);
      }

      try {

        if (_hasPendingSourceSubscription) {
          try {
            _connection.subscribeSource(this, resultData);
            _hasPendingSourceSubscription = false;
          } catch (OneSubscriptionPerSendData ignored) {
            _connection.sendData(resultData);
          }
        } else if (_state == ClientSenderInterface.START_SENDING
            || (_state == ClientSenderInterface.STOP_SENDING
                && _senderRole == SenderRole.source())) {
          _connection.sendData(resultData);
        } else {
          _lastData = resultData;
        }
      } catch (DataNotSubscribedException ignored) {
        _lastData = resultData;
      }

      if (_state == ClientSenderInterface.STOP_SENDING_NO_RIGHTS) {
        _manager.addMessage(Message.newMajor("Keine Rechte zum Senden von Daten: " + this));
      } else if (_state == ClientSenderInterface.STOP_SENDING_NOT_A_VALID_SUBSCRIPTION) {
        _manager.addMessage(Message.newMajor("Ungültige Anmeldung des Empfängers: " + this));
      }
    }
 private void registerSender(final InnerSender innerSender, final SystemObject systemObject) {
   try {
     if (innerSender.getSenderRole() != SenderRole.source()) {
       // Quellen werden verzögert beim ersten Datensatz angemeldet
       _connection.subscribeSender(
           innerSender,
           systemObject,
           innerSender.getDataDescription(),
           innerSender.getSenderRole());
     }
   } catch (OneSubscriptionPerSendData oneSubscriptionPerSendData) {
     _manager.addMessage(
         Message.newMajor("Kann nicht als Sender anmelden", oneSubscriptionPerSendData));
   }
 }
 /**
  * Löscht dieses Objekt
  *
  * @param force Soll das Objekt auch gelöscht werden, wenn es nicht von KExDaV kopiert wurde?
  * @return true wenn das Objekt nicht mehr existiert, sonst false
  * @throws ConfigurationChangeException Falls das Ändern der Konfiguration fehlschlägt (z.B. keine
  *     Berechtigung)
  */
 public boolean invalidate(final boolean force)
     throws ConfigurationChangeException, MissingKExDaVAttributeGroupException {
   final SystemObject wrappedObject = getWrappedObject();
   if (wrappedObject == null || !wrappedObject.isValid()) {
     return true; // Objekt existiert nicht mehr, es braucht nicht nochmal gelöscht zu werden.
                  // Daher ist auch eine Warnung unnötig.
   }
   if (wrappedObject instanceof ConfigurationObject) {
     throw new IllegalArgumentException("Versuch, ein Konfigurationsobjekt zu löschen.");
   }
   if (!force && !isCopy()) return false;
   _manager.addMessage(Message.newInfo("Lösche Objekt: " + _objectSpecification));
   wrappedObject.invalidate();
   setWrappedObject(null);
   return true;
 }
 public void dataRequest(
     final SystemObject object, final DataDescription dataDescription, final byte state) {
   if (state == _state) return;
   _state = state;
   _senderObject.update(state);
   if (_state == ClientSenderInterface.START_SENDING
       && _lastData != null
       && _senderRole != SenderRole.source()) {
     try {
       _connection.sendData(_lastData);
       _lastData = null;
     } catch (SendSubscriptionNotConfirmed sendSubscriptionNotConfirmed) {
       _manager.addMessage(
           Message.newMajor("Kann derzeit nicht senden", sendSubscriptionNotConfirmed));
     }
   }
 }
 @Override
 protected Set<SetExchangeDescription> getExchangeDescriptionsFromNewParameters(
     final RemoteDaVParameter parameters) {
   final Set<SetExchangeDescription> result = new HashSet<SetExchangeDescription>();
   for (final ExchangeSetParameter setParameter : parameters.getExchangeSetParameters()) {
     final SystemObject localObject =
         _correspondingObjectManager
             .getLocalConnection()
             .getDataModel()
             .getObject(setParameter.getLocalObject());
     final SystemObject remoteObject =
         _correspondingObjectManager
             .getRemoteConnection()
             .getDataModel()
             .getObject(setParameter.getRemoteObject());
     if (remoteObject != null
         && localObject != null
         && remoteObject instanceof ConfigurationObject
         && localObject instanceof ConfigurationObject) {
       result.add(
           new SetExchangeDescription(
               (ConfigurationObject) localObject,
               (ConfigurationObject) remoteObject,
               setParameter.getLocalSet(),
               setParameter.getRemoteSet(),
               setParameter.getDirection()));
     } else {
       getManager()
           .addMessage(
               Message.newMajor(
                   "Ein Konfigurationsobjekt für den Mengenaustausch ist ungültig. Betroffener Austausch: "
                       + setParameter.getLocalObject()
                       + " <--> "
                       + setParameter.getRemoteObject()));
     }
   }
   return result;
 }