Example usage for org.apache.commons.configuration HierarchicalConfiguration configurationsAt

List of usage examples for org.apache.commons.configuration HierarchicalConfiguration configurationsAt

Introduction

In this page you can find the example usage for org.apache.commons.configuration HierarchicalConfiguration configurationsAt.

Prototype

public List configurationsAt(String key) 

Source Link

Document

Returns a list of sub configurations for all configuration nodes selected by the given key.

Usage

From source file:jsprit.core.algorithm.io.VehicleRoutingAlgorithms.java

private static VehicleRoutingAlgorithm readAndCreateAlgorithm(final VehicleRoutingProblem vrp,
        XMLConfiguration config, int nuOfThreads, final SolutionCostCalculator solutionCostCalculator,
        final StateManager stateManager, ConstraintManager constraintManager,
        boolean addDefaultCostCalculators) {
    // map to store constructed modules
    TypedMap definedClasses = new TypedMap();

    // algorithm listeners
    Set<PrioritizedVRAListener> algorithmListeners = new HashSet<PrioritizedVRAListener>();

    // insertion listeners
    List<InsertionListener> insertionListeners = new ArrayList<InsertionListener>();

    //threading//  w w  w.  j  av  a 2  s.co m
    final ExecutorService executorService;
    if (nuOfThreads > 0) {
        log.debug("setup executor-service with " + nuOfThreads + " threads");
        executorService = Executors.newFixedThreadPool(nuOfThreads);
        algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, new AlgorithmEndsListener() {

            @Override
            public void informAlgorithmEnds(VehicleRoutingProblem problem,
                    Collection<VehicleRoutingProblemSolution> solutions) {
                log.debug("shutdown executor-service");
                executorService.shutdown();
            }
        }));
        Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {

            @Override
            public void uncaughtException(Thread arg0, Throwable arg1) {
                System.err.println(arg1.toString());
            }
        });
        Runtime.getRuntime().addShutdownHook(new Thread() {
            public void run() {
                if (!executorService.isShutdown()) {
                    System.err.println("shutdowHook shuts down executorService");
                    executorService.shutdown();
                }
            }
        });
    } else
        executorService = null;

    //create fleetmanager
    final VehicleFleetManager vehicleFleetManager = createFleetManager(vrp);

    String switchString = config.getString("construction.insertion.allowVehicleSwitch");
    final boolean switchAllowed;
    if (switchString != null) {
        switchAllowed = Boolean.parseBoolean(switchString);
    } else
        switchAllowed = true;
    ActivityTimeTracker.ActivityPolicy activityPolicy;
    if (stateManager.timeWindowUpdateIsActivated()) {
        UpdateVehicleDependentPracticalTimeWindows timeWindowUpdater = new UpdateVehicleDependentPracticalTimeWindows(
                stateManager, vrp.getTransportCosts());
        timeWindowUpdater
                .setVehiclesToUpdate(new UpdateVehicleDependentPracticalTimeWindows.VehiclesToUpdate() {
                    Map<VehicleTypeKey, Vehicle> uniqueTypes = new HashMap<VehicleTypeKey, Vehicle>();

                    @Override
                    public Collection<Vehicle> get(VehicleRoute vehicleRoute) {
                        if (uniqueTypes.isEmpty()) {
                            for (Vehicle v : vrp.getVehicles()) {
                                if (!uniqueTypes.containsKey(v.getVehicleTypeIdentifier())) {
                                    uniqueTypes.put(v.getVehicleTypeIdentifier(), v);
                                }
                            }
                        }
                        Collection<Vehicle> vehicles = new ArrayList<Vehicle>();
                        vehicles.addAll(uniqueTypes.values());
                        return vehicles;
                    }
                });
        stateManager.addStateUpdater(timeWindowUpdater);
        activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS;
    } else {
        activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_ARRIVED;
    }
    stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts(), activityPolicy));
    stateManager.addStateUpdater(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(),
            stateManager, activityPolicy));

    final SolutionCostCalculator costCalculator;
    if (solutionCostCalculator == null)
        costCalculator = getDefaultCostCalculator(stateManager);
    else
        costCalculator = solutionCostCalculator;

    PrettyAlgorithmBuilder prettyAlgorithmBuilder = PrettyAlgorithmBuilder.newInstance(vrp, vehicleFleetManager,
            stateManager, constraintManager);
    //construct initial solution creator
    final InsertionStrategy initialInsertionStrategy = createInitialSolution(config, vrp, vehicleFleetManager,
            stateManager, algorithmListeners, definedClasses, executorService, nuOfThreads, costCalculator,
            constraintManager, addDefaultCostCalculators);
    if (initialInsertionStrategy != null)
        prettyAlgorithmBuilder.constructInitialSolutionWith(initialInsertionStrategy, costCalculator);

    //construct algorithm, i.e. search-strategies and its modules
    int solutionMemory = config.getInt("strategy.memory");
    List<HierarchicalConfiguration> strategyConfigs = config
            .configurationsAt("strategy.searchStrategies.searchStrategy");
    for (HierarchicalConfiguration strategyConfig : strategyConfigs) {
        String name = getName(strategyConfig);
        SolutionAcceptor acceptor = getAcceptor(strategyConfig, vrp, algorithmListeners, definedClasses,
                solutionMemory);
        SolutionSelector selector = getSelector(strategyConfig, vrp, algorithmListeners, definedClasses);

        SearchStrategy strategy = new SearchStrategy(name, selector, acceptor, costCalculator);
        strategy.setName(name);
        List<HierarchicalConfiguration> modulesConfig = strategyConfig.configurationsAt("modules.module");
        for (HierarchicalConfiguration moduleConfig : modulesConfig) {
            SearchStrategyModule module = buildModule(moduleConfig, vrp, vehicleFleetManager, stateManager,
                    algorithmListeners, definedClasses, executorService, nuOfThreads, constraintManager,
                    addDefaultCostCalculators);
            strategy.addModule(module);
        }
        prettyAlgorithmBuilder.withStrategy(strategy, strategyConfig.getDouble("probability"));
    }

    //construct algorithm
    VehicleRoutingAlgorithm metaAlgorithm = prettyAlgorithmBuilder.build();
    int maxIterations = getMaxIterations(config);
    if (maxIterations > -1)
        metaAlgorithm.setMaxIterations(maxIterations);

    //define prematureBreak
    PrematureAlgorithmTermination prematureAlgorithmTermination = getPrematureTermination(config,
            algorithmListeners);
    if (prematureAlgorithmTermination != null)
        metaAlgorithm.setPrematureAlgorithmTermination(prematureAlgorithmTermination);
    else {
        List<HierarchicalConfiguration> terminationCriteria = config
                .configurationsAt("terminationCriteria.termination");
        for (HierarchicalConfiguration terminationConfig : terminationCriteria) {
            PrematureAlgorithmTermination termination = getTerminationCriterion(terminationConfig,
                    algorithmListeners);
            if (termination != null)
                metaAlgorithm.addTerminationCriterion(termination);
        }
    }
    for (PrioritizedVRAListener l : algorithmListeners) {
        metaAlgorithm.getAlgorithmListeners().add(l);
    }
    return metaAlgorithm;
}

From source file:net.datenwerke.sandbox.util.SandboxParser.java

public void parse(Configuration config) {
    if (!(config instanceof HierarchicalConfiguration))
        throw new IllegalArgumentException("Expected HierarchicalConfiguration format");

    HierarchicalConfiguration conf = (HierarchicalConfiguration) config;

    /* sandboxes */
    for (HierarchicalConfiguration rs : conf.configurationsAt("security.sandbox")) {
        String name = rs.getString("[@name]");
        if (null == name)
            throw new IllegalArgumentException("no name for sandbox given");

        SandboxContext set = loadSandbox(name, conf, rs, new HashSet<String>());
        restrictionSets.put(name, set);//from  w w w  .j a  va  2 s.  co  m
    }
}

From source file:net.datenwerke.sandbox.util.SandboxParser.java

protected void configureFileAccess(SandboxContext context, HierarchicalConfiguration rs) {
    for (HierarchicalConfiguration suf : rs.configurationsAt("fileAccess.read.suffixes.entry"))
        context.addFilePermission(FileAccess.READ, AccessType.PERMIT,
                new FileSuffixPermission(suf.getString("."), suf.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration prefix : rs.configurationsAt("fileAccess.read.prefixes.entry"))
        context.addFilePermission(FileAccess.READ, AccessType.PERMIT,
                new FilePrefixPermission(prefix.getString("."), prefix.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration entry : rs.configurationsAt("fileAccess.read.exactMatches.entry"))
        context.addFilePermission(FileAccess.READ, AccessType.PERMIT,
                new FileEqualsPermission(entry.getString("."), entry.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration entry : rs.configurationsAt("fileAccess.read.regex.entry"))
        context.addFilePermission(FileAccess.READ, AccessType.PERMIT,
                new FileRegexPermission(entry.getString("."), entry.getBoolean("[@negate]", false)));

    for (HierarchicalConfiguration suf : rs.configurationsAt("fileAccess.write.suffixes.entry"))
        context.addFilePermission(FileAccess.WRITE, AccessType.PERMIT,
                new FileSuffixPermission(suf.getString("."), suf.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration prefix : rs.configurationsAt("fileAccess.write.prefixes.entry"))
        context.addFilePermission(FileAccess.WRITE, AccessType.PERMIT,
                new FilePrefixPermission(prefix.getString("."), prefix.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration entry : rs.configurationsAt("fileAccess.write.exactMatches.entry"))
        context.addFilePermission(FileAccess.WRITE, AccessType.PERMIT,
                new FileEqualsPermission(entry.getString("."), entry.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration entry : rs.configurationsAt("fileAccess.write.regex.entry"))
        context.addFilePermission(FileAccess.WRITE, AccessType.PERMIT,
                new FileRegexPermission(entry.getString("."), entry.getBoolean("[@negate]", false)));

    for (HierarchicalConfiguration suf : rs.configurationsAt("fileAccess.delete.suffixes.entry"))
        context.addFilePermission(FileAccess.DELETE, AccessType.PERMIT,
                new FileSuffixPermission(suf.getString("."), suf.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration prefix : rs.configurationsAt("fileAccess.delete.prefixes.entry"))
        context.addFilePermission(FileAccess.DELETE, AccessType.PERMIT,
                new FilePrefixPermission(prefix.getString("."), prefix.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration entry : rs.configurationsAt("fileAccess.delete.exactMatches.entry"))
        context.addFilePermission(FileAccess.DELETE, AccessType.PERMIT,
                new FileEqualsPermission(entry.getString("."), entry.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration entry : rs.configurationsAt("fileAccess.delete.regex.entry"))
        context.addFilePermission(FileAccess.DELETE, AccessType.PERMIT,
                new FileRegexPermission(entry.getString("."), entry.getBoolean("[@negate]", false)));

    Boolean cp = rs.getBoolean("fileAccess[@classpath]", false);
    if (cp)/*www .  j  ava  2  s  .  c o m*/
        context.addClasspath();

    Boolean home = rs.getBoolean("fileAccess[@home]", false);
    if (home)
        context.addHome();

    Boolean temp = rs.getBoolean("fileAccess[@temp]", false);
    if (temp)
        context.addTempDir();

    Boolean work = rs.getBoolean("fileAccess[@work]", false);
    if (work)
        context.addWorkDir();

    for (HierarchicalConfiguration suf : rs.configurationsAt("fileAccessDeny.read.suffixes.entry"))
        context.addFilePermission(FileAccess.READ, AccessType.DENY,
                new FileSuffixPermission(suf.getString("."), suf.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration prefix : rs.configurationsAt("fileAccessDeny.read.prefixes.entry"))
        context.addFilePermission(FileAccess.READ, AccessType.DENY,
                new FilePrefixPermission(prefix.getString("."), prefix.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration entry : rs.configurationsAt("fileAccessDeny.read.exactMatches.entry"))
        context.addFilePermission(FileAccess.READ, AccessType.DENY,
                new FileEqualsPermission(entry.getString("."), entry.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration entry : rs.configurationsAt("fileAccessDeny.read.regex.entry"))
        context.addFilePermission(FileAccess.READ, AccessType.DENY,
                new FileRegexPermission(entry.getString("."), entry.getBoolean("[@negate]", false)));

    for (HierarchicalConfiguration suf : rs.configurationsAt("fileAccessDeny.write.suffixes.entry"))
        context.addFilePermission(FileAccess.WRITE, AccessType.DENY,
                new FileSuffixPermission(suf.getString("."), suf.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration prefix : rs.configurationsAt("fileAccessDeny.write.prefixes.entry"))
        context.addFilePermission(FileAccess.WRITE, AccessType.DENY,
                new FilePrefixPermission(prefix.getString("."), prefix.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration entry : rs.configurationsAt("fileAccessDeny.write.exactMatches.entry"))
        context.addFilePermission(FileAccess.WRITE, AccessType.DENY,
                new FileEqualsPermission(entry.getString("."), entry.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration entry : rs.configurationsAt("fileAccessDeny.write.regex.entry"))
        context.addFilePermission(FileAccess.WRITE, AccessType.DENY,
                new FileRegexPermission(entry.getString("."), entry.getBoolean("[@negate]", false)));

    for (HierarchicalConfiguration suf : rs.configurationsAt("fileAccessDeny.delete.suffixes.entry"))
        context.addFilePermission(FileAccess.DELETE, AccessType.DENY,
                new FileSuffixPermission(suf.getString("."), suf.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration prefix : rs.configurationsAt("fileAccessDeny.delete.prefixes.entry"))
        context.addFilePermission(FileAccess.DELETE, AccessType.DENY,
                new FilePrefixPermission(prefix.getString("."), prefix.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration entry : rs.configurationsAt("fileAccessDeny.delete.exactMatches.entry"))
        context.addFilePermission(FileAccess.DELETE, AccessType.DENY,
                new FileEqualsPermission(entry.getString("."), entry.getBoolean("[@negate]", false)));
    for (HierarchicalConfiguration entry : rs.configurationsAt("fileAccessDeny.delete.regex.entry"))
        context.addFilePermission(FileAccess.DELETE, AccessType.DENY,
                new FileRegexPermission(entry.getString("."), entry.getBoolean("[@negate]", false)));
}

From source file:com.graphhopper.jsprit.io.algorithm.VehicleRoutingAlgorithms.java

private static VehicleRoutingAlgorithm readAndCreateAlgorithm(final VehicleRoutingProblem vrp,
        XMLConfiguration config, int nuOfThreads, final SolutionCostCalculator solutionCostCalculator,
        final StateManager stateManager, ConstraintManager constraintManager, boolean addDefaultCostCalculators,
        boolean addCoreConstraints) {
    // map to store constructed modules
    TypedMap definedClasses = new TypedMap();

    // algorithm listeners
    Set<PrioritizedVRAListener> algorithmListeners = new HashSet<PrioritizedVRAListener>();

    // insertion listeners
    List<InsertionListener> insertionListeners = new ArrayList<InsertionListener>();

    //threading/*from ww  w.j  a va2  s.com*/
    final ExecutorService executorService;
    if (nuOfThreads > 0) {
        log.debug("setup executor-service with " + nuOfThreads + " threads");
        executorService = Executors.newFixedThreadPool(nuOfThreads);
        algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, new AlgorithmEndsListener() {

            @Override
            public void informAlgorithmEnds(VehicleRoutingProblem problem,
                    Collection<VehicleRoutingProblemSolution> solutions) {
                log.debug("shutdown executor-service");
                executorService.shutdown();
            }
        }));
        Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {

            @Override
            public void uncaughtException(Thread arg0, Throwable arg1) {
                System.err.println(arg1.toString());
            }
        });
        Runtime.getRuntime().addShutdownHook(new Thread() {
            public void run() {
                if (!executorService.isShutdown()) {
                    System.err.println("shutdowHook shuts down executorService");
                    executorService.shutdown();
                }
            }
        });
    } else
        executorService = null;

    //create fleetmanager
    final VehicleFleetManager vehicleFleetManager = createFleetManager(vrp);

    String switchString = config.getString("construction.insertion.allowVehicleSwitch");
    final boolean switchAllowed;
    if (switchString != null) {
        switchAllowed = Boolean.parseBoolean(switchString);
    } else
        switchAllowed = true;
    ActivityTimeTracker.ActivityPolicy activityPolicy;
    if (stateManager.timeWindowUpdateIsActivated()) {
        UpdateVehicleDependentPracticalTimeWindows timeWindowUpdater = new UpdateVehicleDependentPracticalTimeWindows(
                stateManager, vrp.getTransportCosts(), vrp.getActivityCosts());
        timeWindowUpdater
                .setVehiclesToUpdate(new UpdateVehicleDependentPracticalTimeWindows.VehiclesToUpdate() {
                    Map<VehicleTypeKey, Vehicle> uniqueTypes = new HashMap<VehicleTypeKey, Vehicle>();

                    @Override
                    public Collection<Vehicle> get(VehicleRoute vehicleRoute) {
                        if (uniqueTypes.isEmpty()) {
                            for (Vehicle v : vrp.getVehicles()) {
                                if (!uniqueTypes.containsKey(v.getVehicleTypeIdentifier())) {
                                    uniqueTypes.put(v.getVehicleTypeIdentifier(), v);
                                }
                            }
                        }
                        Collection<Vehicle> vehicles = new ArrayList<Vehicle>();
                        vehicles.addAll(uniqueTypes.values());
                        return vehicles;
                    }
                });
        stateManager.addStateUpdater(timeWindowUpdater);
        activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS;
    } else {
        activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_ARRIVED;
    }
    stateManager.addStateUpdater(
            new UpdateActivityTimes(vrp.getTransportCosts(), activityPolicy, vrp.getActivityCosts()));
    stateManager.addStateUpdater(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(),
            stateManager, activityPolicy));

    final SolutionCostCalculator costCalculator;
    if (solutionCostCalculator == null)
        costCalculator = getDefaultCostCalculator(stateManager);
    else
        costCalculator = solutionCostCalculator;

    PrettyAlgorithmBuilder prettyAlgorithmBuilder = PrettyAlgorithmBuilder.newInstance(vrp, vehicleFleetManager,
            stateManager, constraintManager);
    if (addCoreConstraints)
        prettyAlgorithmBuilder.addCoreStateAndConstraintStuff();
    //construct initial solution creator
    final InsertionStrategy initialInsertionStrategy = createInitialSolution(config, vrp, vehicleFleetManager,
            stateManager, algorithmListeners, definedClasses, executorService, nuOfThreads, costCalculator,
            constraintManager, addDefaultCostCalculators);
    if (initialInsertionStrategy != null)
        prettyAlgorithmBuilder.constructInitialSolutionWith(initialInsertionStrategy, costCalculator);

    //construct algorithm, i.e. search-strategies and its modules
    int solutionMemory = config.getInt("strategy.memory");
    List<HierarchicalConfiguration> strategyConfigs = config
            .configurationsAt("strategy.searchStrategies.searchStrategy");
    for (HierarchicalConfiguration strategyConfig : strategyConfigs) {
        String name = getName(strategyConfig);
        SolutionAcceptor acceptor = getAcceptor(strategyConfig, vrp, algorithmListeners, definedClasses,
                solutionMemory);
        SolutionSelector selector = getSelector(strategyConfig, vrp, algorithmListeners, definedClasses);

        SearchStrategy strategy = new SearchStrategy(name, selector, acceptor, costCalculator);
        strategy.setName(name);
        List<HierarchicalConfiguration> modulesConfig = strategyConfig.configurationsAt("modules.module");
        for (HierarchicalConfiguration moduleConfig : modulesConfig) {
            SearchStrategyModule module = buildModule(moduleConfig, vrp, vehicleFleetManager, stateManager,
                    algorithmListeners, definedClasses, executorService, nuOfThreads, constraintManager,
                    addDefaultCostCalculators);
            strategy.addModule(module);
        }
        prettyAlgorithmBuilder.withStrategy(strategy, strategyConfig.getDouble("probability"));
    }

    //construct algorithm
    VehicleRoutingAlgorithm metaAlgorithm = prettyAlgorithmBuilder.build();
    int maxIterations = getMaxIterations(config);
    if (maxIterations > -1)
        metaAlgorithm.setMaxIterations(maxIterations);

    //define prematureBreak
    PrematureAlgorithmTermination prematureAlgorithmTermination = getPrematureTermination(config,
            algorithmListeners);
    if (prematureAlgorithmTermination != null)
        metaAlgorithm.setPrematureAlgorithmTermination(prematureAlgorithmTermination);
    else {
        List<HierarchicalConfiguration> terminationCriteria = config
                .configurationsAt("terminationCriteria.termination");
        for (HierarchicalConfiguration terminationConfig : terminationCriteria) {
            PrematureAlgorithmTermination termination = getTerminationCriterion(terminationConfig,
                    algorithmListeners);
            if (termination != null)
                metaAlgorithm.addTerminationCriterion(termination);
        }
    }
    for (PrioritizedVRAListener l : algorithmListeners) {
        metaAlgorithm.getAlgorithmListeners().add(l);
    }
    return metaAlgorithm;
}

From source file:com.eyeq.pivot4j.ui.condition.CellValueCondition.java

/**
 * @see com.eyeq.pivot4j.state.Configurable#restoreSettings(org.apache.commons.configuration.HierarchicalConfiguration)
 *///from  w w  w.java  2s.c om
@Override
public void restoreSettings(HierarchicalConfiguration configuration) {
    String name = configuration.getString("criteria");

    if (name == null) {
        this.criteria = null;
    } else {
        this.criteria = Criteria.valueOf(name);
    }

    this.value = configuration.getDouble("value", null);

    try {
        List<HierarchicalConfiguration> members = configuration.configurationsAt("position.member");

        this.positionUniqueNames = new LinkedList<String>();

        for (HierarchicalConfiguration member : members) {
            positionUniqueNames.add(member.getString(""));
        }
    } catch (IllegalArgumentException e) {
    }
}

From source file:com.processpuzzle.application.domain.Application.java

@SuppressWarnings("unchecked")
private DataLoader instantitateDataLoader(String className, HierarchicalConfiguration dataLoaderConfig)
        throws ApplicationException {
    DataLoader dataLoader = null;/*w w w  .  j  a  v  a2s.c o m*/
    Constructor<DataLoader> dataLoaderConstructor;

    List<HierarchicalConfiguration> arguments = dataLoaderConfig
            .configurationsAt(INSTANTIATION_ARGUMENTS_SELECTOR);
    Class<?>[] parameterTypes = new Class[arguments.size()];
    Object[] parameterValues = new Object[arguments.size()];

    try {
        for (int j = 0; j < arguments.size(); j++) {
            String selectorBase = INSTANTIATION_ARGUMENTS_SELECTOR + PropertyContext.PROPERTY_ARRAY_BEGIN
                    + String.valueOf(j) + PropertyContext.PROPERTY_ARRAY_END;
            String typeSelector = selectorBase + PropertyContext.ATTRIBUTE_BEGIN
                    + PropertyContext.ATTRIBUTE_SIGNER + PARAMETER_TYPE_ELEMENT_NAME
                    + PropertyContext.ATTRIBUTE_END;
            String paremeterType = dataLoaderConfig.getString(typeSelector);
            parameterTypes[j] = Class.forName(paremeterType);

            //String nameSelector = selectorBase + PropertyContext.ATTRIBUTE_BEGIN + PropertyContext.ATTRIBUTE_SIGNER + PARAMETER_NAME_ELEMENT_NAME + PropertyContext.ATTRIBUTE_END;

            String parameterValue = dataLoaderConfig.getString(selectorBase);
            parameterValues[j] = parameterValue;
        }

        Class<DataLoader> dataLoaderClass = (Class<DataLoader>) Class.forName(className);
        dataLoaderConstructor = dataLoaderClass.getConstructor(parameterTypes);
        dataLoader = (DataLoader) dataLoaderConstructor.newInstance(parameterValues);
    } catch (SecurityException e) {
        throw new ApplicationStartException(this, e);
    } catch (NoSuchMethodException e) {
        throw new ApplicationStartException(this, e);
    } catch (IllegalArgumentException e) {
        throw new ApplicationStartException(this, e);
    } catch (InstantiationException e) {
        throw new ApplicationStartException(this, e);
    } catch (IllegalAccessException e) {
        throw new ApplicationStartException(this, e);
    } catch (InvocationTargetException e) {
        throw new ApplicationStartException(this, e);
    } catch (ClassNotFoundException e) {
        throw new ApplicationStartException(this, e);
    }

    return dataLoader;
}

From source file:com.vangent.hieos.empi.codes.CodesConfig.java

/**
 *
 * @param hc//w  ww  . j a va  2s.  c  om
 */
private void loadCodeSet(HierarchicalConfiguration hc) {
    String codeSystem = hc.getString(CODE_SYSTEM_ATTRIBUTE);
    String codeSystemName = hc.getString(CODE_SYSTEM_NAME_ATTRIBUTE);
    String codeSystemVersion = hc.getString(CODE_SYSTEM_VERSION_ATTRIBUTE);
    CodeSystem codeSystemObj = new CodeSystem();
    codeSystemObj.setCodeSystem(codeSystem);
    codeSystemObj.setCodeSystemName(codeSystemName);
    codeSystemObj.setCodeSystemVersion(codeSystemVersion);
    this.codeSystemsByName.put(codeSystem, codeSystemObj);
    // Now, get list of codes.
    List hcCodes = hc.configurationsAt(CODE);
    for (Iterator it = hcCodes.iterator(); it.hasNext();) {
        HierarchicalConfiguration hcCode = (HierarchicalConfiguration) it.next();
        String code = hcCode.getString(VALUE_ATTRIBUTE);
        String displayName = hcCode.getString(DISPLAY_NAME_ATTRIBUTE);
        codeSystemObj.addCode(code, displayName);
    }
}

From source file:edu.kit.dama.mdm.core.MetaDataManagement.java

/**
 * Load configuration from XML-File// ww w  .  j a va2 s. c o  m
 */
private void loadConfiguration() {
    String firstImplementation = null;
    String firstPersistenceUnit = null;
    HierarchicalConfiguration hc = null;
    List<String> persistenceUnits = null;
    URL configURL = null;
    try {
        configURL = DataManagerSettings.getConfigurationURL();
        LOGGER.debug("Loading configuration from {}", configURL);
        hc = new HierarchicalConfiguration(new XMLConfiguration(configURL));
        LOGGER.debug("Configuration successfully loaded");
    } catch (ConfigurationException ex) {
        // error in configuration
        // reason see debug log message:
        LOGGER.error("Failed to load configuration.", ex);
        throw new RuntimeException(ex);
    }
    SubnodeConfiguration configurationAt = hc.configurationAt(CONFIG_ROOT);
    List fields = configurationAt.configurationsAt(CONFIG_PERSISTENCE_IMPL);
    LOGGER.debug("Found {} configured persistence implementations", fields.size());
    persistenceUnitMap = new HashMap<>();
    persistenceClassMap = new HashMap<>();
    persistenceUnitDefaultMap = new HashMap<>();

    String implementationName;
    IPersistenceFactory iPersistenceFactory = null;
    for (Iterator it = fields.iterator(); it.hasNext();) {
        HierarchicalConfiguration sub = (HierarchicalConfiguration) it.next();
        LOGGER.debug("Reading sub-configuration");
        // First get all persistence units.
        persistenceUnits = new ArrayList<>();
        try {
            List<HierarchicalConfiguration> persistenceUnitsList = sub
                    .configurationsAt(CONFIG_PERSISTENCE_UNIT);
            if (persistenceUnitsList == null) {
                persistenceUnitsList = new LinkedList<>();
            }
            LOGGER.debug("Configuration contains {} persistence units.", persistenceUnitsList.size());
            firstPersistenceUnit = null;
            for (HierarchicalConfiguration item : persistenceUnitsList) {
                String value = item.getString(".");
                String defaultAttribute = item.getString("[@default]");

                LOGGER.debug("PersistenceUnit found: " + value);
                LOGGER.debug("@default = {}", defaultAttribute);

                if (Boolean.parseBoolean(defaultAttribute)) {
                    if (firstPersistenceUnit == null) {
                        LOGGER.debug("{} is used as default persistence unit.", value);
                        firstPersistenceUnit = value;
                    } else {
                        LOGGER.warn(
                                "{} is an additional persistence unit defined as default. We'll ignore this.",
                                value);
                    }
                }

                LOGGER.debug("Adding persistence unit to list of units.");
                persistenceUnits.add(value);
            }

        } catch (Exception any) {
            LOGGER.error("Failed to read persistence units.", any);
        }
        LOGGER.debug("firstPersistenceUnit: " + firstPersistenceUnit);
        if ((persistenceUnits.size() > 0) && (firstPersistenceUnit == null)) {
            LOGGER.debug("No default persistence unit defined. Using first entry ({})",
                    persistenceUnits.get(0));
            firstPersistenceUnit = persistenceUnits.get(0);
        }
        LOGGER.debug("Getting implementation name.");
        implementationName = sub.getString(CONFIG_PERSISTENCE_NAME);
        LOGGER.debug("Implementation name '{}' found.", implementationName);
        if (firstImplementation == null) {
            LOGGER.debug("Using implementation '{}' as first implementation.", implementationName);
            firstImplementation = implementationName;
        }
        LOGGER.debug("Testing implementation '{}'", implementationName);
        if (sub.containsKey(CONFIG_DEFAULT_PERSISTENCE)) {
            LOGGER.debug("'{}' is configured as default implementation.", implementationName);
            if (defaultImplementation != null) {
                LOGGER.warn("{} is an additional implementation defined as default. We'll ignore this.",
                        implementationName);
            } else {
                defaultImplementation = implementationName;
            }
        }
        Class<?> loadClass;
        boolean success = false;
        String persistenceClass = sub.getString(CONFIG_PERSISTENCE_CLASS);
        try {

            LOGGER.debug("Loading class '{}': ", persistenceClass);
            loadClass = getClass().getClassLoader().loadClass(persistenceClass);
            LOGGER.debug("Checking IPersistenceFactory.class.assignableFrom({})", persistenceClass);
            success = IPersistenceFactory.class.isAssignableFrom(loadClass);
            iPersistenceFactory = null;
            if (success) {
                LOGGER.debug("Creating instance of class {}", persistenceClass);
                iPersistenceFactory = (IPersistenceFactory) loadClass.newInstance();
                LOGGER.debug("Persistence factory successfully instantiated.");
            } else {
                LOGGER.error("IPersistenceFactory seems not to be assignable from class {}", persistenceClass);
            }
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException ex) {
            LOGGER.error("Failed to create instance of persistence implementation " + persistenceClass, ex);
            success = false;
        }
        if (success) {
            persistenceUnitMap.put(implementationName, persistenceUnits);
            persistenceClassMap.put(implementationName, iPersistenceFactory);
            persistenceUnitDefaultMap.put(implementationName, firstPersistenceUnit);
        } else {
            throw new edu.kit.dama.mdm.core.exception.ConfigurationException(
                    "Failed to initialize persistence factory from URL '" + configURL
                            + "'. See logfile for details.");
        }
    }
    if (defaultImplementation == null) {
        LOGGER.debug("Default implementation not set, yet. Using first one ({}) as default.",
                firstImplementation);
        defaultImplementation = firstImplementation;
    }
}

From source file:edu.uw.sig.frames2owl.util.BatchFromIncludeConverter.java

private void runBatch() {
    // read general configuration parameters
    HierarchicalConfiguration conv = batchFromIncludeConfig.configurationAt("conv");

    // run converter for primary 
    String framesPath = conv.getString("frames-path");
    String owlPath = conv.getString("owl-path");
    String owlURI = conv.getString("owl-uri");
    String configPath = conv.getString("conf-path");

    //System.err.println("will create run using args: "+ framesPath+" "+owlPath+" "+owlURI);
    Converter mainConv = new Converter(framesPath, owlPath, owlURI, configPath);
    mainConv.run();//  w ww . j av  a 2 s . co  m

    // reuse frame2ProjectMap
    Map<FrameID, String> frame2ProjectMap = mainConv.getFrame2ProjectMap();

    // get all of the included ont configs
    List<HierarchicalConfiguration> inclConfs = conv.configurationsAt("include");
    Map<String, HierarchicalConfiguration> name2ConfMap = new HashMap<String, HierarchicalConfiguration>();
    for (HierarchicalConfiguration inclConf : inclConfs) {
        String name = inclConf.getString("[@name]");
        if (name == null || name.equals("")) {
            System.err.println("Include configuration with no name attribute");
            continue;
        }
        name2ConfMap.put(name, inclConf);
    }

    // create and run converter for each included ont
    Collection<URI> includedProjURIs = mainConv.getIncludedProjects();
    for (URI includedProjURI : includedProjURIs) {
        String ontName = getOntNameFromURI(includedProjURI);
        HierarchicalConfiguration include = name2ConfMap.get(ontName);
        if (include == null) {
            System.err.println("Included ontology with no corresponding batch config entry");
            continue;
        }
        System.err.println(include);

        //TODO you are here!
        String includeFramesPath = includedProjURI.getPath();
        String includeOwlPath = include.getString("owl-path");
        String includeOwlURI = include.getString("owl-uri");
        String includeConfigPath = include.getString("conf-path");
        Converter importConv = new Converter(includeFramesPath, includeOwlPath, includeOwlURI,
                includeConfigPath, frame2ProjectMap);
        importConv.run();
    }

    /*
    for(HierarchicalConfiguration conv : convs)
     {
        // get arguments for run
       // i.e. resource/cho.pprj results/test.owl http://si.uw.edu/ont/fma.owl
       String framesPath = conv.getString("frames-path");
       String owlPath = conv.getString("owl-path");
       String owlURI = conv.getString("owl-uri");
       String configPath = conv.getString("conf-path");
               
       //System.err.println("will create run using args: "+ framesPath+" "+owlPath+" "+owlURI);
       Converter currConv = new Converter(framesPath, owlPath, owlURI, configPath);
       currConv.run();
     }
     */
}

From source file:net.datenwerke.sandbox.util.SandboxParser.java

protected void configurePackages(SandboxContext set, HierarchicalConfiguration rs) {
    for (Object e : rs.getList("packages.whitelist.entry"))
        set.addPackagePermission(AccessType.PERMIT, (String) e);

    for (Object e : rs.getList("packages.blacklist.entry"))
        set.addPackagePermission(AccessType.DENY, (String) e);

    for (HierarchicalConfiguration compl : rs.configurationsAt("packages.whitelist.complex")) {
        String cName = compl.getString("[@name]");

        Collection<StackEntry> entries = new HashSet<StackEntry>();

        for (HierarchicalConfiguration stack : compl.configurationsAt("check"))
            entries.add(getStackEntry(stack));

        PackagePermission wpkg = new PackagePermission(cName, entries);

        set.addPackagePermission(wpkg);/*from w  w  w .  ja v a2 s .c  om*/
    }
}