com.opengamma.strata.basics.currency.CurrencyDataLoader.java Source code

Introduction

Here is the source code for com.opengamma.strata.basics.currency.CurrencyDataLoader.java

Source

/**
 * Copyright (C) 2015 - present by OpenGamma Inc. and the OpenGamma group of companies
 *
 * Please see distribution for license.
 */
package com.opengamma.strata.basics.currency;

import static com.opengamma.strata.collect.Guavate.toImmutableList;

import java.util.Arrays;
import java.util.List;
import java.util.Map.Entry;
import java.util.logging.Logger;

import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableMap;
import com.opengamma.strata.collect.io.IniFile;
import com.opengamma.strata.collect.io.PropertySet;
import com.opengamma.strata.collect.io.ResourceConfig;

/**
 * Internal loader of currency and currency pair data.
 * <p>
 * This loads configuration files for {@link Currency} and {@link CurrencyPair}.
 */
final class CurrencyDataLoader {

    /**
     * The logger.
     */
    private static final Logger log = Logger.getLogger(CurrencyDataLoader.class.getName());
    /**
     * INI file for currency data.
     */
    private static final String CURRENCY_INI = "Currency.ini";
    /**
     * INI file for currency pair data.
     */
    private static final String PAIR_INI = "CurrencyPair.ini";
    /**
     * INI file containing a list of general currency data.
     * This in includes a list of currencies in priority order used to choose the base currency of the market
     * convention pair for pairs that aren't configured in currency-pair.ini.
     */
    private static final String CURRENCY_DATA_INI = "CurrencyData.ini";

    // restricted constructor
    private CurrencyDataLoader() {
    }

    //-------------------------------------------------------------------------
    /**
     * Loads the available currencies.
     * 
     * @param loadHistoric  whether to load the historic or active currencies
     * @return the map of known currencies
     */
    static ImmutableMap<String, Currency> loadCurrencies(boolean loadHistoric) {
        try {
            IniFile ini = ResourceConfig.combinedIniFile(ResourceConfig.orderedResources(CURRENCY_INI));
            return parseCurrencies(ini, loadHistoric);

        } catch (RuntimeException ex) {
            // logging used because this is loaded in a static variable
            log.severe(Throwables.getStackTraceAsString(ex));
            // return an empty instance to avoid ExceptionInInitializerError
            return ImmutableMap.of();
        }
    }

    // parse currency info
    private static ImmutableMap<String, Currency> parseCurrencies(IniFile ini, boolean loadHistoric) {
        ImmutableMap.Builder<String, Currency> builder = ImmutableMap.builder();
        for (Entry<String, PropertySet> entry : ini.asMap().entrySet()) {
            String currencyCode = entry.getKey();
            if (currencyCode.length() == 3 && Currency.CODE_MATCHER.matchesAllOf(currencyCode)) {
                PropertySet properties = entry.getValue();
                boolean isHistoric = (properties.keys().contains("historic")
                        && Boolean.parseBoolean(properties.value("historic")));
                if (isHistoric == loadHistoric) {
                    Integer minorUnits = Integer.parseInt(properties.value("minorUnitDigits"));
                    String triangulationCurrency = properties.value("triangulationCurrency");
                    builder.put(currencyCode, new Currency(currencyCode, minorUnits, triangulationCurrency));
                }
            }
        }
        return builder.build();
    }

    //-------------------------------------------------------------------------
    /**
     * Loads the available currency pairs.
     * 
     * @return the map of known currency pairs, where the value is the number of digits in the rate
     */
    static ImmutableMap<CurrencyPair, Integer> loadPairs() {
        try {
            IniFile ini = ResourceConfig.combinedIniFile(ResourceConfig.orderedResources(PAIR_INI));
            return parsePairs(ini);

        } catch (RuntimeException ex) {
            // logging used because this is loaded in a static variable
            log.severe(Throwables.getStackTraceAsString(ex));
            // return an empty instance to avoid ExceptionInInitializerError
            return ImmutableMap.of();
        }
    }

    // parse pair info
    private static ImmutableMap<CurrencyPair, Integer> parsePairs(IniFile ini) {
        ImmutableMap.Builder<CurrencyPair, Integer> builder = ImmutableMap.builder();
        for (Entry<String, PropertySet> entry : ini.asMap().entrySet()) {
            String pairStr = entry.getKey();
            if (CurrencyPair.REGEX_FORMAT.matcher(pairStr).matches()) {
                CurrencyPair pair = CurrencyPair.parse(pairStr);
                PropertySet properties = entry.getValue();
                Integer rateDigits = Integer.parseInt(properties.value("rateDigits"));
                builder.put(pair, rateDigits);
            }
        }
        return builder.build();
    }

    /**
     * Loads the priority order of currencies, used to determine the base currency of the market convention pair
     * for pairs that aren't explicitly configured.
     *
     * @return a map of currency to order
     */
    static ImmutableMap<Currency, Integer> loadOrdering() {
        try {
            IniFile ini = ResourceConfig.combinedIniFile(ResourceConfig.orderedResources(CURRENCY_DATA_INI));
            PropertySet section = ini.section("marketConventionPriority");
            String list = section.value("ordering");
            // The currency ordering is defined as a comma-separated list
            List<Currency> currencies = Arrays.stream(list.split(",")).map(String::trim).map(Currency::of)
                    .collect(toImmutableList());

            ImmutableMap.Builder<Currency, Integer> orderBuilder = ImmutableMap.builder();

            for (int i = 0; i < currencies.size(); i++) {
                orderBuilder.put(currencies.get(i), i + 1);
            }
            return orderBuilder.build();
        } catch (Exception ex) {
            // logging used because this is loaded in a static variable
            log.severe(Throwables.getStackTraceAsString(ex));
            // return an empty instance to avoid ExceptionInInitializerError
            return ImmutableMap.of();
        }
    }
}