TimeSpanMap.java

  1. /* Copyright 2002-2018 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.utils;

  19. import java.util.Collections;
  20. import java.util.NavigableSet;
  21. import java.util.SortedSet;
  22. import java.util.TreeSet;

  24. import org.orekit.time.AbsoluteDate;
  25. import org.orekit.time.ChronologicalComparator;
  26. import org.orekit.time.TimeStamped;

  28. /** Container for objects that apply to spans of time.

  30.  * @param <T> Type of the data.

  32.  * @author Luc Maisonobe
  33.  * @since 7.1
  34.  */
  35. public class TimeSpanMap<T> {

  37.     /** Container for the data. */
  38.     private final NavigableSet<Transition<T>> data;

  40.     /** Create a map containing a single object, initially valid throughout the timeline.
  41.      * <p>
  42.      * The real validity of this first entry will be truncated as other
  43.      * entries are either {@link #addValidBefore(Object, AbsoluteDate)
  44.      * added before} it or {@link #addValidAfter(Object, AbsoluteDate)
  45.      * added after} it.
  46.      * </p>
  47.      * @param entry entry (initially valid throughout the timeline)
  48.      */
  49.     public TimeSpanMap(final T entry) {
  50.         data = new TreeSet<Transition<T>>(new ChronologicalComparator());
  51.         data.add(new Transition<T>(AbsoluteDate.J2000_EPOCH, entry, entry));
  52.     }

  54.     /** Add an entry valid before a limit date.
  55.      * <p>
  56.      * As an entry is valid, it truncates the validity of the neighboring
  57.      * entries already present in the map.
  58.      * </p>
  59.      * <p>
  60.      * The transition dates should be entered only once, either
  61.      * by a call to this method or by a call to {@link #addValidAfter(Object,
  62.      * AbsoluteDate)}. Repeating a transition date will lead to unexpected
  63.      * result and is not supported.
  64.      * </p>
  65.      * @param entry entry to add
  66.      * @param latestValidityDate date before which the entry is valid
  67.      * (must be different from <em>all</em> dates already used for transitions)
  68.      */
  69.     public void addValidBefore(final T entry, final AbsoluteDate latestValidityDate) {

  71.         if (data.size() == 1) {
  72.             final Transition<T> single = data.first();
  73.             if (single.getBefore() == single.getAfter()) {
  74.                 // the single entry was a dummy one, without a real transition
  75.                 // we replace it entirely
  76.                 data.clear();
  77.                 data.add(new Transition<T>(latestValidityDate, entry, single.getAfter()));
  78.                 return;
  79.             }
  80.         }

  82.         final Transition<T> previous =
  83.                 data.floor(new Transition<T>(latestValidityDate, entry, null));
  84.         if (previous == null) {
  85.             // the new transition will be the first one
  86.             data.add(new Transition<T>(latestValidityDate, entry, data.first().getBefore()));
  87.         } else {
  88.             // the new transition will be after the previous one
  89.             data.remove(previous);
  90.             data.add(new Transition<T>(previous.date,      previous.getBefore(), entry));
  91.             data.add(new Transition<T>(latestValidityDate, entry,                previous.getAfter()));
  92.         }

  94.     }

  96.     /** Add an entry valid after a limit date.
  97.      * <p>
  98.      * As an entry is valid, it truncates the validity of the neighboring
  99.      * entries already present in the map.
  100.      * </p>
  101.      * <p>
  102.      * The transition dates should be entered only once, either
  103.      * by a call to this method or by a call to {@link #addValidBefore(Object,
  104.      * AbsoluteDate)}. Repeating a transition date will lead to unexpected
  105.      * result and is not supported.
  106.      * </p>
  107.      * @param entry entry to add
  108.      * @param earliestValidityDate date after which the entry is valid
  109.      * (must be different from <em>all</em> dates already used for transitions)
  110.      */
  111.     public void addValidAfter(final T entry, final AbsoluteDate earliestValidityDate) {

  113.         if (data.size() == 1) {
  114.             final Transition<T> single = data.first();
  115.             if (single.getBefore() == single.getAfter()) {
  116.                 // the single entry was a dummy one, without a real transition
  117.                 // we replace it entirely
  118.                 data.clear();
  119.                 data.add(new Transition<T>(earliestValidityDate, single.getBefore(), entry));
  120.                 return;
  121.             }
  122.         }

  124.         final Transition<T> next =
  125.                 data.ceiling(new Transition<T>(earliestValidityDate, entry, null));
  126.         if (next == null) {
  127.             // the new transition will be the last one
  128.             data.add(new Transition<T>(earliestValidityDate, data.last().getAfter(), entry));
  129.         } else {
  130.             // the new transition will be before the next one
  131.             data.remove(next);
  132.             data.add(new Transition<T>(earliestValidityDate, next.getBefore(), entry));
  133.             data.add(new Transition<T>(next.date,            entry,            next.getAfter()));
  134.         }

  136.     }

  138.     /** Get the entry valid at a specified date.
  139.      * @param date date at which the entry must be valid
  140.      * @return valid entry at specified date
  141.      */
  142.     public T get(final AbsoluteDate date) {
  143.         final Transition<T> previous = data.floor(new Transition<T>(date, null, null));
  144.         if (previous == null) {
  145.             // there are no transition before the specified date
  146.             // return the first valid entry
  147.             return data.first().getBefore();
  148.         } else {
  149.             return previous.getAfter();
  150.         }
  151.     }

  153.     /** Extract a range of the map.
  154.      * <p>
  155.      * The object returned will be a new independent instance that will contain
  156.      * only the transitions that lie in the specified range.
  157.      * </p>
  158.      * <p>
  159.      * Consider for example a map containing objects O₀ valid before t₁, O₁ valid
  160.      * between t₁ and t₂, O₂ valid between t₂ and t₃, O₃ valid between t₃ and t₄,
  161.      * and O₄ valid after t₄. then calling this method with a {@code start}
  162.      * date between t₁ and t₂ and a {@code end} date between t₃ and t₄
  163.      * will result in a new map containing objects O₁ valid before t₂, O₂
  164.      * valid between t₂ and t₃, and O₃ valid after t₃. The validity of O₁
  165.      * is therefore extended in the past, and the validity of O₃ is extended
  166.      * in the future.
  167.      * </p>
  168.      * @param start earliest date at which a transition is included in the range
  169.      * (may be set to {@link AbsoluteDate#PAST_INFINITY} to keep all early transitions)
  170.      * @param end latest date at which a transition is included in the r
  171.      * (may be set to {@link AbsoluteDate#FUTURE_INFINITY} to keep all late transitions)
  172.      * @return a new instance with all transitions restricted to the specified range
  173.      * @since 9.2
  174.      */
  175.     public TimeSpanMap<T> extractRange(final AbsoluteDate start, final AbsoluteDate end) {

  177.         final NavigableSet<Transition<T>> inRange = data.subSet(new Transition<T>(start, null, null), true,
  178.                                                                 new Transition<T>(end,   null, null), true);
  179.         if (inRange.isEmpty()) {
  180.             // there are no transitions at all in the range
  181.             // we need to pick up the only valid object
  182.             return new TimeSpanMap<>(get(start));
  183.         }

  185.         final TimeSpanMap<T> range = new TimeSpanMap<>(inRange.first().before);
  186.         for (final Transition<T> transition : inRange) {
  187.             range.addValidAfter(transition.after, transition.getDate());
  188.         }

  190.         return range;

  192.     }

  194.     /** Get an unmodifiable view of the sorted transitions.
  195.      * @return unmodifiable view of the sorted transitions
  196.      */
  197.     public SortedSet<Transition<T>> getTransitions() {
  198.         return Collections.unmodifiableSortedSet(data);
  199.     }

  201.     /** Local class holding transition times. */
  202.     public static class Transition<S> implements TimeStamped {

  204.         /** Transition date. */
  205.         private final AbsoluteDate date;

  207.         /** Entry valid before the transition. */
  208.         private final S before;

  210.         /** Entry valid after the transition. */
  211.         private final S after;

  213.         /** Simple constructor.
  214.          * @param date transition date
  215.          * @param before entry valid before the transition
  216.          * @param after entry valid after the transition
  217.          */
  218.         private Transition(final AbsoluteDate date, final S before, final S after) {
  219.             this.date   = date;
  220.             this.before = before;
  221.             this.after  = after;
  222.         }

  224.         /** Get the transition date.
  225.          * @return transition date
  226.          */
  227.         @Override
  228.         public AbsoluteDate getDate() {
  229.             return date;
  230.         }

  232.         /** Get the entry valid before transition.
  233.          * @return entry valid before transition
  234.          */
  235.         public S getBefore() {
  236.             return before;
  237.         }

  239.         /** Get the entry valid after transition.
  240.          * @return entry valid after transition
  241.          */
  242.         public S getAfter() {
  243.             return after;
  244.         }

  246.     }

  248. }
Created with JaCoCo 0.7.9.201702052155