ParameterDriversList.java

  1. /* Copyright 2002-2019 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.ArrayList;
  20. import java.util.Collections;
  21. import java.util.Comparator;
  22. import java.util.Iterator;
  23. import java.util.List;

  25. import org.orekit.time.AbsoluteDate;


  28. /** Class managing several {@link ParameterDriver parameter drivers},
  29.  * taking care of duplicated names.
  30.  * <p>
  31.  * Once parameter drivers sharing the same name have been added to
  32.  * an instance of this class, they are permanently bound together and
  33.  * also bound to the {@link #getDrivers() delegating driver} that
  34.  * manages them. This means that if drivers {@code d1}, {@code d2}...
  35.  * {@code dn} are added to the list and both correspond to parameter
  36.  * name "P", then {@link #getDrivers()} will return a list containing
  37.  * a delegating driver {@code delegateD} for the same name "P".
  38.  * Afterwards, whenever either {@link ParameterDriver#setValue(double)}
  39.  * or {@link ParameterDriver#setReferenceDate(AbsoluteDate)} is called
  40.  * on any of the {@code n+1} instances {@code d1}, {@code d2}... {@code dn}
  41.  * or {@code delegateD}, the call will be automatically forwarded to the
  42.  * {@code n} remaining instances, hence ensuring they remain consistent
  43.  * with each other.
  44.  * </p>
  45.  * @author Luc Maisonobe
  46.  * @since 8.0
  47.  */
  48. public class ParameterDriversList {

  50.     /** Managed drivers. */
  51.     private final List<DelegatingDriver> delegating;

  53.     /** Creates an empty list.
  54.      */
  55.     public ParameterDriversList() {
  56.         this.delegating = new ArrayList<DelegatingDriver>();
  57.     }

  59.     /** Add a driver.
  60.      * <p>
  61.      * If the driver is already present, it will not be added.
  62.      * If another driver managing the same parameter is present,
  63.      * both drivers will be managed together, existing drivers
  64.      * being set to the value of the last driver added (i.e.
  65.      * each addition overrides the parameter value).
  66.      * </p>
  67.      * @param driver driver to add
  68.      */
  69.     public void add(final ParameterDriver driver) {

  71.         final DelegatingDriver existingHere = findByName(driver.getName());
  72.         final DelegatingDriver alreadyBound = getAssociatedDelegatingDriver(driver);

  74.         if (existingHere != null) {
  75.             if (alreadyBound != null) {
  76.                 // ensure we don't get intermixed change forwarders that call each other recursively
  77.                 existingHere.setForwarder(alreadyBound.getForwarder());
  78.             } else {
  79.                 // this is a new driver for an already managed parameter
  80.                 existingHere.add(driver);
  81.             }
  82.         } else {
  83.             if (alreadyBound != null) {
  84.                 // the driver is new here, but already bound to other drivers in other lists
  85.                 delegating.add(alreadyBound);
  86.             } else {
  87.                 // this is the first driver we have for this parameter name
  88.                 final DelegatingDriver created   = new DelegatingDriver(driver);
  89.                 final ChangesForwarder forwarder = new ChangesForwarder(created);
  90.                 created.setForwarder(forwarder);
  91.                 delegating.add(created);
  92.             }
  93.         }

  95.     }

  97.     /** Get a {@link DelegatingDriver delegating driver} bound to a driver.
  98.      * @param driver driver to check
  99.      * @return a {@link DelegatingDriver delegating driver} bound to a driver, or
  100.      * null if this driver is not associated with any {@link DelegatingDriver delegating driver}
  101.      * @since 9.1
  102.      */
  103.     private DelegatingDriver getAssociatedDelegatingDriver(final ParameterDriver driver) {
  104.         for (final ParameterObserver observer : driver.getObservers()) {
  105.             if (observer instanceof ChangesForwarder) {
  106.                 return ((ChangesForwarder) observer).getDelegatingDriver();
  107.             }
  108.         }
  109.         return null;
  110.     }

  112.     /** Find  a {@link DelegatingDriver delegating driver} by name.
  113.      * @param name name to check
  114.      * @return a {@link DelegatingDriver delegating driver} managing this parameter name
  115.      * @since 9.1
  116.      */
  117.     public DelegatingDriver findByName(final String name) {
  118.         for (final DelegatingDriver d : delegating) {
  119.             if (d.getName().equals(name)) {
  120.                 return d;
  121.             }
  122.         }
  123.         return null;
  124.     }

  126.     /** Sort the parameters lexicographically.
  127.      */
  128.     public void sort() {
  129.         Collections.sort(delegating, new Comparator<DelegatingDriver>() {
  130.             /** {@inheritDoc} */
  131.             @Override
  132.             public int compare(final DelegatingDriver d1, final DelegatingDriver d2) {
  133.                 return d1.getName().compareTo(d2.getName());
  134.             }
  135.         });
  136.     }

  138.     /** Filter parameters to keep only one type of selection status.
  139.      * @param selected if true, only {@link ParameterDriver#isSelected()
  140.      * selected} parameters will be kept, the other ones will be removed
  141.      */
  142.     public void filter(final boolean selected) {
  143.         for (final Iterator<DelegatingDriver> iterator = delegating.iterator(); iterator.hasNext();) {
  144.             if (iterator.next().isSelected() != selected) {
  145.                 iterator.remove();
  146.             }
  147.         }
  148.     }

  150.     /** Get the number of parameters with different names.
  151.      * @return number of parameters with different names
  152.      */
  153.     public int getNbParams() {
  154.         return delegating.size();
  155.     }

  157.     /** Get delegating drivers for all parameters.
  158.      * <p>
  159.      * The delegating drivers are <em>not</em> the same as
  160.      * the drivers added to the list, but they delegate to them.
  161.      * </p>
  162.      * <p>
  163.      * All delegating drivers manage parameters with different names.
  164.      * </p>
  165.      * @return unmodifiable view of the list of delegating drivers
  166.      */
  167.     public List<DelegatingDriver> getDrivers() {
  168.         return Collections.unmodifiableList(delegating);
  169.     }

  171.     /** Specialized driver delegating to several other managing
  172.      * the same parameter name.
  173.      */
  174.     public static class DelegatingDriver extends ParameterDriver {

  176.         /** Drivers managing the same parameter. */
  177.         private final List<ParameterDriver> drivers;

  179.         /** Observer for propagating changes between all drivers. */
  180.         private ChangesForwarder forwarder;

  182.         /** Simple constructor.
  183.          * @param driver first driver in the series
  184.          */
  185.         DelegatingDriver(final ParameterDriver driver) {
  186.             super(driver.getName(), driver.getReferenceValue(),
  187.                   driver.getScale(), driver.getMinValue(), driver.getMaxValue());
  188.             drivers = new ArrayList<ParameterDriver>();
  189.             drivers.add(driver);

  191.             setValue(driver.getValue());
  192.             setReferenceDate(driver.getReferenceDate());
  193.             setSelected(driver.isSelected());

  195.         }

  197.         /** Set the changes forwarder.
  198.          * @param forwarder new changes forwarder
  199.                   * @since 9.1
  200.          */
  201.         void setForwarder(final ChangesForwarder forwarder) {

  203.             // remove the previous observer if any
  204.             if (this.forwarder != null) {
  205.                 removeObserver(this.forwarder);
  206.                 for (final ParameterDriver driver : drivers) {
  207.                     driver.removeObserver(this.forwarder);
  208.                 }
  209.             }

  211.             // add the new observer
  212.             this.forwarder = forwarder;
  213.             addObserver(forwarder);
  214.             for (final ParameterDriver driver : drivers) {
  215.                 driver.addObserver(forwarder);
  216.             }

  218.         }

  220.         /** Get the changes forwarder.
  221.          * @return changes forwarder
  222.          */
  223.         ChangesForwarder getForwarder() {
  224.             return forwarder;
  225.         }

  227.         /** Add a driver.
  228.          * @param driver driver to add
  229.          */
  230.         private void add(final ParameterDriver driver) {

  232.             for (final ParameterDriver d : drivers) {
  233.                 if (d == driver) {
  234.                     // the driver is already known, don't add it again
  235.                     return;
  236.                 }
  237.             }

  239.             setValue(driver.getValue());
  240.             setReferenceDate(driver.getReferenceDate());

  242.             // if any of the drivers is selected, all must be selected
  243.             if (isSelected()) {
  244.                 driver.setSelected(true);
  245.             } else {
  246.                 setSelected(driver.isSelected());
  247.             }

  249.             driver.addObserver(forwarder);
  250.             drivers.add(driver);

  252.         }

  254.         /** Get the raw drivers to which this one delegates.
  255.          * <p>
  256.          * These raw drivers all manage the same parameter name.
  257.          * </p>
  258.          * @return raw drivers to which this one delegates
  259.          */
  260.         public List<ParameterDriver> getRawDrivers() {
  261.             return Collections.unmodifiableList(drivers);
  262.         }

  264.     }

  266.     /** Local observer for propagating changes, avoiding infinite recursion. */
  267.     private static class ChangesForwarder implements ParameterObserver {

  269.         /** DelegatingDriver we are associated with. */
  270.         private final DelegatingDriver delegating;

  272.         /** Root of the current update chain. */
  273.         private ParameterDriver root;

  275.         /** Depth of the current update chain. */
  276.         private int depth;

  278.         /** Simple constructor.
  279.          * @param delegating delegatingDriver we are associated with
  280.          */
  281.         ChangesForwarder(final DelegatingDriver delegating) {
  282.             this.delegating = delegating;
  283.         }

  285.         /** Get the {@link DelegatingDriver} associated with this instance.
  286.          * @return {@link DelegatingDriver} associated with this instance
  287.          * @since 9.1
  288.          */
  289.         DelegatingDriver getDelegatingDriver() {
  290.             return delegating;
  291.         }

  293.         /** {@inheritDoc} */
  294.         @Override
  295.         public void valueChanged(final double previousValue, final ParameterDriver driver) {
  296.             updateAll(driver, d -> {
  297.                 d.setValue(driver.getValue());
  298.             });
  299.         }

  301.         /** {@inheritDoc} */
  302.         @Override
  303.         public void referenceDateChanged(final AbsoluteDate previousReferenceDate, final ParameterDriver driver) {
  304.             updateAll(driver, d -> d.setReferenceDate(driver.getReferenceDate()));
  305.         }

  307.         /** {@inheritDoc} */
  308.         @Override
  309.         public void nameChanged(final String previousName, final ParameterDriver driver) {
  310.             updateAll(driver, d -> d.setName(driver.getName()));
  311.         }

  313.         /** {@inheritDoc} */
  314.         @Override
  315.         public void selectionChanged(final boolean previousSelection, final ParameterDriver driver) {
  316.             updateAll(driver, d -> d.setSelected(driver.isSelected()));
  317.         }

  319.         /** {@inheritDoc} */
  320.         @Override
  321.         public void referenceValueChanged(final double previousReferenceValue, final ParameterDriver driver) {
  322.             updateAll(driver, d -> d.setReferenceValue(driver.getReferenceValue()));
  323.         }

  325.         /** {@inheritDoc} */
  326.         @Override
  327.         public void minValueChanged(final double previousMinValue, final ParameterDriver driver) {
  328.             updateAll(driver, d -> d.setMinValue(driver.getMinValue()));
  329.         }

  331.         /** {@inheritDoc} */
  332.         @Override
  333.         public void maxValueChanged(final double previousMaxValue, final ParameterDriver driver) {
  334.             updateAll(driver, d -> d.setMaxValue(driver.getMaxValue()));
  335.         }

  337.         /** {@inheritDoc} */
  338.         @Override
  339.         public void scaleChanged(final double previousScale, final ParameterDriver driver) {
  340.             updateAll(driver, d -> d.setScale(driver.getScale()));
  341.         }

  343.         /** Update all bound parameters.
  344.          * @param driver driver triggering the update
  345.          * @param updater updater to use
  346.          */
  347.         private void updateAll(final ParameterDriver driver, final Updater updater) {

  349.             final boolean firstCall = depth++ == 0;
  350.             if (firstCall) {
  351.                 root = driver;
  352.             }

  354.             if (driver == getDelegatingDriver()) {
  355.                 // propagate change downwards, which will trigger recursive calls
  356.                 for (final ParameterDriver d : delegating.drivers) {
  357.                     if (d != root) {
  358.                         updater.update(d);
  359.                     }
  360.                 }
  361.             } else if (firstCall) {
  362.                 // first call started from an underlying driver, propagate change upwards
  363.                 updater.update(getDelegatingDriver());
  364.             }

  366.             if (--depth == 0) {
  367.                 // this is the end of the root call
  368.                 root = null;
  369.             }

  371.         }

  373.     }

  375.     /** Interface for updating parameters. */
  376.     @FunctionalInterface
  377.     private interface Updater {
  378.         /** Update a driver.
  379.          * @param driver driver to update
  380.          */
  381.         void update(ParameterDriver driver);
  382.     }

  384. }
Created with JaCoCo 0.8.2.201808211720