Java Code Examples for org.osgi.service.component.annotations.ReferenceCardinality#MULTIPLE

@Reference(name = "serverConfigurationService",
        service = CarbonServerConfigurationService.class,
        policy = ReferencePolicy.DYNAMIC,
        cardinality = ReferenceCardinality.MULTIPLE,
        unbind = "unsetServerConfigurationService")
public void setServerConfigurationService(CarbonServerConfigurationService serverConfigurationService) {

    // Read the internal crypto provider class name from the conf file.
    this.defaultCryptoService.setInternalCryptoProviderClassName(
            serverConfigurationService.getFirstProperty("CryptoService.InternalCryptoProviderClassName"));

    // Read the external crypto provider class name from the conf file.
    this.defaultCryptoService.setExternalCryptoProviderClassName(
            serverConfigurationService.getFirstProperty("CryptoService.ExternalCryptoProviderClassName"));

    // Read resolver configurations
    readAndOverrideKeyResolverPriorities(serverConfigurationService.getDocumentElement());
}
 

@Reference(name = "keyResolver",
        service = KeyResolver.class,
        cardinality = ReferenceCardinality.MULTIPLE,
        policy = ReferencePolicy.DYNAMIC,
        unbind = "unsetKeyResolver")
public void setKeyResolver(KeyResolver keyResolver) {

    this.defaultCryptoService.registerKeyResolver(keyResolver);

    // Re-order the resolvers whenever a new resolver is registered.
    overrideKeyResolverPriorities();
}
 

@Reference(policy = ReferencePolicy.DYNAMIC, cardinality = ReferenceCardinality.MULTIPLE)
public void addAnnotatedThingActions(ThingActions annotatedThingActions) {
    if (annotatedThingActions.getClass().isAnnotationPresent(ThingActionsScope.class)) {
        ThingActionsScope scope = annotatedThingActions.getClass().getAnnotation(ThingActionsScope.class);
        Collection<ModuleInformation> moduleInformations = helper.parseAnnotations(scope.name(),
                annotatedThingActions);

        String thingUID = annotatedThingActions.getThingHandler().getThing().getUID().getAsString();

        for (ModuleInformation mi : moduleInformations) {
            mi.setThingUID(thingUID);

            ModuleType oldType = null;
            if (moduleInformation.containsKey(mi.getUID())) {
                oldType = helper.buildModuleType(mi.getUID(), moduleInformation);
                Set<ModuleInformation> availableModuleConfigs = moduleInformation.get(mi.getUID());
                availableModuleConfigs.add(mi);
            } else {
                Set<ModuleInformation> configs = ConcurrentHashMap.newKeySet();
                configs.add(mi);
                moduleInformation.put(mi.getUID(), configs);
            }

            ModuleType mt = helper.buildModuleType(mi.getUID(), moduleInformation);
            if (mt != null) {
                for (ProviderChangeListener<ModuleType> l : changeListeners) {
                    if (oldType != null) {
                        l.updated(this, oldType, mt);
                    } else {
                        l.added(this, mt);
                    }
                }
            }
        }
    }
}
 

@Reference(
        name = "identity.core.ConnectorConfig",
        service = org.wso2.carbon.identity.core.ConnectorConfig.class,
        cardinality = ReferenceCardinality.MULTIPLE,
        policy = ReferencePolicy.DYNAMIC,
        unbind = "unsetGovernanceConnector")
protected void setIdentityGovernanceConnector(ConnectorConfig identityConnectorConfig) {

    try {
        IdpMgtServiceComponentHolder.getInstance().addConnectorConfig(identityConnectorConfig);
    } catch (IdentityProviderManagementException e) {
        log.error("Error while clearing the cache with the registered connector config.");
    }
}
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
public void addScriptEngineFactory(ScriptEngineFactory engineFactory) {
    List<String> scriptTypes = engineFactory.getScriptTypes();

    logger.trace("{}.getScriptTypes(): {}", engineFactory.getClass().getSimpleName(), scriptTypes);
    for (String scriptType : scriptTypes) {
        if (isCustomFactory(engineFactory)) {
            this.customSupport.put(scriptType, engineFactory);
        } else {
            this.genericSupport.put(scriptType, engineFactory);
        }
    }
    if (!engineFactory.getScriptTypes().isEmpty()) {
        ScriptEngine scriptEngine = engineFactory.createScriptEngine(engineFactory.getScriptTypes().get(0));
        if (scriptEngine != null) {
            javax.script.ScriptEngineFactory factory = scriptEngine.getFactory();
            logger.debug(
                    "Initialized a {} ScriptEngineFactory for {} ({}): supports {} ({}) with file extensions {}, names {}, and mimetypes {}",
                    (isCustomFactory(engineFactory)) ? "custom" : "generic", factory.getEngineName(),
                    factory.getEngineVersion(), factory.getLanguageName(), factory.getLanguageVersion(),
                    factory.getExtensions(), factory.getNames(), factory.getMimeTypes());
        } else {
            logger.trace("addScriptEngineFactory: engine was null");
        }
    } else {
        logger.trace("addScriptEngineFactory: scriptTypes was empty");
    }
}
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
protected void addItemFactory(ItemFactory itemFactory) {
    itemFactories.add(itemFactory);

    if (!failedToCreate.isEmpty()) {
        // retry failed creation attempts
        Iterator<Entry<String, PersistedItem>> iterator = failedToCreate.entrySet().iterator();
        while (iterator.hasNext()) {
            Entry<String, PersistedItem> entry = iterator.next();
            String itemName = entry.getKey();
            PersistedItem persistedItem = entry.getValue();
            Item item = itemFactory.createItem(persistedItem.itemType, itemName);
            if (item != null && item instanceof ActiveItem) {
                iterator.remove();
                configureItem(persistedItem, (ActiveItem) item);
                notifyListenersAboutAddedElement(item);
            } else {
                logger.debug("The added item factory '{}' still could not instantiate item '{}'.", itemFactory,
                        itemName);
            }
        }

        if (failedToCreate.isEmpty()) {
            logger.info("Finished loading the items which could not have been created before.");
        }
    }
}
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
protected void bindStaticInjectAnnotationProcessorFactory(final StaticInjectAnnotationProcessorFactory factory, final Map<String, Object> props) {
    synchronized (staticInjectAnnotationProcessorFactories) {
        staticInjectAnnotationProcessorFactories.bind(factory, props);
        this.adapterImplementations.setStaticInjectAnnotationProcessorFactories(staticInjectAnnotationProcessorFactories.get());
    }
}
 

@Reference(
         name = "org.wso2.carbon.identity.workflow.mgt.extension.requesthandler", 
         service = org.wso2.carbon.identity.workflow.mgt.extension.WorkflowRequestHandler.class, 
         cardinality = ReferenceCardinality.MULTIPLE, 
         policy = ReferencePolicy.DYNAMIC, 
         unbind = "unsetWorkflowRequestHandler")
protected void setWorkflowRequestHandler(WorkflowRequestHandler workflowRequestHandler) {
    WorkflowServiceDataHolder.getInstance().addWorkflowRequestHandler(workflowRequestHandler);
}
 

@Reference(
         name = "claim.manager.listener.service", 
         service = org.wso2.carbon.user.core.listener.ClaimManagerListener.class, 
         cardinality = ReferenceCardinality.MULTIPLE, 
         policy = ReferencePolicy.DYNAMIC, 
         unbind = "unsetClaimManagerListener")
public synchronized void setClaimManagerListener(ClaimManagerListener claimManagerListener) {
    IdentityClaimManagementServiceDataHolder.getInstance().setClaimManagerListener(claimManagerListener);
    if (log.isDebugEnabled()) {
        log.debug("ClaimManagerListener set in Identity Claim Management bundle");
    }
}
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
protected void addActionService(ActionService actionService) {
    if (started) {
        scheduleRuleRefresh();
    }
}
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
protected void addThingHandlerFactory(ThingHandlerFactory thingHandlerFactory) {
    this.thingHandlerFactories.add(thingHandlerFactory);
}
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
void addSwitch(SwitchSegmentController t, ServiceReference<?> ref) {
	switches.put((Integer) ref.getProperty(SegmentController.CONTROLLER_ID), t);
}
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
protected void addSitemapProvider(SitemapProvider provider) {
    sitemapProviders.add(provider);
    provider.addModelChangeListener(this);
}
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
protected void addBindingInfoProvider(BindingInfoProvider bindingInfoProvider) {
    if (bindingInfoProvider != null) {
        bindingInfoProviders.add(bindingInfoProvider);
    }
}
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
protected void addProfileFactory(ProfileFactory profileFactory) {
    this.profileFactories.put(profileFactory, ConcurrentHashMap.newKeySet());
}
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
public void addItemUIProvider(ItemUIProvider itemUIProvider) {
    itemUIProviders.add(itemUIProvider);
}
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
void addTrain(TrainController t, ServiceReference<?> ref) {
	String ch = (String) ref.getProperty("channel");
	trains.put(ch.toLowerCase(), t);
}
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
protected void addExtensionService(ExtensionService featureService) {
    this.extensionServices.add(featureService);
}
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
protected void addConfigDescriptionProvider(ConfigDescriptionProvider configDescriptionProvider) {
    if (configDescriptionProvider != null) {
        configDescriptionProviders.add(configDescriptionProvider);
    }
}
 

/**
 * This method provides functionality for tracking {@link Parser} services.
 *
 * @param parser {@link Parser} service
 * @param properties of the service that has been added.
 */

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC, target = "(parser.type=parser.rule)")
protected void addParser(Parser<Rule> parser, Map<String, String> properties) {
    rImporter.addParser(parser, properties);
}