How to use

AbstractConfigurableController

in

org.openbase.jul.extension.rsb.com

this.config = config;
if (supportsDataField(TYPE_FIELD_ID) && hasConfigField(TYPE_FIELD_ID)) {
  setDataField(TYPE_FIELD_ID, getConfigField(TYPE_FIELD_ID));
if (supportsDataField(TYPE_FIELD_LABEL) && hasConfigField(TYPE_FIELD_LABEL)) {
  setDataField(TYPE_FIELD_LABEL, getConfigField(TYPE_FIELD_LABEL));
  if (isActive() && !currentScope.equals(detectScope(config))) {
    currentScope = detectScope();
    super.init(currentScope);

protected final Object getConfigField(String name) throws CouldNotPerformException {
  synchronized (CONFIG_LOCK) {
    return getConfigField(name, getConfig());
  }
}

private Scope detectScope() throws NotAvailableException {
  synchronized (CONFIG_LOCK) {
    return detectScope(getConfig());
  }
}

@Override
public void init(Scope scope, ParticipantConfig participantConfig) throws InitializationException, InterruptedException {
  super.init(scope, participantConfig);
  try {
    RPCHelper.registerInterface(AuthenticatedRequestable.class, this, server);
  } catch (CouldNotPerformException ex) {
    throw new InitializationException(this, ex);
  }
}

/**
 * Initialize the controller with a configuration.
 *
 * @param config the configuration
 * @throws InitializationException if the initialization fails
 * @throws java.lang.InterruptedException if the initialization is interrupted
 */
@Override
public void init(final CONFIG config) throws InitializationException, InterruptedException {
  synchronized (CONFIG_LOCK) {
    try {
      if (config == null) {
        throw new NotAvailableException("config");
      }
      currentScope = detectScope(config);
      applyConfigUpdate(config);
      super.init(currentScope);
    } catch (CouldNotPerformException ex) {
      throw new InitializationException(this, ex);
    }
  }
}

return super.applyConfigUpdate(config);

private Scope detectScope(final CONFIG config) throws NotAvailableException {
  try {
    return (Scope) getConfigField(FIELD_SCOPE, config);
  } catch (CouldNotPerformException ex) {
    throw new NotAvailableException("scope");
  }
}

public AbstractUnitController(final Class unitClass, final DB builder) throws InstantiationException {
  super(builder);
  this.serviceList = new ArrayList<>();
  this.unitDataObservableMap = new HashMap<>();
  this.serviceTempusServiceTypeObservableMap = new HashMap<>();
  for (final ServiceTempus serviceTempus : ServiceTempus.values()) {
    unitDataObservableMap.put(serviceTempus, new UnitDataFilteredObservable<>(this, serviceTempus));
    super.addDataObserver((Observable<D> source, D data) -> {
      unitDataObservableMap.get(serviceTempus).notifyObservers(data);
    });
    serviceTempusServiceTypeObservableMap.put(serviceTempus, new HashMap<>());
  }
  this.unitRegistryObserver = new Observer<UnitRegistryData>() {
    @Override
    public void update(Observable<UnitRegistryData> source, UnitRegistryData data) throws Exception {
      try {
        final UnitConfig newUnitConfig = Registries.getUnitRegistry(true).getUnitConfigById(getId());
        if (!newUnitConfig.equals(getConfig())) {
          applyConfigUpdate(newUnitConfig);
        }
      } catch (NotAvailableException ex) {
        // unit config has been removed, probably because of deletion and a higher controller will do the shutdown in this case
        logger.debug("Could not update unit controller", ex);
      } catch (CouldNotPerformException ex) {
        ExceptionPrinter.printHistory("Could not update unit config of " + this, ex, logger);
      }
    }
  };
}

@Override
protected void postInit() throws InitializationException, InterruptedException {
  try {
    super.postInit();
    if (!initialized) {
      Registries.getUnitRegistry().addDataObserver(unitRegistryObserver);
      initialized = true;
    }
  } catch (CouldNotPerformException ex) {
    throw new InitializationException(this, ex);
  }
}

@Override
protected void notifyDataUpdate(final D data) throws CouldNotPerformException {
  super.notifyDataUpdate(data);
  for (final ServiceTempus serviceTempus : ServiceTempus.values()) {
    final Set<ServiceType> serviceTypeSet = new HashSet<>();
    for (final ServiceDescription serviceDescription : getUnitTemplate().getServiceDescriptionList()) {
      // check if already handled
      if (!serviceTypeSet.contains(serviceDescription.getType())) {
        serviceTypeSet.add(serviceDescription.getType());
        try {
          Object serviceData = Services.invokeServiceMethod(serviceDescription.getType(), ServicePattern.PROVIDER, serviceTempus, data);
          serviceTempusServiceTypeObservableMap.get(serviceTempus).get(serviceDescription.getType()).notifyObservers(serviceData);
        } catch (CouldNotPerformException ex) {
          logger.debug("Could not notify state update for service[" + serviceDescription.getType() + "] because this service is not supported by this controller.", ex);
        }
      }
    }
  }
}

@Override
public void init(ScopeType.Scope scope) throws InitializationException, InterruptedException {
  try {
    super.init(Registries.getUnitRegistry(true).getUnitConfigByScope(scope));
  } catch (CouldNotPerformException ex) {
    throw new InitializationException(this, ex);
  }
}

@Override
public void init(final UnitConfig config) throws InitializationException, InterruptedException {
  try {
    if (config == null) {
      throw new NotAvailableException("config");
    }
    if (!config.hasId()) {
      throw new NotAvailableException("config.id");
    }
    if (config.getId().isEmpty()) {
      throw new NotAvailableException("Field config.id is empty!");
    }
    if (!config.hasLabel()) {
      throw new NotAvailableException("config.label");
    }
    if (config.getLabel().isEmpty()) {
      throw new NotAvailableException("Field config.label is emty!");
    }
    super.init(config);
  } catch (CouldNotPerformException ex) {
    throw new InitializationException(this, ex);
  }
}