How to use

adjusted

method

in

com.opengamma.strata.basics.date.AdjustableDate

/**
 * Resolves the date on this payment, returning a payment with a fixed date.
 * <p>
 * This returns a {@link Payment} with the same amount and resolved date.
 * 
 * @param refData  the reference data, used to find the holiday calendar
 * @return the resolved payment
 */
@Override
public Payment resolve(ReferenceData refData) {
 return Payment.of(value, date.adjusted(refData));
}

private List<LocalDate> applyBusinessDayAdjustment(List<LocalDate> unadj, ReferenceData refData) {
 List<LocalDate> adj = new ArrayList<>(unadj.size());
 adj.add(calculatedStartDate().adjusted(refData));
 for (int i = 1; i < unadj.size() - 1; i++) {
  adj.add(businessDayAdjustment.adjust(unadj.get(i), refData));
 }
 adj.add(calculatedEndDate().adjusted(refData));
 return adj;
}

@Test(dataProvider = "adjusted")
public void test_adjusted(LocalDate date, LocalDate expected) {
 AdjustableDate test = AdjustableDate.of(date, BDA_FOLLOW_SAT_SUN);
 assertEquals(test.adjusted(REF_DATA), expected);
}

@Override
public ResolvedBulletPayment resolve(ReferenceData refData) {
 CurrencyAmount signed = payReceive == PayReceive.PAY ? value.negated() : value;
 Payment payment = Payment.of(signed, date.adjusted(refData));
 return ResolvedBulletPayment.of(payment);
}

private LocalDate calculateEnd(LocalDate valuationDate, ReferenceData refData) {
 SwapTrade trade = template.createTrade(valuationDate, BuySell.BUY, 1, 1, refData);
 return trade.getProduct().getEndDate().adjusted(refData);
}

private LocalDate calculateEnd(LocalDate valuationDate, ReferenceData refData) {
 SwapTrade trade = template.createTrade(valuationDate, BuySell.BUY, 1, 1, 0, refData);
 return trade.getProduct().getEndDate().adjusted(refData);
}

private LocalDate calculateEnd(LocalDate valuationDate, ReferenceData refData) {
 SwapTrade trade = template.createTrade(valuationDate, BuySell.BUY, 1, 1, refData);
 return trade.getProduct().getEndDate().adjusted(refData);
}

private LocalDate calculateEnd(LocalDate valuationDate, ReferenceData refData) {
 SwapTrade trade = template.createTrade(valuationDate, BuySell.BUY, 1, 1, refData);
 return trade.getProduct().getEndDate().adjusted(refData);
}

private LocalDate calculateEnd(LocalDate valuationDate, ReferenceData refData) {
 SwapTrade trade = template.createTrade(valuationDate, BuySell.BUY, 1, 1, refData);
 return trade.getProduct().getEndDate().adjusted(refData);
}

private LocalDate calculateEnd(LocalDate valuationDate, ReferenceData refData) {
 SwapTrade trade = template.createTrade(valuationDate, BuySell.BUY, 1, 1, refData);
 return trade.getProduct().getEndDate().adjusted(refData);
}

private LocalDate calculateEnd(LocalDate valuationDate, ReferenceData refData) {
 SwapTrade trade = template.createTrade(valuationDate, BuySell.BUY, 1, 1, refData);
 return trade.getProduct().getEndDate().adjusted(refData);
}

public void test_of_2args_withAdjustment() {
 AdjustableDate test = AdjustableDate.of(FRI_2014_07_11, BDA_FOLLOW_SAT_SUN);
 assertEquals(test.getUnadjusted(), FRI_2014_07_11);
 assertEquals(test.getAdjustment(), BDA_FOLLOW_SAT_SUN);
 assertEquals(test.toString(), "2014-07-11 adjusted by Following using calendar Sat/Sun");
 assertEquals(test.adjusted(REF_DATA), FRI_2014_07_11);
}

public void test_of_1arg() {
 AdjustableDate test = AdjustableDate.of(FRI_2014_07_11);
 assertEquals(test.getUnadjusted(), FRI_2014_07_11);
 assertEquals(test.getAdjustment(), BDA_NONE);
 assertEquals(test.toString(), "2014-07-11");
 assertEquals(test.adjusted(REF_DATA), FRI_2014_07_11);
}

public void test_of_2args_withNoAdjustment() {
 AdjustableDate test = AdjustableDate.of(FRI_2014_07_11, BDA_NONE);
 assertEquals(test.getUnadjusted(), FRI_2014_07_11);
 assertEquals(test.getAdjustment(), BDA_NONE);
 assertEquals(test.toString(), "2014-07-11");
 assertEquals(test.adjusted(REF_DATA), FRI_2014_07_11);
}

@Override
public ResolvedSwaption resolve(ReferenceData refData) {
 return ResolvedSwaption.builder()
   .expiry(expiryDate.adjusted(refData).atTime(expiryTime).atZone(expiryZone))
   .longShort(longShort)
   .swaptionSettlement(swaptionSettlement)
   .underlying(underlying.resolve(refData))
   .build();
}

@Override
public ResolvedFra resolve(ReferenceData refData) {
 DateAdjuster bda = getBusinessDayAdjustment().orElse(BusinessDayAdjustment.NONE).resolve(refData);
 LocalDate start = bda.adjust(startDate);
 LocalDate end = bda.adjust(endDate);
 LocalDate pay = paymentDate.adjusted(refData);
 return ResolvedFra.builder()
   .paymentDate(pay)
   .startDate(start)
   .endDate(end)
   .yearFraction(dayCount.yearFraction(start, end))
   .fixedRate(fixedRate)
   .floatingRate(createRateComputation(refData))
   .currency(currency)
   .notional(buySell.normalize(notional))
   .discounting(discounting)
   .build();
}

LocalDate fixing2 = EUR_EURIBOR_6M.calculateFixingFromEffective(end1, REF_DATA);
LocalDate fixing3 = EUR_EURIBOR_6M.calculateFixingFromEffective(END, REF_DATA);
LocalDate endDate = SCHEDULE_EUR.calculatedEndDate().adjusted(REF_DATA);
  .build();
assertEquals(resolvedFloor.getCurrency(), EUR);
assertEquals(resolvedFloor.getStartDate(), baseFloor.getStartDate().adjusted(REF_DATA));
assertEquals(resolvedFloor.getEndDate(), baseFloor.getEndDate().adjusted(REF_DATA));
assertEquals(resolvedFloor.getIndex(), INDEX);
assertEquals(resolvedFloor.getPayReceive(), PAY);
  .build();
assertEquals(resolvedFloorEnd.getCurrency(), EUR);
assertEquals(resolvedFloorEnd.getStartDate(), baseFloor.getStartDate().adjusted(REF_DATA));
assertEquals(resolvedFloorEnd.getEndDate(), baseFloor.getEndDate().adjusted(REF_DATA));
assertEquals(resolvedFloorEnd.getIndex(), INDEX);
assertEquals(resolvedFloorEnd.getPayReceive(), PAY);
  .build();
assertEquals(resolvedCap.getCurrency(), EUR);
assertEquals(resolvedCap.getStartDate(), baseCap.getStartDate().adjusted(REF_DATA));
assertEquals(resolvedCap.getEndDate(), baseCap.getEndDate().adjusted(REF_DATA));
assertEquals(resolvedCap.getIndex(), INDEX);
assertEquals(resolvedCap.getPayReceive(), PAY);