AbstractCurrencyDateCalculator (Date Calculator Common 1.4.1 API)

java.lang.Object
- net.objectlab.kit.datecalc.common.ccy.AbstractCurrencyDateCalculator<E>

All Implemented Interfaces:

CurrencyDateCalculator<E>, NonWorkingDayChecker<E>
```
public abstract class AbstractCurrencyDateCalculator<E extends Serializable>
extends Object
implements CurrencyDateCalculator<E>, NonWorkingDayChecker<E>
```
Abstract Currency calculator implementation in order to encapsulate all the common functionality between Jdk/Jdk8 and Joda implementations. It is parameterized on <E> but basically Date and LocalDate are the only viable values for it for now. This follows convention for currency, see http://www.londonfx.co.uk/valdates.html
Currency Holiday
For most T+2 currency pairs (spotLag=2), if T+1 is a USD holiday, then this does not normally affect the spot date, but if a non-USD currency in the currency pair has a holiday on T+1, then it will make the spot date become T+3. If USD or either currency of a pair have a holiday on T+2, then the spot date will be T+3. This means, for example, that crosses such as EUR/GBP can never have a spot date on 4th July (although such a date could be quoted as an outright).
Latin American currencies
USD holidays normally affect the spot date only if T+2 is a USD holiday. If T+1 is a USD holiday, this does not normally prevent T+2 from being the spot date. Certain Latin American currencies (ARS, CLP and MXN) are an exception to this. If T+1 is a USD holiday, then the spot date for the affected currencies will be T+3. For example, if the trade date is a Monday and a USD holiday falls on the Tuesday, then the spot date for EUR/USD will be the Wednesday, but the spot date for USD/MXN will be the Thursday.

Since:

1.4.0

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`adjustStartDateWithCcy1Ccy2`
`private boolean`	`brokenDateAllowed`
`private String`	`ccy1`
`private HolidayCalendar<E>`	`ccy1HolidayCalendar`
`private WorkingWeek`	`ccy1Week`
`private String`	`ccy2`
`private HolidayCalendar<E>`	`ccy2HolidayCalendar`
`private WorkingWeek`	`ccy2Week`
`private String`	`crossCcy`
`private HolidayCalendar<E>`	`crossCcyHolidayCalendar`
`private WorkingWeek`	`crossCcyWeek`
`private static int`	`DAYS_IN_WEEK`
`private HolidayHandler<E>`	`holidayHandler`
`private static int`	`MONTHS_IN_YEAR`
`private SpotLag`	`spotLag`
`private boolean`	`useCrossCcyOnT1ForCcy1`
`private boolean`	`useCrossCcyOnT1ForCcy2`

Constructor Summary

Constructors
Modifier Constructor and Description

protected AbstractCurrencyDateCalculator(CurrencyDateCalculatorBuilder<E> builder)

Constructors
Modifier	Constructor and Description
`protected`	`AbstractCurrencyDateCalculator(CurrencyDateCalculatorBuilder<E> builder)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected abstract E`	`addMonths(E calc, int unit)`
`private E`	`adjustForCcyPairIfRequired(E startDate)`
`private E`	`adjustToNextWorkingDateForCcyPairAndUsdIfRequired(E startDate)`
`private E`	`adjustToNextWorkingDateForCcyPairIfRequired(E startDate)`
`private E`	`applyTenor(E date, TenorCode tenorCode, int unit)`
`private E`	`calculateCcySpot(String ccy, E date, WorkingWeek workingWeek, HolidayCalendar<E> calendar)`
`protected abstract E`	`calculateNextDay(E date)`
`private E`	`calculateNextWorkingDay(E startDate, WorkingWeek ww, HolidayCalendar<E> calendar)`
`private E`	`calculateNextWorkingDayIfRequired(E startDate, WorkingWeek ww, HolidayCalendar<E> calendar)`
`E`	`calculateSpotDate(E startDate)` Calculate the Spot Date taking into account the working weeks, holidays and spot lag (T+1, T+2 etc), the calculator also takes into account special rules for Latin American Currencies or Arabic currencies.
`E`	`calculateTenorDate(E startDate, Tenor tenor)` Calculate the Tenor Date from Spot Date taking into account the working weeks, holidays and spot lag (T+1, T+2 etc).
`List<E>`	`calculateTenorDates(E startDate, List<Tenor> tenors)` Calculate a list of Tenor Dates from Spot Date taking into account the working weeks, holidays and spot lag (T+1, T+2 etc).
`protected abstract int`	`calendarWeekDay(E date)`
`String`	`getCcy1()`
`ReadOnlyHolidayCalendar<E>`	`getCcy1Calendar()`
`WorkingWeek`	`getCcy1Week()`
`String`	`getCcy2()`
`ReadOnlyHolidayCalendar<E>`	`getCcy2Calendar()`
`WorkingWeek`	`getCcy2Week()`
`String`	`getCrossCcy()` The cross currency used by this calculator.
`ReadOnlyHolidayCalendar<E>`	`getCrossCcyCalendar()` If enabled show the CrossCcy calendar that may be used on Spot or Tenor dates (in some cases, it is required that GBP/EUR AND USD [the crossCcy] have all a working day in common for the Spot/Tenor date).
`WorkingWeek`	`getCrossCcyWeek()`
`String`	`getName()`
`SpotLag`	`getSpotLag()`
`boolean`	`isAdjustStartDateWithCurrencyPair()`
`boolean`	`isBrokenDateAllowed()`
`boolean`	`isNonWorkingDay(E date)` Is the given date a non working day, i.e. either a "weekend" or a holiday?
`private boolean`	`isNonWorkingDay(E date, WorkingWeek ww, HolidayCalendar<E> calendar)`
`boolean`	`isUseCrossCcyOnT1ForCcy1()`
`boolean`	`isUseCrossCcyOnT1ForCcy2()`
`protected abstract E`	`max(E d1, E d2)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - MONTHS_IN_YEAR
```
private static final int MONTHS_IN_YEAR
```
    See Also:
    
    Constant Field Values
  - DAYS_IN_WEEK
```
private static final int DAYS_IN_WEEK
```
    See Also:
    
    Constant Field Values
  - ccy1
```
private final String ccy1
```
  - ccy2
```
private final String ccy2
```
  - crossCcy
```
private final String crossCcy
```
  - ccy1HolidayCalendar
```
private final HolidayCalendar<E extends Serializable> ccy1HolidayCalendar
```
  - ccy2HolidayCalendar
```
private final HolidayCalendar<E extends Serializable> ccy2HolidayCalendar
```
  - crossCcyHolidayCalendar
```
private final HolidayCalendar<E extends Serializable> crossCcyHolidayCalendar
```
  - holidayHandler
```
private final HolidayHandler<E extends Serializable> holidayHandler
```
  - ccy1Week
```
private final WorkingWeek ccy1Week
```
  - ccy2Week
```
private final WorkingWeek ccy2Week
```
  - crossCcyWeek
```
private final WorkingWeek crossCcyWeek
```
  - brokenDateAllowed
```
private final boolean brokenDateAllowed
```
  - useCrossCcyOnT1ForCcy1
```
private final boolean useCrossCcyOnT1ForCcy1
```
  - useCrossCcyOnT1ForCcy2
```
private final boolean useCrossCcyOnT1ForCcy2
```
  - adjustStartDateWithCcy1Ccy2
```
private final boolean adjustStartDateWithCcy1Ccy2
```
  - spotLag
```
private final SpotLag spotLag
```
- Constructor Detail
  - AbstractCurrencyDateCalculator
```
protected AbstractCurrencyDateCalculator(CurrencyDateCalculatorBuilder<E> builder)
```
- Method Detail
  - isUseCrossCcyOnT1ForCcy1
```
public boolean isUseCrossCcyOnT1ForCcy1()
```
    Specified by:
    
    isUseCrossCcyOnT1ForCcy1 in interface CurrencyDateCalculator<E extends Serializable>
    
    Returns:
    
    true if the calculator is using the CrossCcy holidays for T+1 for Ccy1. CurrencyCalculatorConfig.getCurrenciesSubjectToCrossCcyForT1(String)
  - isUseCrossCcyOnT1ForCcy2
```
public boolean isUseCrossCcyOnT1ForCcy2()
```
    Specified by:
    
    isUseCrossCcyOnT1ForCcy2 in interface CurrencyDateCalculator<E extends Serializable>
    
    Returns:
    
    true if the calculator is using the CrossCcy holidays for T+1 for Ccy2. CurrencyCalculatorConfig.getCurrenciesSubjectToCrossCcyForT1(String)
  - getSpotLag
```
public SpotLag getSpotLag()
```
    Specified by:
    
    getSpotLag in interface CurrencyDateCalculator<E extends Serializable>
    
    Returns:
    
    the Spot Lag (0,1,2) used by this calculator.
  - isAdjustStartDateWithCurrencyPair
```
public boolean isAdjustStartDateWithCurrencyPair()
```
    Specified by:
    
    isAdjustStartDateWithCurrencyPair in interface CurrencyDateCalculator<E extends Serializable>
    
    Returns:
    
    true if the calculator adjusts the start date based on the working week and holidays for the currency pair (not the crossCcy). CurrencyDateCalculatorBuilder.adjustStartDateWithCurrencyPair(boolean)
  - isBrokenDateAllowed
```
public boolean isBrokenDateAllowed()
```
    Specified by:
    
    isBrokenDateAllowed in interface CurrencyDateCalculator<E extends Serializable>
    
    Returns:
    
    true if the calculator allows a broken date (i.e. a Spot or Tenor date that can fall on a weekend or holiday for the crossCcy). CurrencyDateCalculatorBuilder.brokenDateAllowed(boolean)
  - getCrossCcy
```
public String getCrossCcy()
```
    Description copied from interface: CurrencyDateCalculator
    
    The cross currency used by this calculator.
    
    Specified by:
    
    getCrossCcy in interface CurrencyDateCalculator<E extends Serializable>
  - getCcy1
```
public String getCcy1()
```
    Specified by:
    
    getCcy1 in interface CurrencyDateCalculator<E extends Serializable>
  - getCcy2
```
public String getCcy2()
```
    Specified by:
    
    getCcy2 in interface CurrencyDateCalculator<E extends Serializable>
  - getName
```
public String getName()
```
    Specified by:
    
    getName in interface CurrencyDateCalculator<E extends Serializable>
  - getCcy1Calendar
```
public ReadOnlyHolidayCalendar<E> getCcy1Calendar()
```
    Specified by:
    
    getCcy1Calendar in interface CurrencyDateCalculator<E extends Serializable>
  - getCcy2Calendar
```
public ReadOnlyHolidayCalendar<E> getCcy2Calendar()
```
    Specified by:
    
    getCcy2Calendar in interface CurrencyDateCalculator<E extends Serializable>
  - getCrossCcyCalendar
```
public ReadOnlyHolidayCalendar<E> getCrossCcyCalendar()
```
    Description copied from interface: CurrencyDateCalculator
    
    If enabled show the CrossCcy calendar that may be used on Spot or Tenor dates (in some cases, it is required that GBP/EUR AND USD [the crossCcy] have all a working day in common for the Spot/Tenor date). This is configurable CurrencyDateCalculatorBuilder.brokenDateAllowed(boolean).
    
    Specified by:
    
    getCrossCcyCalendar in interface CurrencyDateCalculator<E extends Serializable>
  - getCcy1Week
```
public WorkingWeek getCcy1Week()
```
    Specified by:
    
    getCcy1Week in interface CurrencyDateCalculator<E extends Serializable>
  - getCcy2Week
```
public WorkingWeek getCcy2Week()
```
    Specified by:
    
    getCcy2Week in interface CurrencyDateCalculator<E extends Serializable>
  - getCrossCcyWeek
```
public WorkingWeek getCrossCcyWeek()
```
    Specified by:
    
    getCrossCcyWeek in interface CurrencyDateCalculator<E extends Serializable>
  - calculateNextDay
```
protected abstract E calculateNextDay(E date)
```
  - calendarWeekDay
```
protected abstract int calendarWeekDay(E date)
```
  - max
```
protected abstract E max(E d1,
                         E d2)
```
  - isNonWorkingDay
```
private boolean isNonWorkingDay(E date,
                                WorkingWeek ww,
                                HolidayCalendar<E> calendar)
```
  - isNonWorkingDay
```
public boolean isNonWorkingDay(E date)
```
    Description copied from interface: NonWorkingDayChecker
    
    Is the given date a non working day, i.e. either a "weekend" or a holiday?
    
    Specified by:
    
    isNonWorkingDay in interface NonWorkingDayChecker<E extends Serializable>
    
    Returns:
    
    true if the given date is non-working.
  - adjustToNextWorkingDateForCcyPairIfRequired
```
private E adjustToNextWorkingDateForCcyPairIfRequired(E startDate)
```
  - adjustToNextWorkingDateForCcyPairAndUsdIfRequired
```
private E adjustToNextWorkingDateForCcyPairAndUsdIfRequired(E startDate)
```
  - calculateNextWorkingDay
```
private E calculateNextWorkingDay(E startDate,
                                  WorkingWeek ww,
                                  HolidayCalendar<E> calendar)
```
  - calculateNextWorkingDayIfRequired
```
private E calculateNextWorkingDayIfRequired(E startDate,
                                            WorkingWeek ww,
                                            HolidayCalendar<E> calendar)
```
  - calculateSpotDate
```
public E calculateSpotDate(E startDate)
```
    Description copied from interface: CurrencyDateCalculator
    
    Calculate the Spot Date taking into account the working weeks, holidays and spot lag (T+1, T+2 etc), the calculator also takes into account special rules for Latin American Currencies or Arabic currencies.
    
    Specified by:
    
    calculateSpotDate in interface CurrencyDateCalculator<E extends Serializable>
    
    Parameters:
    
    startDate - the start date which may be adjusted for the ccy pair if enabled.
    
    Returns:
    
    the Spot Date
  - calculateCcySpot
```
private E calculateCcySpot(String ccy,
                           E date,
                           WorkingWeek workingWeek,
                           HolidayCalendar<E> calendar)
```
  - calculateTenorDate
```
public E calculateTenorDate(E startDate,
                            Tenor tenor)
```
    Description copied from interface: CurrencyDateCalculator
    
    Calculate the Tenor Date from Spot Date taking into account the working weeks, holidays and spot lag (T+1, T+2 etc).
    
    Specified by:
    
    calculateTenorDate in interface CurrencyDateCalculator<E extends Serializable>
    
    Parameters:
    
    startDate - the start date which may be adjusted for the ccy pair if enabled.
    
    tenor - e.g. 1M
    
    Returns:
    
    the Tenor Date
  - applyTenor
```
private E applyTenor(E date,
                     TenorCode tenorCode,
                     int unit)
```
  - adjustForCcyPairIfRequired
```
private E adjustForCcyPairIfRequired(E startDate)
```
  - addMonths
```
protected abstract E addMonths(E calc,
                               int unit)
```
  - calculateTenorDates
```
public List<E> calculateTenorDates(E startDate,
                                   List<Tenor> tenors)
```
    Description copied from interface: CurrencyDateCalculator
    
    Calculate a list of Tenor Dates from Spot Date taking into account the working weeks, holidays and spot lag (T+1, T+2 etc).
    
    Specified by:
    
    calculateTenorDates in interface CurrencyDateCalculator<E extends Serializable>
    
    Parameters:
    
    startDate - the start date which may be adjusted for the ccy pair if enabled.
    
    tenors - the list of tenors ('chronological order is not mandatory)
    
    Returns:
    
    the Tenor Dates (same order as the list of Tenors)

Class AbstractCurrencyDateCalculator<E extends Serializable>

Currency Holiday

Latin American currencies

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MONTHS_IN_YEAR

DAYS_IN_WEEK

ccy1

ccy2

crossCcy

ccy1HolidayCalendar

ccy2HolidayCalendar

crossCcyHolidayCalendar

holidayHandler

ccy1Week

ccy2Week

crossCcyWeek

brokenDateAllowed

useCrossCcyOnT1ForCcy1

useCrossCcyOnT1ForCcy2

adjustStartDateWithCcy1Ccy2

spotLag

Constructor Detail

AbstractCurrencyDateCalculator

Method Detail

isUseCrossCcyOnT1ForCcy1

isUseCrossCcyOnT1ForCcy2

getSpotLag

isAdjustStartDateWithCurrencyPair

isBrokenDateAllowed

getCrossCcy

getCcy1

getCcy2

getName

getCcy1Calendar

getCcy2Calendar

getCrossCcyCalendar

getCcy1Week

getCcy2Week

getCrossCcyWeek

calculateNextDay

calendarWeekDay

max

isNonWorkingDay

isNonWorkingDay

adjustToNextWorkingDateForCcyPairIfRequired

adjustToNextWorkingDateForCcyPairAndUsdIfRequired

calculateNextWorkingDay

calculateNextWorkingDayIfRequired

calculateSpotDate

calculateCcySpot

calculateTenorDate

applyTenor

adjustForCcyPairIfRequired

addMonths

calculateTenorDates