/**
* Copyright (C) 2013 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.web.analytics.blotter;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.util.Map;
import java.util.Set;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.WordUtils;
import org.joda.beans.BeanBuilder;
import org.joda.beans.MetaBean;
import org.joda.beans.MetaProperty;
import org.joda.convert.StringConvert;
import org.joda.convert.StringConverter;
import org.threeten.bp.LocalDate;
import org.threeten.bp.LocalTime;
import org.threeten.bp.OffsetTime;
import org.threeten.bp.ZoneOffset;
import org.threeten.bp.ZonedDateTime;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.opengamma.analytics.financial.credit.DebtSeniority;
import com.opengamma.core.id.ExternalSchemes;
import com.opengamma.financial.convention.StubType;
import com.opengamma.financial.conversion.JodaBeanConverters;
import com.opengamma.financial.security.FinancialSecurity;
import com.opengamma.financial.security.LongShort;
import com.opengamma.financial.security.capfloor.CapFloorCMSSpreadSecurity;
import com.opengamma.financial.security.capfloor.CapFloorSecurity;
import com.opengamma.financial.security.cash.CashSecurity;
import com.opengamma.financial.security.cds.CreditDefaultSwapIndexSecurity;
import com.opengamma.financial.security.cds.CreditDefaultSwapSecurity;
import com.opengamma.financial.security.cds.LegacyFixedRecoveryCDSSecurity;
import com.opengamma.financial.security.cds.LegacyRecoveryLockCDSSecurity;
import com.opengamma.financial.security.cds.LegacyVanillaCDSSecurity;
import com.opengamma.financial.security.cds.StandardFixedRecoveryCDSSecurity;
import com.opengamma.financial.security.cds.StandardRecoveryLockCDSSecurity;
import com.opengamma.financial.security.cds.StandardVanillaCDSSecurity;
import com.opengamma.financial.security.equity.EquityVarianceSwapSecurity;
import com.opengamma.financial.security.fra.FRASecurity;
import com.opengamma.financial.security.fx.FXForwardSecurity;
import com.opengamma.financial.security.fx.NonDeliverableFXForwardSecurity;
import com.opengamma.financial.security.option.BarrierDirection;
import com.opengamma.financial.security.option.BarrierType;
import com.opengamma.financial.security.option.CreditDefaultSwapOptionSecurity;
import com.opengamma.financial.security.option.FXBarrierOptionSecurity;
import com.opengamma.financial.security.option.FXDigitalOptionSecurity;
import com.opengamma.financial.security.option.FXOptionSecurity;
import com.opengamma.financial.security.option.MonitoringType;
import com.opengamma.financial.security.option.NonDeliverableFXOptionSecurity;
import com.opengamma.financial.security.option.OptionType;
import com.opengamma.financial.security.option.SamplingFrequency;
import com.opengamma.financial.security.option.SwaptionSecurity;
import com.opengamma.financial.security.swap.FixedInflationSwapLeg;
import com.opengamma.financial.security.swap.FixedInterestRateLeg;
import com.opengamma.financial.security.swap.FloatingGearingIRLeg;
import com.opengamma.financial.security.swap.FloatingInterestRateLeg;
import com.opengamma.financial.security.swap.FloatingSpreadIRLeg;
import com.opengamma.financial.security.swap.InflationIndexSwapLeg;
import com.opengamma.financial.security.swap.InterestRateNotional;
import com.opengamma.financial.security.swap.SwapLeg;
import com.opengamma.financial.security.swap.SwapSecurity;
import com.opengamma.financial.security.swap.YearOnYearInflationSwapSecurity;
import com.opengamma.financial.security.swap.ZeroCouponInflationSwapSecurity;
import com.opengamma.id.ExternalId;
import com.opengamma.id.ExternalIdBundle;
import com.opengamma.master.security.ManageableSecurity;
import com.opengamma.util.ArgumentChecker;
import com.opengamma.util.time.Expiry;
/**
*
*/
/* package */ class BlotterUtils {
// TODO this should be configurable, should be able to add from client projects
/** All the securities and related types supported by the blotter. */
private static final Set<MetaBean> s_metaBeans = Sets.<MetaBean>newHashSet(
FXForwardSecurity.meta(),
SwapSecurity.meta(),
SwaptionSecurity.meta(),
CapFloorCMSSpreadSecurity.meta(),
NonDeliverableFXOptionSecurity.meta(),
FXOptionSecurity.meta(),
FRASecurity.meta(),
CapFloorSecurity.meta(),
EquityVarianceSwapSecurity.meta(),
FXBarrierOptionSecurity.meta(),
FXDigitalOptionSecurity.meta(),
FixedInterestRateLeg.meta(),
FloatingInterestRateLeg.meta(),
FloatingSpreadIRLeg.meta(),
FloatingGearingIRLeg.meta(),
FixedInflationSwapLeg.meta(),
InflationIndexSwapLeg.meta(),
InterestRateNotional.meta(),
LegacyVanillaCDSSecurity.meta(),
LegacyRecoveryLockCDSSecurity.meta(),
LegacyFixedRecoveryCDSSecurity.meta(),
StandardVanillaCDSSecurity.meta(),
StandardRecoveryLockCDSSecurity.meta(),
StandardFixedRecoveryCDSSecurity.meta(),
CreditDefaultSwapIndexSecurity.meta(),
CreditDefaultSwapOptionSecurity.meta(),
YearOnYearInflationSwapSecurity.meta(),
ZeroCouponInflationSwapSecurity.meta());
/** Meta bean factory for looking up meta beans by type name. */
private static final MetaBeanFactory s_metaBeanFactory = new MapMetaBeanFactory(s_metaBeans);
/** Formatter for decimal numbers, DecimalFormat isn't thread safe. */
private static final ThreadLocal<DecimalFormat> s_decimalFormat = new ThreadLocal<DecimalFormat>() {
@Override
protected DecimalFormat initialValue() {
DecimalFormat decimalFormat = new DecimalFormat("#,###.#####");
decimalFormat.setParseBigDecimal(true);
return decimalFormat;
}
};
/**
* For traversing trade and security {@link MetaBean}s and building instances from the data sent from the blotter.
* The security type name is filtered out because it is a read-only property. The external ID bundle is filtered
* out because it is always empty for trades and securities entered via the blotter but isn't nullable. Therefore
* it has to be explicitly set to an empty bundle after the client data is processed but before the object is built.
*/
private static final BeanTraverser s_beanBuildingTraverser = new BeanTraverser(
new PropertyFilter(FinancialSecurity.meta().externalIdBundle()),
new PropertyFilter(ManageableSecurity.meta().securityType()));
/** For converting between strings values used by the UI and real objects. */
private static final StringConvert s_stringConvert;
/** For converting property values when creating trades and securities from JSON. */
private static final Converters s_beanBuildingConverters;
/** For converting property values when creating JSON objects from trades and securities. */
private static final Converters s_jsonBuildingConverters;
static {
StringToRegionIdConverter stringToRegionIdConverter = new StringToRegionIdConverter();
// for building beans from JSON
Map<MetaProperty<?>, Converter<?, ?>> beanRegionConverters = Maps.newHashMap();
beanRegionConverters.putAll(
ImmutableMap.<MetaProperty<?>, Converter<?, ?>>of(
CashSecurity.meta().regionId(), stringToRegionIdConverter,
CreditDefaultSwapSecurity.meta().regionId(), stringToRegionIdConverter,
EquityVarianceSwapSecurity.meta().regionId(), stringToRegionIdConverter,
FRASecurity.meta().regionId(), stringToRegionIdConverter,
SwapLeg.meta().regionId(), stringToRegionIdConverter));
beanRegionConverters.putAll(
ImmutableMap.<MetaProperty<?>, Converter<?, ?>>of(
FXForwardSecurity.meta().regionId(), new FXRegionConverter(),
NonDeliverableFXForwardSecurity.meta().regionId(), new FXRegionConverter()));
// for building JSON from beans
RegionIdToStringConverter regionIdToStringConverter = new RegionIdToStringConverter();
Map<MetaProperty<?>, Converter<?, ?>> jsonRegionConverters =
ImmutableMap.<MetaProperty<?>, Converter<?, ?>>of(
CashSecurity.meta().regionId(), regionIdToStringConverter,
CreditDefaultSwapSecurity.meta().regionId(), regionIdToStringConverter,
EquityVarianceSwapSecurity.meta().regionId(), regionIdToStringConverter,
FRASecurity.meta().regionId(), regionIdToStringConverter,
SwapLeg.meta().regionId(), regionIdToStringConverter);
s_stringConvert = new StringConvert();
s_stringConvert.register(BigDecimal.class, new BigDecimalConverter());
s_stringConvert.register(Double.class, new DoubleConverter());
s_stringConvert.register(Double.TYPE, new DoubleConverter());
s_stringConvert.register(ExternalIdBundle.class, new JodaBeanConverters.ExternalIdBundleConverter());
s_stringConvert.register(Expiry.class, new ExpiryConverter());
s_stringConvert.register(MonitoringType.class, new EnumConverter<MonitoringType>());
s_stringConvert.register(BarrierType.class, new EnumConverter<BarrierType>());
s_stringConvert.register(BarrierDirection.class, new EnumConverter<BarrierDirection>());
s_stringConvert.register(SamplingFrequency.class, new EnumConverter<SamplingFrequency>());
s_stringConvert.register(LongShort.class, new EnumConverter<LongShort>());
s_stringConvert.register(OptionType.class, new EnumConverter<OptionType>());
s_stringConvert.register(ZonedDateTime.class, new ZonedDateTimeConverter());
s_stringConvert.register(OffsetTime.class, new OffsetTimeConverter());
s_stringConvert.register(DebtSeniority.class, new EnumConverter<DebtSeniority>());
s_stringConvert.register(StubType.class, new EnumConverter<StubType>());
s_jsonBuildingConverters = new Converters(jsonRegionConverters, s_stringConvert);
s_beanBuildingConverters = new Converters(beanRegionConverters, s_stringConvert);
}
/**
* Filters out region ID for FX forwards when building JSON for the security and HTML screens showing the structure.
* The property value is hard-coded to {@code FINANCIAL_REGION~GB} for FX forwards so its value is of no interest
* to the client and it can't be updated.
*/
private static final PropertyFilter s_fxRegionFilter =
new PropertyFilter(FXForwardSecurity.meta().regionId(), NonDeliverableFXForwardSecurity.meta().regionId());
/**
* Filters out the {@code externalIdBundle} property from OTC securities when building the HTML showing the security
* structure. OTC security details are passed to the blotter back end which generates the ID so this
* info is irrelevant to the client.
*/
private static final BeanVisitorDecorator s_externalIdBundleFilter = new PropertyNameFilter("externalIdBundle");
/**
* Filters out the underlying ID field of {@link SwaptionSecurity} when building the HTML showing the security
* structure. The back end creates the underlying security and fills this field in so it's of no interest
* to the client.
*/
private static final PropertyFilter s_swaptionUnderlyingFilter = new PropertyFilter(SwaptionSecurity.meta().underlyingId());
/**
* Filters out the underlying ID field of {@link CreditDefaultSwapOptionSecurity} when building the HTML showing the security
* structure. The back end creates the underlying security and fills this field in so it's of no interest
* to the client.
*/
private static final PropertyFilter s_cdsOptionUnderlyingFilter = new PropertyFilter(CreditDefaultSwapOptionSecurity.meta().underlyingId());
/**
* Filters out the {@code securityType} field for all securities when building the HTML showing the security
* structure. This value is read-only in each security type and is of no interest to the client.
*/
private static final PropertyFilter s_securityTypeFilter = new PropertyFilter(ManageableSecurity.meta().securityType());
/**
* @return A thread-local formatter instance set to parse numbers into BigDecimals.
*/
/* package */ static DecimalFormat getDecimalFormat() {
return s_decimalFormat.get();
}
/* package */ static FinancialSecurity buildSecurity(BeanDataSource data) {
return buildSecurity(data, ExternalIdBundle.EMPTY);
}
@SuppressWarnings("unchecked")
/* package */ static FinancialSecurity buildSecurity(BeanDataSource data, ExternalIdBundle idBundle) {
BeanVisitor<BeanBuilder<FinancialSecurity>> visitor = new BeanBuildingVisitor<>(data, s_metaBeanFactory,
s_beanBuildingConverters);
MetaBean metaBean = s_metaBeanFactory.beanFor(data);
// TODO check it's a FinancialSecurity metaBean
if (!(metaBean instanceof FinancialSecurity.Meta)) {
throw new IllegalArgumentException("MetaBean " + metaBean + " isn't for a FinancialSecurity");
}
BeanBuilder<FinancialSecurity> builder = (BeanBuilder<FinancialSecurity>) s_beanBuildingTraverser.traverse(metaBean, visitor);
// externalIdBundle needs to be specified or building fails because it's not nullable
builder.set(FinancialSecurity.meta().externalIdBundle(), idBundle);
return builder.build();
}
// TODO move to BlotterUtils
/* package */ static StringConvert getStringConvert() {
return s_stringConvert;
}
/* package */ static Converters getJsonBuildingConverters() {
return s_jsonBuildingConverters;
}
/* package */ static Converters getBeanBuildingConverters() {
return s_beanBuildingConverters;
}
/* package */ static Set<MetaBean> getMetaBeans() {
return s_metaBeans;
}
/* package */ static BeanTraverser structureBuildingTraverser() {
return new BeanTraverser(s_externalIdBundleFilter, s_securityTypeFilter, s_swaptionUnderlyingFilter, s_cdsOptionUnderlyingFilter, s_fxRegionFilter);
}
/* package */
static BeanTraverser securityJsonBuildingTraverser() {
return new BeanTraverser(s_securityTypeFilter, s_fxRegionFilter);
}
}
// ----------------------------------------------------------------------------------
/**
* For converting between enum instances and strings. The enum value names are made more readable by downcasing
* and capitalizing them and replacing underscores with spaces.
* @param <T> Type of the enum
*/
@SuppressWarnings({"rawtypes", "unchecked" })
/* package */ class EnumConverter<T extends Enum> implements StringConverter<T> {
@Override
public T convertFromString(Class<? extends T> type, String str) {
// IntelliJ says this cast is redundant but javac disagrees
//noinspection RedundantCast
return (T) Enum.valueOf(type, str.toUpperCase().replace(' ', '_'));
}
@Override
public String convertToString(T e) {
return WordUtils.capitalize(e.name().toLowerCase().replace('_', ' '));
}
}
/**
* Converts {@link ZonedDateTime} to a local date string (e.g. 2012-12-21) and creates a {@link ZonedDateTime} from
* a local date string with a time of 11:00 and a zone of UTC.
*/
/* package */ class ZonedDateTimeConverter implements StringConverter<ZonedDateTime> {
@Override
public ZonedDateTime convertFromString(Class<? extends ZonedDateTime> cls, String localDateString) {
LocalDate localDate = LocalDate.parse(localDateString);
return localDate.atTime(11, 0).atZone(ZoneOffset.UTC);
}
@Override
public String convertToString(ZonedDateTime dateTime) {
return dateTime.toLocalDate().toString();
}
}
/**
* Converts an {@link OffsetTime} to a time string (e.g. 11:35) and discards the offset. Creates
* an {@link OffsetTime} instance by parsing a local date string and using UTC as the offset.
*/
/* package */ class OffsetTimeConverter implements StringConverter<OffsetTime> {
@Override
public OffsetTime convertFromString(Class<? extends OffsetTime> cls, String timeString) {
if (!StringUtils.isEmpty(timeString)) {
return OffsetTime.of(LocalTime.parse(timeString.trim()), ZoneOffset.UTC);
} else {
return null;
}
}
@Override
public String convertToString(OffsetTime time) {
return time.toLocalTime().toString();
}
}
/**
* Converts between an {@link Expiry} and a local date string (e.g. 2011-03-08).
*/
/* package */ class ExpiryConverter implements StringConverter<Expiry> {
@Override
public Expiry convertFromString(Class<? extends Expiry> cls, String localDateString) {
LocalDate localDate = LocalDate.parse(localDateString);
return new Expiry(localDate.atTime(11, 0).atZone(ZoneOffset.UTC));
}
@Override
public String convertToString(Expiry expiry) {
return expiry.getExpiry().toLocalDate().toString();
}
}
/**
* Converts doubles to strings in simple format (i.e. no scientific notation). Limits to 5DP.
*/
/* package */ class DoubleConverter implements StringConverter<Double> {
@Override
public Double convertFromString(Class<? extends Double> cls, String str) {
try {
return BlotterUtils.getDecimalFormat().parse(str).doubleValue();
} catch (ParseException e) {
throw new IllegalArgumentException("Failed to parse number", e);
}
}
@Override
public String convertToString(Double value) {
return BlotterUtils.getDecimalFormat().format(value);
}
}
/**
* Converts big decimals to strings in simple format (i.e. no scientific notation). Limits to 5DP.
*/
/* package */ class BigDecimalConverter implements StringConverter<BigDecimal> {
@Override
public BigDecimal convertFromString(Class<? extends BigDecimal> cls, String str) {
try {
Number number = BlotterUtils.getDecimalFormat().parse(str);
// bizarrely if you call setParseBigDecimal(true) on a DecimalFormat it returns a BigDecimal unless the number
// is NaN or +/- infinity in which case it returns a Double
if (number instanceof BigDecimal) {
return (BigDecimal) number;
} else {
throw new IllegalArgumentException("Failed to parse number as BigDecimal: " + number);
}
} catch (ParseException e) {
throw new IllegalArgumentException("Failed to parse number", e);
}
}
@Override
public String convertToString(BigDecimal value) {
return BlotterUtils.getDecimalFormat().format(value);
}
}
/**
* Converts a string to an {@link ExternalId} with a scheme of {@link ExternalSchemes#FINANCIAL}.
*/
/* package */ class StringToRegionIdConverter implements Converter<String, ExternalId> {
/**
* Converts a string to an {@link ExternalId} with a scheme of {@link ExternalSchemes#FINANCIAL}.
* @param region The region name, not empty
* @return An {@link ExternalId} with a scheme of {@link ExternalSchemes#FINANCIAL} and a value of {@code region}.
*/
@Override
public ExternalId convert(String region) {
if (StringUtils.isEmpty(region)) {
throw new IllegalArgumentException("Region must not be empty");
}
return ExternalId.of(ExternalSchemes.FINANCIAL, region);
}
}
/**
* Converts an {@link ExternalId} to a string.
*/
/* package */ class RegionIdToStringConverter implements Converter<ExternalId, String> {
/**
* Converts an {@link ExternalId} to a string
* @param regionId The region ID, not null
* @return {@code regionId}'s value
*/
@Override
public String convert(ExternalId regionId) {
ArgumentChecker.notNull(regionId, "regionId");
return regionId.getValue();
}
}