How to use

ScopeGenerator

in

org.openbase.jul.extension.rsb.scope

private String getScopeStringRep() {
  try {
    return ScopeGenerator.generateStringRep(scope);
  } catch (CouldNotPerformException ex) {
    return "?";
  }
}

  private String generateItemId(final UnitConfig appConfig) throws CouldNotPerformException {
    return StringProcessor.transformToIdString("App")
        + ITEM_SEGMENT_DELIMITER
        + ScopeGenerator.generateStringRepWithDelimiter(appConfig.getScope(), ITEM_SUBSEGMENT_DELIMITER);
  }
}

public void init(final String label, final ScopeProvider location) throws InitializationException, InterruptedException {
  try {
    init(ScopeGenerator.generateScope(label, getClass().getSimpleName(), location.getScope()));
  } catch (CouldNotPerformException | NullPointerException ex) {
    throw new InitializationException(this, ex);
  }
}

  @Override
  public void processData(String id, IdentifiableMessage<String, UnitConfig, UnitConfig.Builder> entry, ProtoBufMessageMap<String, UnitConfig, UnitConfig.Builder> entryMap, ProtoBufRegistry<String, UnitConfig, UnitConfig.Builder> registry) throws CouldNotPerformException, EntryModification {
    UnitConfig locationConfig = entry.getMessage();
    ScopeType.Scope newScope = ScopeGenerator.generateLocationScope(locationConfig, entryMap);

    // verify and update scope
    if (!ScopeGenerator.generateStringRep(locationConfig.getScope()).equals(ScopeGenerator.generateStringRep(newScope))) {
      entry.setMessage(locationConfig.toBuilder().setScope(newScope));
      throw new EntryModification(entry, this);
    }
  }
}

  @Override
  public void processData(String id, IdentifiableMessage<String, UnitConfig, UnitConfig.Builder> entry, ProtoBufMessageMap<String, UnitConfig, UnitConfig.Builder> entryMap, ProtoBufRegistry<String, UnitConfig, UnitConfig.Builder> registry) throws CouldNotPerformException, EntryModification {
    UnitConfig connectionUnitConfig = entry.getMessage();

    Scope newScope = ScopeGenerator.generateConnectionScope(connectionUnitConfig, locationRegistry.getMessage(connectionUnitConfig.getPlacementConfig().getLocationId()));
    // verify and update scope
    if (!ScopeGenerator.generateStringRep(connectionUnitConfig.getScope()).equals(ScopeGenerator.generateStringRep(newScope))) {
      entry.setMessage(connectionUnitConfig.toBuilder().setScope(newScope));
      throw new EntryModification(entry, this);
    }
  }
}

@Override
public void processData(String id, IdentifiableMessage<String, UnitConfig, UnitConfig.Builder> entry, ProtoBufMessageMap<String, UnitConfig, UnitConfig.Builder> entryMap, ProtoBufRegistry<String, UnitConfig, UnitConfig.Builder> registry) throws CouldNotPerformException, EntryModification {
  UnitConfig authorizationGroupUnitConfig = entry.getMessage();
  if (!authorizationGroupUnitConfig.hasLabel() || authorizationGroupUnitConfig.getLabel().isEmpty()) {
    throw new NotAvailableException("user.label");
  }
  ScopeType.Scope newScope = ScopeGenerator.generateAuthorizationGroupScope(authorizationGroupUnitConfig);
  // verify and update scope
  if (!ScopeGenerator.generateStringRep(authorizationGroupUnitConfig.getScope()).equals(ScopeGenerator.generateStringRep(newScope))) {
    entry.setMessage(authorizationGroupUnitConfig.toBuilder().setScope(newScope));
    throw new EntryModification(entry, this);
  }
}

  @Override
  public void processData(String id, IdentifiableMessage<String, UnitConfig, UnitConfig.Builder> entry, ProtoBufMessageMap<String, UnitConfig, UnitConfig.Builder> entryMap, ProtoBufRegistry<String, UnitConfig, UnitConfig.Builder> registry) throws CouldNotPerformException, EntryModification {
    UnitConfig userUnitConfig = entry.getMessage();

    if (!userUnitConfig.getUserConfig().hasUserName() || userUnitConfig.getUserConfig().getUserName().isEmpty()) {
      throw new NotAvailableException("user.userName");
    }

    ScopeType.Scope newScope = ScopeGenerator.generateUserScope(userUnitConfig);

    // verify and update scope
    if (!ScopeGenerator.generateStringRep(userUnitConfig.getScope()).equals(ScopeGenerator.generateStringRep(newScope))) {
      throw new EntryModification(entry.setMessage(userUnitConfig.toBuilder().setScope(newScope)), this);
    }
  }
}

@Override
public void processData(String id, IdentifiableMessage<String, UnitConfig, UnitConfig.Builder> entry, ProtoBufMessageMap<String, UnitConfig, UnitConfig.Builder> entryMap, ProtoBufRegistry<String, UnitConfig, UnitConfig.Builder> registry) throws CouldNotPerformException, EntryModification {
  UnitConfig agentUnitConfig = entry.getMessage();
  if (!agentUnitConfig.hasPlacementConfig()) {
    throw new NotAvailableException("agent.placementConfig");
  }
  if (!agentUnitConfig.getPlacementConfig().hasLocationId() || agentUnitConfig.getPlacementConfig().getLocationId().isEmpty()) {
    throw new NotAvailableException("agent.placementConfig.locationId");
  }
  
  if (!agentUnitConfig.getAgentConfig().hasAgentClassId() || agentUnitConfig.getAgentConfig().getAgentClassId().isEmpty()) {
    throw new NotAvailableException("agent.agentClassId");
  }
  Scope newScope = ScopeGenerator.generateAgentScope(agentUnitConfig, agentClassRegistry.get(agentUnitConfig.getAgentConfig().getAgentClassId()).getMessage(), locationRegistry.getMessage(agentUnitConfig.getPlacementConfig().getLocationId()));
  // verify and update scope
  if (!ScopeGenerator.generateStringRep(agentUnitConfig.getScope()).equals(ScopeGenerator.generateStringRep(newScope))) {
    if (agentMap.containsKey(ScopeGenerator.generateStringRep(newScope))) {
      throw new InvalidStateException("Two agents [" + agentUnitConfig + "][" + agentMap.get(ScopeGenerator.generateStringRep(newScope)) + "] are registered with the same label and location");
    } else {
      agentMap.put(ScopeGenerator.generateStringRep(newScope), agentUnitConfig);
      entry.setMessage(agentUnitConfig.toBuilder().setScope(newScope));
      throw new EntryModification(entry, this);
    }
  }
}

@Override
public void processData(final String id, final IdentifiableMessage<String, UnitConfig, UnitConfig.Builder> entry, ProtoBufMessageMap<String, UnitConfig, UnitConfig.Builder> entryMap, final ProtoBufRegistry<String, UnitConfig, UnitConfig.Builder> registry) throws CouldNotPerformException, EntryModification {
  UnitConfig appUnitConfig = entry.getMessage();
  if (!appUnitConfig.hasPlacementConfig()) {
    throw new NotAvailableException("agent.placementConfig");
  }
  if (!appUnitConfig.getPlacementConfig().hasLocationId() || appUnitConfig.getPlacementConfig().getLocationId().isEmpty()) {
    throw new NotAvailableException("app.placementConfig.locationId");
  }
  
  if (!appUnitConfig.getAppConfig().hasAppClassId() || appUnitConfig.getAppConfig().getAppClassId().isEmpty()) {
    throw new NotAvailableException("app.appClassId");
  }
  Scope newScope = ScopeGenerator.generateAppScope(appUnitConfig, appClassRegistry.get(appUnitConfig.getAppConfig().getAppClassId()).getMessage(), locationRegistry.getMessage(appUnitConfig.getPlacementConfig().getLocationId()));
  // verify and update scope
  if (!ScopeGenerator.generateStringRep(appUnitConfig.getScope()).equals(ScopeGenerator.generateStringRep(newScope))) {
    if (appMap.containsKey(ScopeGenerator.generateStringRep(newScope))) {
      throw new InvalidStateException("Two apps [" + appUnitConfig + "][" + appMap.get(ScopeGenerator.generateStringRep(newScope)) + "] are registered with the same label and location");
    } else {
      appMap.put(ScopeGenerator.generateStringRep(newScope), appUnitConfig);
      entry.setMessage(appUnitConfig.toBuilder().setScope(newScope));
      throw new EntryModification(entry, this);
    }
  }
}

@Override
public void processData(String id, IdentifiableMessage<String, UnitConfig, UnitConfig.Builder> entry, ProtoBufMessageMap<String, UnitConfig, UnitConfig.Builder> entryMap, ProtoBufRegistry<String, UnitConfig, UnitConfig.Builder> registry) throws CouldNotPerformException, EntryModification {
  UnitConfig.Builder dalUnitConfig = entry.getMessage().toBuilder();
  boolean modification = false;
  UnitConfig unitConfigClone = UnitConfig.newBuilder(dalUnitConfig.build()).build();
  if (!dalUnitConfig.hasPlacementConfig()) {
    throw new NotAvailableException("placementconfig");
  }
  if (!dalUnitConfig.getPlacementConfig().hasLocationId() || dalUnitConfig.getPlacementConfig().getLocationId().isEmpty()) {
    throw new NotAvailableException("placementconfig.locationid");
  }
  ScopeType.Scope newScope = ScopeGenerator.generateUnitScope(unitConfigClone, locationRegistry.getMessage((dalUnitConfig.getPlacementConfig().getLocationId())));
  // verify and update scope
  if (!ScopeGenerator.generateStringRep(dalUnitConfig.getScope()).equals(ScopeGenerator.generateStringRep(newScope))) {
    dalUnitConfig.setScope(newScope);
    modification = true;
  }
  if (unitScopeMap.containsKey(ScopeGenerator.generateStringRep(dalUnitConfig.getScope()))) {
    throw new InvalidStateException("Two units with same scope[" + ScopeGenerator.generateStringRep(dalUnitConfig.getScope()) + "]!");
  }
  unitScopeMap.put(ScopeGenerator.generateStringRep(dalUnitConfig.getScope()), dalUnitConfig.build());
  if (modification) {
    throw new EntryModification(entry.setMessage(dalUnitConfig), this);
  }
}

  @Override
  public void processData(String id, IdentifiableMessage<String, UnitConfig, UnitConfig.Builder> entry, ProtoBufMessageMap<String, UnitConfig, UnitConfig.Builder> entryMap, ProtoBufRegistry<String, UnitConfig, UnitConfig.Builder> registry) throws CouldNotPerformException, EntryModification {
    UnitConfig unitGroupUnitConfig = entry.getMessage();

    if (!unitGroupUnitConfig.hasPlacementConfig()) {
      throw new NotAvailableException("unitGroupConfig.placementconfig");
    }
    if (!unitGroupUnitConfig.getPlacementConfig().hasLocationId() || unitGroupUnitConfig.getPlacementConfig().getLocationId().isEmpty()) {
      throw new NotAvailableException("unitGroupConfig.placementconfig.locationid");
    }

    UnitConfig locationConfig = locationRegistry.getMessage(unitGroupUnitConfig.getPlacementConfig().getLocationId());
    ScopeType.Scope newScope = ScopeGenerator.generateUnitGroupScope(unitGroupUnitConfig, locationConfig);

    // verify and update scope
    if (!ScopeGenerator.generateStringRep(unitGroupUnitConfig.getScope()).equals(ScopeGenerator.generateStringRep(newScope))) {
      entry.setMessage(unitGroupUnitConfig.toBuilder().setScope(newScope));
      throw new EntryModification(entry, this);
    }
  }
}

  @Override
  public void processData(String id, IdentifiableMessage<String, UnitConfig, UnitConfig.Builder> entry, ProtoBufMessageMap<String, UnitConfig, UnitConfig.Builder> entryMap, ProtoBufRegistry<String, UnitConfig, UnitConfig.Builder> registry) throws CouldNotPerformException, EntryModification {
    UnitConfig unitDeviceConfig = entry.getMessage();

    if (!unitDeviceConfig.hasPlacementConfig()) {
      throw new NotAvailableException("deviceconfig.placementconfig");
    }
    if (!unitDeviceConfig.getPlacementConfig().hasLocationId() || unitDeviceConfig.getPlacementConfig().getLocationId().isEmpty()) {
      throw new NotAvailableException("deviceconfig.placementconfig.locationid");
    }

    UnitConfig unitLocationConfig = locationRegistry.get(unitDeviceConfig.getPlacementConfig().getLocationId()).getMessage();
    ScopeType.Scope newScope = ScopeGenerator.generateDeviceScope(unitDeviceConfig, unitLocationConfig);

    // verify and update scope
    if (!ScopeGenerator.generateStringRep(unitDeviceConfig.getScope()).equals(ScopeGenerator.generateStringRep(newScope))) {
      entry.setMessage(unitDeviceConfig.toBuilder().setScope(newScope));
      throw new EntryModification(entry, this);
    }
  }
}

  @Override
  public void processData(String id, IdentifiableMessage<String, UnitConfig, UnitConfig.Builder> entry, ProtoBufMessageMap<String, UnitConfig, UnitConfig.Builder> entryMap, ProtoBufRegistry<String, UnitConfig, UnitConfig.Builder> registry) throws CouldNotPerformException, EntryModification {
    UnitConfig sceneUnitConfig = entry.getMessage();

    if (!sceneUnitConfig.hasPlacementConfig()) {
      throw new NotAvailableException("sceneConfig.placementConfig");
    }
    if (!sceneUnitConfig.getPlacementConfig().hasLocationId()) {
      throw new NotAvailableException("sceneConfig.locationId");
    }
    if (sceneUnitConfig.getPlacementConfig().getLocationId().isEmpty()) {
      throw new NotAvailableException("Field sceneConfig.locationId is empty");
    }

    Scope newScope = ScopeGenerator.generateSceneScope(sceneUnitConfig, locationRegistry.getMessage(sceneUnitConfig.getPlacementConfig().getLocationId()));

    // verify and update scope
    if (!ScopeGenerator.generateStringRep(sceneUnitConfig.getScope()).equals(ScopeGenerator.generateStringRep(newScope))) {
      throw new EntryModification(entry.setMessage(sceneUnitConfig.toBuilder().setScope(newScope)), this);
    }
  }
}

public static ScopeType.Scope generateScope(final String scope) throws CouldNotPerformException {
  ScopeType.Scope.Builder generatedScope = ScopeType.Scope.newBuilder();
  for (String component : scope.split("/")) {
    // check for empty components (/a//b/ = /a/b/)
    if (component.isEmpty()) {
      continue;
    }
    generatedScope.addComponent(convertIntoValidScopeComponent(component));
  }
  return generatedScope.build();
}

@Override
protected Scope getPropertyDefaultValue() {
  if(JPService.testMode()) {
    String user = ScopeGenerator.convertIntoValidScopeComponent(System.getProperty("user.name"));
    return new Scope("/test/"+user);
  }
  return new Scope("/");
}

/**
 * Method prints a class instance representation.
 *
 * @return the class string representation.
 */
@Override
public String toString() {
  try {
    return getClass().getSimpleName() + "[scope:" + ScopeGenerator.generateStringRep(scope) + "]";
  } catch (CouldNotPerformException ex) {
    return getClass().getSimpleName() + "[scope:?]";
  }
}

  private String generateItemId(final UnitConfig appConfig) throws CouldNotPerformException {
    return StringProcessor.transformToIdString("App")
        + ITEM_SEGMENT_DELIMITER
        + ScopeGenerator.generateStringRepWithDelimiter(appConfig.getScope(), ITEM_SUBSEGMENT_DELIMITER);
  }
}

@Override
public void init() throws InitializationException, InterruptedException {
  try {
    super.init(SCOPE_PREFIX_LAUNCHER + Scope.COMPONENT_SEPARATOR + ScopeGenerator.convertIntoValidScopeComponent(getName()));
  } catch (NotAvailableException ex) {
    throw new InitializationException(this, ex);
  }
}

/**
 * {@inheritDoc}
 *
 * @param scope
 * @throws org.openbase.jul.exception.InitializationException
 * @throws java.lang.InterruptedException
 */
@Override
public void init(final String scope) throws InitializationException, InterruptedException {
  try {
    this.init(ScopeGenerator.generateScope(scope));
  } catch (CouldNotPerformException ex) {
    throw new InitializationException(this, ex);
  }
}

  @Override
  public int compare(UnitConfig o1, UnitConfig o2) {
    try {
      return ScopeGenerator.generateStringRep(o1.getScope()).compareTo(ScopeGenerator.generateStringRep(o2.getScope()));
    } catch (CouldNotPerformException ex) {
      ExceptionPrinter.printHistory("Could not sort scope!", ex, System.err);
      return 0;
    }
  }
});