fr.cnes.sirius.patrius.utils.legs

Class AbstractLegsSequence<L extends Leg>

java.lang.Object

fr.cnes.sirius.patrius.utils.legs.AbstractLegsSequence<L>

Type Parameters:

L - Leg

All Implemented Interfaces:

Leg, LegsSequence<L>, Serializable, Iterable<L>, Collection<L>, NavigableSet<L>, Set<L>, SortedSet<L>

Direct Known Subclasses:

AngularVelocitiesPolynomialProfile, AttitudeLegsSequence, AttitudeProfilesSequence, OrientationAngleLegsSequence, OrientationAngleProfileSequence

public abstract class AbstractLegsSequence<L extends Leg>
extends Object
implements LegsSequence<L>

This abstract class provides implementations for the LegsSequence interface.

Since:

4.2

Author:

morerem

See Also:

Serialized Form

Constructor Summary

Constructors

Constructor and Description
AbstractLegsSequence(String natureIn) Constructor.

Method Summary

Modifier and Type	Method and Description
boolean	add(L leg) Add the input leg to the sequence.
boolean	addAll(Collection<? extends L> collection)
L	ceiling(L leg)
void	clean() Clean the legs sequence by truncating every overlapping legs and removing included legs.
void	clear()
Comparator<? super L>	comparator()
boolean	contains(Object object)
boolean	containsAll(Collection<?> collection)
Iterator<L>	descendingIterator()
NavigableSet<L>	descendingSet()
L	first()
L	floor(L leg)
L	getLeg(AbsoluteDate date) {inheritDoc}
String	getNature() Returns the sequence nature.
AbsoluteDateInterval	getTimeInterval() Return the time interval of validity of the leg
boolean	hasOverlaping() Returns a boolean indicating if the sequence contains overlapping legs.
SortedSet<L>	headSet(L toElement)
NavigableSet<L>	headSet(L toElement, boolean inclusive)
L	higher(L leg)
boolean	isCompact() Returns a boolean indicating if the sequence is compact or not.
boolean	isEmpty()
Iterator<L>	iterator()
L	last()
L	lower(L leg)
L	pollFirst()
L	pollLast()
boolean	remove(Object object)
boolean	removeAll(Collection<?> collection)
boolean	retainAll(Collection<?> collection)
int	size()
NavigableSet<L>	subSet(L fromElement, boolean fromInclusive, L toElement, boolean toInclusive)
SortedSet<L>	subSet(L fromElement, L toElement)
SortedSet<L>	tailSet(L fromElement)
NavigableSet<L>	tailSet(L fromElement, boolean inclusive)
Object[]	toArray()
<T> T[]	toArray(T[] array)
void	truncate(AbsoluteDateInterval newIntervalOfValidity) Truncate the time interval of validity of the leg

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface fr.cnes.sirius.patrius.utils.legs.LegsSequence

toPrettyString

Methods inherited from interface java.util.SortedSet

spliterator

Methods inherited from interface java.util.Set

equals, hashCode

Methods inherited from interface java.util.Collection

parallelStream, removeIf, stream

Methods inherited from interface java.lang.Iterable

forEach

Constructor Detail

AbstractLegsSequence

public AbstractLegsSequence(String natureIn)

Constructor.

Parameters:

natureIn - nature of the sequence

Method Detail

getTimeInterval

public AbsoluteDateInterval getTimeInterval()

Return the time interval of validity of the leg

Specified by:

getTimeInterval in interface Leg

Returns:

time interval of validity of the leg

truncate

public void truncate(AbsoluteDateInterval newIntervalOfValidity)
              throws PatriusException

Truncate the time interval of validity of the leg

Specified by:

truncate in interface Leg

Parameters:

newIntervalOfValidity - the new time interval

Throws:

PatriusException - if the new time interval is not included in the current time interval

getNature

public String getNature()

Returns the sequence nature.

Specified by:

getNature in interface Leg

Returns:

the sequence nature

getLeg

public L getLeg(AbsoluteDate date)
         throws PatriusException

{inheritDoc}

Specified by:

getLeg in interface LegsSequence<L extends Leg>

Parameters:

date - input date

Returns:

leg

Throws:

PatriusException - thrown if no leg contains the input date

lower

public L lower(L leg)

Specified by:

lower in interface NavigableSet<L extends Leg>

floor

public L floor(L leg)

Specified by:

floor in interface NavigableSet<L extends Leg>

ceiling

public L ceiling(L leg)

Specified by:

ceiling in interface NavigableSet<L extends Leg>

higher

public L higher(L leg)

Specified by:

higher in interface NavigableSet<L extends Leg>

pollFirst

public L pollFirst()

Specified by:

pollFirst in interface NavigableSet<L extends Leg>

pollLast

public L pollLast()

Specified by:

pollLast in interface NavigableSet<L extends Leg>

iterator

public Iterator<L> iterator()

Specified by:

iterator in interface Iterable<L extends Leg>

Specified by:

iterator in interface Collection<L extends Leg>

Specified by:

iterator in interface NavigableSet<L extends Leg>

Specified by:

iterator in interface Set<L extends Leg>

descendingSet

public NavigableSet<L> descendingSet()

Specified by:

descendingSet in interface NavigableSet<L extends Leg>

descendingIterator

public Iterator<L> descendingIterator()

Specified by:

descendingIterator in interface NavigableSet<L extends Leg>

subSet

public NavigableSet<L> subSet(L fromElement,
                              boolean fromInclusive,
                              L toElement,
                              boolean toInclusive)

Specified by:

subSet in interface NavigableSet<L extends Leg>

headSet

public NavigableSet<L> headSet(L toElement,
                               boolean inclusive)

Specified by:

headSet in interface NavigableSet<L extends Leg>

tailSet

public NavigableSet<L> tailSet(L fromElement,
                               boolean inclusive)

Specified by:

tailSet in interface NavigableSet<L extends Leg>

subSet

public SortedSet<L> subSet(L fromElement,
                           L toElement)

Specified by:

subSet in interface NavigableSet<L extends Leg>

Specified by:

subSet in interface SortedSet<L extends Leg>

headSet

public SortedSet<L> headSet(L toElement)

Specified by:

headSet in interface NavigableSet<L extends Leg>

Specified by:

headSet in interface SortedSet<L extends Leg>

tailSet

public SortedSet<L> tailSet(L fromElement)

Specified by:

tailSet in interface NavigableSet<L extends Leg>

Specified by:

tailSet in interface SortedSet<L extends Leg>

comparator

public Comparator<? super L> comparator()

Specified by:

comparator in interface SortedSet<L extends Leg>

first

public L first()

Specified by:

first in interface SortedSet<L extends Leg>

last

public L last()

Specified by:

last in interface SortedSet<L extends Leg>

size

public int size()

Specified by:

size in interface Collection<L extends Leg>

Specified by:

size in interface Set<L extends Leg>

isEmpty

public boolean isEmpty()

Specified by:

isEmpty in interface Collection<L extends Leg>

Specified by:

isEmpty in interface Set<L extends Leg>

contains

public boolean contains(Object object)

Specified by:

contains in interface Collection<L extends Leg>

Specified by:

contains in interface Set<L extends Leg>

toArray

public Object[] toArray()

Specified by:

toArray in interface Collection<L extends Leg>

Specified by:

toArray in interface Set<L extends Leg>

toArray

public <T> T[] toArray(T[] array)

Specified by:

toArray in interface Collection<L extends Leg>

Specified by:

toArray in interface Set<L extends Leg>

add

public boolean add(L leg)

Add the input leg to the sequence. Be aware that a Leg can be added regardless its interval of validity. It means that Legs can overlap each other in the sequence. Returns true if this collection changed as a result of the call (the leg has been added). Returns false if this collection does not permit duplicates and already contains the specified element (the leg has not been added).

Collections that support this operation may place limitations on what elements may be added to this collection. In particular, some collections will refuse to add null elements, and others will impose restrictions on the type of elements that may be added. Collection classes should clearly specify in their documentation any restrictions on what elements may be added.

If a collection refuses to add a particular element for any reason other than that it already contains the element, it must throw an exception (rather than returning false ). This preserves the invariant that a collection always contains the specified element after this call returns.

Specified by:

add in interface Collection<L extends Leg>

Specified by:

add in interface Set<L extends Leg>

Parameters:

leg - element whose presence in this collection is to be ensured

Returns:

true if this collection changed as a result of the call

remove

public boolean remove(Object object)

Specified by:

remove in interface Collection<L extends Leg>

Specified by:

remove in interface Set<L extends Leg>

containsAll

public boolean containsAll(Collection<?> collection)

Specified by:

containsAll in interface Collection<L extends Leg>

Specified by:

containsAll in interface Set<L extends Leg>

addAll

public boolean addAll(Collection<? extends L> collection)

Specified by:

addAll in interface Collection<L extends Leg>

Specified by:

addAll in interface Set<L extends Leg>

retainAll

public boolean retainAll(Collection<?> collection)

Specified by:

retainAll in interface Collection<L extends Leg>

Specified by:

retainAll in interface Set<L extends Leg>

removeAll

public boolean removeAll(Collection<?> collection)

Specified by:

removeAll in interface Collection<L extends Leg>

Specified by:

removeAll in interface Set<L extends Leg>

clear

public void clear()

Specified by:

clear in interface Collection<L extends Leg>

Specified by:

clear in interface Set<L extends Leg>

clean

public void clean()
           throws PatriusException

Clean the legs sequence by truncating every overlapping legs and removing included legs.

This method should cover several cases for each legs couples (leg1/leg2) from the sequence :

• 1 - When the leg1 is included in the leg2 -> leg1 is removed
• 2 - When the leg2 is included in the leg1 -> leg2 is removed
• 3 - When the leg1 overlaps leg2 (so saying that leg2 overlaps leg1 is also true) : we check the two leg's upper dates.
  • The leg which is the more in the future is kept untouched.
  • The other one is truncated with its lower bound untouched and upper bound equals to the other leg's lower bound date with closed endpoint. It's possible for the two legs to overlaps only at this date if the other has a closed endpoint too.

Specified by:

clean in interface LegsSequence<L extends Leg>

Throws:

PatriusException - thrown if the new time interval is not included in the current time interval

isCompact

public boolean isCompact()
                  throws PatriusException

Returns a boolean indicating if the sequence is compact or not. A sequence is compact if not gap exists between the legs in the sequence. However, the sequence is still considered compact if legs are overlapping with each other.

Returns:

true if the sequence is compact

Throws:

PatriusException - thrown if sequence is empty

hasOverlaping

public boolean hasOverlaping()
                      throws PatriusException

Returns a boolean indicating if the sequence contains overlapping legs. Legs with connected boundaries are not considered to be overlapping.

Returns:

true if the sequence contains overlapping legs

Throws:

PatriusException - thrown if sequence is empty