/**
* Copyright (C) 2015 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.strata.product.fx;
import java.io.Serializable;
import java.time.LocalDate;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import org.joda.beans.Bean;
import org.joda.beans.BeanBuilder;
import org.joda.beans.BeanDefinition;
import org.joda.beans.ImmutableBean;
import org.joda.beans.ImmutablePreBuild;
import org.joda.beans.ImmutableValidator;
import org.joda.beans.JodaBeanUtils;
import org.joda.beans.MetaProperty;
import org.joda.beans.Property;
import org.joda.beans.PropertyDefinition;
import org.joda.beans.impl.direct.DirectFieldsBeanBuilder;
import org.joda.beans.impl.direct.DirectMetaBean;
import org.joda.beans.impl.direct.DirectMetaProperty;
import org.joda.beans.impl.direct.DirectMetaPropertyMap;
import com.opengamma.strata.basics.ReferenceData;
import com.opengamma.strata.basics.currency.Currency;
import com.opengamma.strata.basics.currency.CurrencyAmount;
import com.opengamma.strata.basics.currency.CurrencyPair;
import com.opengamma.strata.basics.currency.FxRate;
import com.opengamma.strata.basics.currency.Payment;
import com.opengamma.strata.collect.ArgChecker;
import com.opengamma.strata.product.ResolvedProduct;
/**
* A single FX transaction, resolved for pricing.
* <p>
* This is the resolved form of {@link FxSingle} and is an input to the pricers.
* Applications will typically create a {@code ResolvedFxSingle} from a {@code FxSingle}
* using {@link FxSingle#resolve(ReferenceData)}.
* <p>
* The two payments are identified as the base and counter currencies in a standardized currency pair.
* For example, a EUR/USD exchange always has EUR as the base payment and USD as the counter payment.
* See {@link CurrencyPair} for details of the configuration that determines the ordering.
* <p>
* A {@code ResolvedFxSingle} is bound to data that changes over time, such as holiday calendars.
* If the data changes, such as the addition of a new holiday, the resolved form will not be updated.
* Care must be taken when placing the resolved form in a cache or persistence layer.
*/
@BeanDefinition(builderScope = "private")
public final class ResolvedFxSingle
implements ResolvedProduct, ImmutableBean, Serializable {
/**
* The payment in the base currency, positive if receiving, negative if paying.
* <p>
* The payment amount is signed.
* A positive amount indicates the payment is to be received.
* A negative amount indicates the payment is to be paid.
*/
@PropertyDefinition(validate = "notNull")
private final Payment baseCurrencyPayment;
/**
* The payment in the counter currency, positive if receiving, negative if paying.
* <p>
* The payment amount is signed.
* A positive amount indicates the payment is to be received.
* A negative amount indicates the payment is to be paid.
*/
@PropertyDefinition(validate = "notNull")
private final Payment counterCurrencyPayment;
//-------------------------------------------------------------------------
/**
* Creates an {@code ResolvedFxSingle} from two equivalent payments in different currencies.
* <p>
* The payments must be of the correct type, one pay and one receive.
* The currencies of the payments must differ.
* <p>
* This factory identifies the currency pair of the exchange and assigns the payments
* to match the base or counter currency of the standardized currency pair.
* For example, a EUR/USD exchange always has EUR as the base payment and USD as the counter payment.
*
* @param payment1 the first payment
* @param payment2 the second payment
* @return the resolved foreign exchange transaction
*/
public static ResolvedFxSingle of(Payment payment1, Payment payment2) {
CurrencyPair pair = CurrencyPair.of(payment2.getCurrency(), payment1.getCurrency());
if (pair.isConventional()) {
return new ResolvedFxSingle(payment2, payment1);
} else {
return new ResolvedFxSingle(payment1, payment2);
}
}
/**
* Creates an {@code ResolvedFxSingle} from two amounts and the value date.
* <p>
* The amounts must be of the correct type, one pay and one receive.
* The currencies of the payments must differ.
* <p>
* This factory identifies the currency pair of the exchange and assigns the payments
* to match the base or counter currency of the standardized currency pair.
* For example, a EUR/USD exchange always has EUR as the base payment and USD as the counter payment.
*
* @param amount1 the amount in the first currency
* @param amount2 the amount in the second currency
* @param valueDate the value date
* @return the resolved foreign exchange transaction
*/
public static ResolvedFxSingle of(CurrencyAmount amount1, CurrencyAmount amount2, LocalDate valueDate) {
return ResolvedFxSingle.of(Payment.of(amount1, valueDate), Payment.of(amount2, valueDate));
}
/**
* Creates an {@code ResolvedFxSingle} using a rate.
* <p>
* This create an FX specifying a value date, notional in one currency, the second currency
* and the FX rate between the two.
* The currencies of the payments must differ.
* <p>
* This factory identifies the currency pair of the exchange and assigns the payments
* to match the base or counter currency of the standardized currency pair.
* For example, a EUR/USD exchange always has EUR as the base payment and USD as the counter payment.
* <p>
* No payment date adjustments apply.
*
* @param amountCurrency1 the amount of the near leg in the first currency
* @param fxRate the near FX rate
* @param paymentDate date that the FX settles
* @return the resolved foreign exchange transaction
*/
public static ResolvedFxSingle of(CurrencyAmount amountCurrency1, FxRate fxRate, LocalDate paymentDate) {
CurrencyPair pair = fxRate.getPair();
ArgChecker.isTrue(pair.contains(amountCurrency1.getCurrency()));
Currency currency2 = pair.getBase().equals(amountCurrency1.getCurrency()) ? pair.getCounter() : pair.getBase();
CurrencyAmount amountCurrency2 = amountCurrency1.convertedTo(currency2, fxRate).negated();
return ResolvedFxSingle.of(Payment.of(amountCurrency1, paymentDate), Payment.of(amountCurrency2, paymentDate));
}
//-------------------------------------------------------------------------
@ImmutableValidator
private void validate() {
if (baseCurrencyPayment.getCurrency().equals(counterCurrencyPayment.getCurrency())) {
throw new IllegalArgumentException("Payments must have different currencies");
}
if ((baseCurrencyPayment.getAmount() != 0d || counterCurrencyPayment.getAmount() != 0d) &&
Math.signum(baseCurrencyPayment.getAmount()) != -Math.signum(counterCurrencyPayment.getAmount())) {
throw new IllegalArgumentException("Payments must have different signs");
}
ArgChecker.inOrderOrEqual(baseCurrencyPayment.getDate(), counterCurrencyPayment.getDate(),
"baseCurrencyPayment.date", "counterCurrencyPayment.date");
}
@ImmutablePreBuild
private static void preBuild(Builder builder) {
// swap order to be base/counter if reverse is conventional
// this handled deserialization where the base/counter rules differ from those applicable at serialization
Payment base = builder.baseCurrencyPayment;
Payment counter = builder.counterCurrencyPayment;
CurrencyPair pair = CurrencyPair.of(counter.getCurrency(), base.getCurrency());
if (pair.isConventional()) {
builder.baseCurrencyPayment = counter;
builder.counterCurrencyPayment = base;
}
}
//-------------------------------------------------------------------------
/**
* Gets currency pair of the base currency and counter currency.
* <p>
* This currency pair is conventional, thus indifferent to the direction of FX.
*
* @return the currency pair
*/
public CurrencyPair getCurrencyPair() {
return CurrencyPair.of(baseCurrencyPayment.getCurrency(), counterCurrencyPayment.getCurrency());
}
/**
* Gets the currency amount in which the amount is received.
* <p>
* This returns the currency amount whose amount is non-negative.
* If both are zero, the currency amount of {@code counterCurrencyPayment} is returned.
*
* @return the receive currency amount
*/
public CurrencyAmount getReceiveCurrencyAmount() {
if (baseCurrencyPayment.getAmount() > 0d) {
return CurrencyAmount.of(baseCurrencyPayment.getCurrency(), baseCurrencyPayment.getAmount());
}
return CurrencyAmount.of(counterCurrencyPayment.getCurrency(), counterCurrencyPayment.getAmount());
}
/**
* Returns the date that the transaction settles.
* <p>
* This returns the settlement date of the base currency.
*
* @return the value date
*/
public LocalDate getPaymentDate() {
return baseCurrencyPayment.getDate();
}
//-------------------------------------------------------------------------
/**
* Returns the inverse transaction.
* <p>
* The result has the base and counter payments negated.
*
* @return the inverse transaction
*/
public ResolvedFxSingle inverse() {
return new ResolvedFxSingle(baseCurrencyPayment.negated(), counterCurrencyPayment.negated());
}
//------------------------- AUTOGENERATED START -------------------------
///CLOVER:OFF
/**
* The meta-bean for {@code ResolvedFxSingle}.
* @return the meta-bean, not null
*/
public static ResolvedFxSingle.Meta meta() {
return ResolvedFxSingle.Meta.INSTANCE;
}
static {
JodaBeanUtils.registerMetaBean(ResolvedFxSingle.Meta.INSTANCE);
}
/**
* The serialization version id.
*/
private static final long serialVersionUID = 1L;
private ResolvedFxSingle(
Payment baseCurrencyPayment,
Payment counterCurrencyPayment) {
JodaBeanUtils.notNull(baseCurrencyPayment, "baseCurrencyPayment");
JodaBeanUtils.notNull(counterCurrencyPayment, "counterCurrencyPayment");
this.baseCurrencyPayment = baseCurrencyPayment;
this.counterCurrencyPayment = counterCurrencyPayment;
validate();
}
@Override
public ResolvedFxSingle.Meta metaBean() {
return ResolvedFxSingle.Meta.INSTANCE;
}
@Override
public <R> Property<R> property(String propertyName) {
return metaBean().<R>metaProperty(propertyName).createProperty(this);
}
@Override
public Set<String> propertyNames() {
return metaBean().metaPropertyMap().keySet();
}
//-----------------------------------------------------------------------
/**
* Gets the payment in the base currency, positive if receiving, negative if paying.
* <p>
* The payment amount is signed.
* A positive amount indicates the payment is to be received.
* A negative amount indicates the payment is to be paid.
* @return the value of the property, not null
*/
public Payment getBaseCurrencyPayment() {
return baseCurrencyPayment;
}
//-----------------------------------------------------------------------
/**
* Gets the payment in the counter currency, positive if receiving, negative if paying.
* <p>
* The payment amount is signed.
* A positive amount indicates the payment is to be received.
* A negative amount indicates the payment is to be paid.
* @return the value of the property, not null
*/
public Payment getCounterCurrencyPayment() {
return counterCurrencyPayment;
}
//-----------------------------------------------------------------------
@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj != null && obj.getClass() == this.getClass()) {
ResolvedFxSingle other = (ResolvedFxSingle) obj;
return JodaBeanUtils.equal(baseCurrencyPayment, other.baseCurrencyPayment) &&
JodaBeanUtils.equal(counterCurrencyPayment, other.counterCurrencyPayment);
}
return false;
}
@Override
public int hashCode() {
int hash = getClass().hashCode();
hash = hash * 31 + JodaBeanUtils.hashCode(baseCurrencyPayment);
hash = hash * 31 + JodaBeanUtils.hashCode(counterCurrencyPayment);
return hash;
}
@Override
public String toString() {
StringBuilder buf = new StringBuilder(96);
buf.append("ResolvedFxSingle{");
buf.append("baseCurrencyPayment").append('=').append(baseCurrencyPayment).append(',').append(' ');
buf.append("counterCurrencyPayment").append('=').append(JodaBeanUtils.toString(counterCurrencyPayment));
buf.append('}');
return buf.toString();
}
//-----------------------------------------------------------------------
/**
* The meta-bean for {@code ResolvedFxSingle}.
*/
public static final class Meta extends DirectMetaBean {
/**
* The singleton instance of the meta-bean.
*/
static final Meta INSTANCE = new Meta();
/**
* The meta-property for the {@code baseCurrencyPayment} property.
*/
private final MetaProperty<Payment> baseCurrencyPayment = DirectMetaProperty.ofImmutable(
this, "baseCurrencyPayment", ResolvedFxSingle.class, Payment.class);
/**
* The meta-property for the {@code counterCurrencyPayment} property.
*/
private final MetaProperty<Payment> counterCurrencyPayment = DirectMetaProperty.ofImmutable(
this, "counterCurrencyPayment", ResolvedFxSingle.class, Payment.class);
/**
* The meta-properties.
*/
private final Map<String, MetaProperty<?>> metaPropertyMap$ = new DirectMetaPropertyMap(
this, null,
"baseCurrencyPayment",
"counterCurrencyPayment");
/**
* Restricted constructor.
*/
private Meta() {
}
@Override
protected MetaProperty<?> metaPropertyGet(String propertyName) {
switch (propertyName.hashCode()) {
case 765258148: // baseCurrencyPayment
return baseCurrencyPayment;
case -863240423: // counterCurrencyPayment
return counterCurrencyPayment;
}
return super.metaPropertyGet(propertyName);
}
@Override
public BeanBuilder<? extends ResolvedFxSingle> builder() {
return new ResolvedFxSingle.Builder();
}
@Override
public Class<? extends ResolvedFxSingle> beanType() {
return ResolvedFxSingle.class;
}
@Override
public Map<String, MetaProperty<?>> metaPropertyMap() {
return metaPropertyMap$;
}
//-----------------------------------------------------------------------
/**
* The meta-property for the {@code baseCurrencyPayment} property.
* @return the meta-property, not null
*/
public MetaProperty<Payment> baseCurrencyPayment() {
return baseCurrencyPayment;
}
/**
* The meta-property for the {@code counterCurrencyPayment} property.
* @return the meta-property, not null
*/
public MetaProperty<Payment> counterCurrencyPayment() {
return counterCurrencyPayment;
}
//-----------------------------------------------------------------------
@Override
protected Object propertyGet(Bean bean, String propertyName, boolean quiet) {
switch (propertyName.hashCode()) {
case 765258148: // baseCurrencyPayment
return ((ResolvedFxSingle) bean).getBaseCurrencyPayment();
case -863240423: // counterCurrencyPayment
return ((ResolvedFxSingle) bean).getCounterCurrencyPayment();
}
return super.propertyGet(bean, propertyName, quiet);
}
@Override
protected void propertySet(Bean bean, String propertyName, Object newValue, boolean quiet) {
metaProperty(propertyName);
if (quiet) {
return;
}
throw new UnsupportedOperationException("Property cannot be written: " + propertyName);
}
}
//-----------------------------------------------------------------------
/**
* The bean-builder for {@code ResolvedFxSingle}.
*/
private static final class Builder extends DirectFieldsBeanBuilder<ResolvedFxSingle> {
private Payment baseCurrencyPayment;
private Payment counterCurrencyPayment;
/**
* Restricted constructor.
*/
private Builder() {
}
//-----------------------------------------------------------------------
@Override
public Object get(String propertyName) {
switch (propertyName.hashCode()) {
case 765258148: // baseCurrencyPayment
return baseCurrencyPayment;
case -863240423: // counterCurrencyPayment
return counterCurrencyPayment;
default:
throw new NoSuchElementException("Unknown property: " + propertyName);
}
}
@Override
public Builder set(String propertyName, Object newValue) {
switch (propertyName.hashCode()) {
case 765258148: // baseCurrencyPayment
this.baseCurrencyPayment = (Payment) newValue;
break;
case -863240423: // counterCurrencyPayment
this.counterCurrencyPayment = (Payment) newValue;
break;
default:
throw new NoSuchElementException("Unknown property: " + propertyName);
}
return this;
}
@Override
public Builder set(MetaProperty<?> property, Object value) {
super.set(property, value);
return this;
}
@Override
public Builder setString(String propertyName, String value) {
setString(meta().metaProperty(propertyName), value);
return this;
}
@Override
public Builder setString(MetaProperty<?> property, String value) {
super.setString(property, value);
return this;
}
@Override
public Builder setAll(Map<String, ? extends Object> propertyValueMap) {
super.setAll(propertyValueMap);
return this;
}
@Override
public ResolvedFxSingle build() {
preBuild(this);
return new ResolvedFxSingle(
baseCurrencyPayment,
counterCurrencyPayment);
}
//-----------------------------------------------------------------------
@Override
public String toString() {
StringBuilder buf = new StringBuilder(96);
buf.append("ResolvedFxSingle.Builder{");
buf.append("baseCurrencyPayment").append('=').append(JodaBeanUtils.toString(baseCurrencyPayment)).append(',').append(' ');
buf.append("counterCurrencyPayment").append('=').append(JodaBeanUtils.toString(counterCurrencyPayment));
buf.append('}');
return buf.toString();
}
}
///CLOVER:ON
//-------------------------- AUTOGENERATED END --------------------------
}