Example usage for org.apache.commons.configuration Configuration getFloat

List of usage examples for org.apache.commons.configuration Configuration getFloat

Introduction

In this page you can find the example usage for org.apache.commons.configuration Configuration getFloat.

Prototype

float getFloat(String key);

Source Link

Document

Get a float associated with the given configuration key.

Usage

From source file:com.discursive.jccook.configuration.ConfigurationExample.java

public static void main(String[] args) throws Exception {

    ConfigurationExample example = new ConfigurationExample();

    ConfigurationFactory factory = new ConfigurationFactory();
    URL configURL = example.getClass().getResource("configuration.xml");
    factory.setConfigurationURL(configURL);

    Configuration config = factory.getConfiguration();

    System.out.println("Timeout: " + config.getFloat("timeout"));
    System.out.println("Region: " + config.getString("region"));
    System.out.println("Name: " + config.getString("name"));
    System.out.println("Speed: " + config.getInt("speed"));
}

From source file:com.discursive.jccook.configuration.TypedConfigurationExample.java

public static void main(String[] args) throws Exception {
    Configuration config = new PropertiesConfiguration("test.properties");

    System.out.println("Speed: " + config.getFloat("speed"));
    System.out.println("Names: " + config.getList("names"));
    System.out.println("Correct: " + config.getBoolean("correct"));
}

From source file:com.manydesigns.elements.configuration.CommonsConfigurationFunctions.java

public static float getFloat(Configuration configuration, String key) {
    return configuration.getFloat(key);
}

From source file:at.salzburgresearch.kmt.zkconfig.ZookeeperConfigurationTest.java

@Test
public void testFloat() throws Exception {
    Configuration config = new ZookeeperConfiguration(zkConnection, 5000, "/test");

    final String key = UUID.randomUUID().toString();
    final Random random = new Random();
    final float val1 = random.nextFloat();
    final Float val2 = random.nextFloat();

    assertThat(config.getProperty(key), nullValue());

    config.setProperty(key, val1);
    assertEquals(val1, config.getFloat(key), 10e-6);
    assertEquals(new Float(val1), config.getFloat(key, val2));

    config.setProperty(key, val2);
    assertEquals(val2, config.getFloat(key), 10e-6);
    assertEquals(val2, config.getFloat(key, Float.valueOf(val1)));

}

From source file:nl.tudelft.graphalytics.configuration.ConfigurationUtil.java

public static float getFloat(Configuration config, String property) throws InvalidConfigurationException {
    ensureConfigurationKeyExists(config, property);
    try {/*www . j  av a  2s  . c  om*/
        return config.getFloat(property);
    } catch (ConversionException ignore) {
        throw new InvalidConfigurationException("Invalid value for property \"" + resolve(config, property)
                + "\": \"" + config.getString(property) + "\", expected a floating point value.");
    }
}

From source file:org.lable.oss.dynamicconfig.core.commonsconfiguration.ConcurrentConfigurationTest.java

@Test
public void testMethodWrappers() {
    CombinedConfiguration mockConfiguration = mock(CombinedConfiguration.class);
    Configuration concurrentConfiguration = new ConcurrentConfiguration(mockConfiguration, null);

    concurrentConfiguration.subset("subset");
    concurrentConfiguration.isEmpty();//from   w  ww.  ja v a2 s. co m
    concurrentConfiguration.containsKey("key");
    concurrentConfiguration.getProperty("getprop");
    concurrentConfiguration.getKeys("getkeys");
    concurrentConfiguration.getKeys();
    concurrentConfiguration.getProperties("getprops");
    concurrentConfiguration.getBoolean("getboolean1");
    concurrentConfiguration.getBoolean("getboolean2", true);
    concurrentConfiguration.getBoolean("getboolean3", Boolean.FALSE);
    concurrentConfiguration.getByte("getbyte1");
    concurrentConfiguration.getByte("getbyte2", (byte) 0);
    concurrentConfiguration.getByte("getbyte3", Byte.valueOf((byte) 0));
    concurrentConfiguration.getDouble("getdouble1");
    concurrentConfiguration.getDouble("getdouble2", 0.2);
    concurrentConfiguration.getDouble("getdouble3", Double.valueOf(0.2));
    concurrentConfiguration.getFloat("getfloat1");
    concurrentConfiguration.getFloat("getfloat2", 0f);
    concurrentConfiguration.getFloat("getfloat3", Float.valueOf(0f));
    concurrentConfiguration.getInt("getint1");
    concurrentConfiguration.getInt("getint2", 0);
    concurrentConfiguration.getInteger("getint3", 0);
    concurrentConfiguration.getLong("getlong1");
    concurrentConfiguration.getLong("getlong2", 0L);
    concurrentConfiguration.getLong("getlong3", Long.valueOf(0L));
    concurrentConfiguration.getShort("getshort1");
    concurrentConfiguration.getShort("getshort2", (short) 0);
    concurrentConfiguration.getShort("getshort3", Short.valueOf((short) 0));
    concurrentConfiguration.getBigDecimal("getbigd1");
    concurrentConfiguration.getBigDecimal("getbigd2", BigDecimal.valueOf(0.4));
    concurrentConfiguration.getBigInteger("getbigi1");
    concurrentConfiguration.getBigInteger("getbigi2", BigInteger.valueOf(2L));
    concurrentConfiguration.getString("getstring1");
    concurrentConfiguration.getString("getstring2", "def");
    concurrentConfiguration.getStringArray("stringarray");
    concurrentConfiguration.getList("getlist1");
    concurrentConfiguration.getList("getlist2", Arrays.asList("a", "b"));

    verify(mockConfiguration, times(1)).subset("subset");
    verify(mockConfiguration, times(1)).isEmpty();
    verify(mockConfiguration, times(1)).containsKey("key");
    verify(mockConfiguration, times(1)).getProperty("getprop");
    verify(mockConfiguration, times(1)).getKeys("getkeys");
    verify(mockConfiguration, times(1)).getKeys();
    verify(mockConfiguration, times(1)).getProperties("getprops");
    verify(mockConfiguration, times(1)).getBoolean("getboolean1");
    verify(mockConfiguration, times(1)).getBoolean("getboolean2", true);
    verify(mockConfiguration, times(1)).getBoolean("getboolean3", Boolean.FALSE);
    verify(mockConfiguration, times(1)).getByte("getbyte1");
    verify(mockConfiguration, times(1)).getByte("getbyte2", (byte) 0);
    verify(mockConfiguration, times(1)).getByte("getbyte3", Byte.valueOf((byte) 0));
    verify(mockConfiguration, times(1)).getDouble("getdouble1");
    verify(mockConfiguration, times(1)).getDouble("getdouble2", 0.2);
    verify(mockConfiguration, times(1)).getDouble("getdouble3", Double.valueOf(0.2));
    verify(mockConfiguration, times(1)).getFloat("getfloat1");
    verify(mockConfiguration, times(1)).getFloat("getfloat2", 0f);
    verify(mockConfiguration, times(1)).getFloat("getfloat3", Float.valueOf(0f));
    verify(mockConfiguration, times(1)).getInt("getint1");
    verify(mockConfiguration, times(1)).getInt("getint2", 0);
    verify(mockConfiguration, times(1)).getInteger("getint3", Integer.valueOf(0));
    verify(mockConfiguration, times(1)).getLong("getlong1");
    verify(mockConfiguration, times(1)).getLong("getlong2", 0L);
    verify(mockConfiguration, times(1)).getLong("getlong3", Long.valueOf(0L));
    verify(mockConfiguration, times(1)).getShort("getshort1");
    verify(mockConfiguration, times(1)).getShort("getshort2", (short) 0);
    verify(mockConfiguration, times(1)).getShort("getshort3", Short.valueOf((short) 0));
    verify(mockConfiguration, times(1)).getBigDecimal("getbigd1");
    verify(mockConfiguration, times(1)).getBigDecimal("getbigd2", BigDecimal.valueOf(0.4));
    verify(mockConfiguration, times(1)).getBigInteger("getbigi1");
    verify(mockConfiguration, times(1)).getBigInteger("getbigi2", BigInteger.valueOf(2L));
    verify(mockConfiguration, times(1)).getString("getstring1");
    verify(mockConfiguration, times(1)).getString("getstring2", "def");
    verify(mockConfiguration, times(1)).getStringArray("stringarray");
    verify(mockConfiguration, times(1)).getList("getlist1");
    verify(mockConfiguration, times(1)).getList("getlist2", Arrays.asList("a", "b"));
}

From source file:uk.ac.ebi.fg.jobs.OntologySimilarityJob.java

public void doExecute(JobExecutionContext jobExecutionContext)
        throws JobExecutionException, InterruptedException {
    JobDataMap dataMap = jobExecutionContext.getJobDetail().getJobDataMap();
    Map<ExperimentId, SortedSet<EfoTerm>> smallMap = (Map<ExperimentId, SortedSet<EfoTerm>>) dataMap
            .get("smallMap");
    OntologyDistanceCalculator distanceCalculator = (OntologyDistanceCalculator) dataMap
            .get("distanceCalculator");
    Map<String, SortedSet<ExperimentId>> uriToExpMap = (ConcurrentHashMap<String, SortedSet<ExperimentId>>) dataMap
            .get("uriToExpMap");
    Map<ExperimentId, SortedSet<EfoTerm>> expToURIMap = (ConcurrentHashMap<ExperimentId, SortedSet<EfoTerm>>) dataMap
            .get("expToURIMap");
    Map<ExperimentId, SortedSet<ExperimentId>> ontologyResults = (ConcurrentHashMap<ExperimentId, SortedSet<ExperimentId>>) dataMap
            .get("ontologyResults");
    lowPriorityURIs = (SortedSet<String>) dataMap.get("lowPriorityOntologyURIs");
    int counter = (Integer) dataMap.get("counter");
    Configuration properties = (Configuration) dataMap.get("properties");

    final int maxOWLSimilarityCount = properties.getInt("max_displayed_OWL_similarities");
    final int smallExpAssayCountLimit = properties.getInt("small_experiment_assay_count_limit");
    final float minCalculatedOntologyDistance = properties.getFloat("minimal_calculated_ontology_distance");

    logger.info("Started " + (counter - smallMap.size()) + " - " + counter + " ontology similarity jobs");

    for (Map.Entry<ExperimentId, SortedSet<EfoTerm>> entry : smallMap.entrySet()) {
        ExperimentId experiment = entry.getKey();
        SortedSet<ExperimentId> resultExpSimilaritySet = new TreeSet<ExperimentId>();

        for (EfoTerm efoTerm : entry.getValue()) {
            Set<OntologySimilarityResult> similars = distanceCalculator.getSimilarNodes(efoTerm.getUri());

            if (null != similars) {
                for (OntologySimilarityResult ontologySimilarityResult : similars) {
                    int distance = ontologySimilarityResult.getDistance();
                    SortedSet<ExperimentId> similarExperiments = uriToExpMap
                            .get(ontologySimilarityResult.getURI());

                    if (similarExperiments != null) {
                        for (ExperimentId exp : similarExperiments) {
                            if (experiment.getSpecies().equals(exp.getSpecies()) && !experiment.equals(exp)) {
                                if (resultExpSimilaritySet.contains(exp)) {
                                    ExperimentId expClone = resultExpSimilaritySet.tailSet(exp).first().clone();
                                    resultExpSimilaritySet.remove(exp);
                                    resultExpSimilaritySet.add(
                                            setDistance(expClone, ontologySimilarityResult.getURI(), distance));
                                } else {
                                    ExperimentId expClone = exp.clone();
                                    resultExpSimilaritySet.add(
                                            setDistance(expClone, ontologySimilarityResult.getURI(), distance));
                                }//from ww  w. j av  a  2  s .co  m
                            }
                        }
                    }
                }
            }
        }

        // store information for maximal score calculation
        ExperimentId experimentClone = experiment.clone();
        for (EfoTerm efoTerm : expToURIMap.get(experimentClone)) {
            if (lowPriorityURIs.contains(efoTerm.getUri()))
                experimentClone.setLowPriorityMatchCount(experimentClone.getLowPriorityMatchCount() + 1);
            else
                experimentClone.setDist0Count(experimentClone.getDist0Count() + 1);

            experimentClone.setNumbOfMatches(experimentClone.getNumbOfMatches() + 1);
        }

        ontologyResults.put(experimentClone, cleanResults(experimentClone, resultExpSimilaritySet,
                smallExpAssayCountLimit, maxOWLSimilarityCount, minCalculatedOntologyDistance, expToURIMap));

        Thread.currentThread().wait(1);
    }

    logger.info("Finished " + (counter - smallMap.size()) + " - " + counter + " ontology similarity jobs");

    smallMap.clear();
}