ParameterDriversList.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.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.errors.OrekitException;
  26. import org.orekit.errors.OrekitExceptionWrapper;
  27. import org.orekit.time.AbsoluteDate;


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

  52.     /** Managed drivers. */
  53.     private final List<DelegatingDriver> delegating;

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

  61.     /** Add a driver.
  62.      * <p>
  63.      * If the driver is already present, it will not be added.
  64.      * If another driver managing the same parameter is present,
  65.      * both drivers will be managed together, existing drivers
  66.      * being set to the value of the last driver added (i.e.
  67.      * each addition overrides the parameter value).
  68.      * </p>
  69.      * @param driver driver to add
  70.      * @exception OrekitException if an existing driver for the
  71.      * same parameter throws one when its value is reset using the
  72.      * new driver value
  73.      */
  74.     public void add(final ParameterDriver driver) throws OrekitException {

  76.         final DelegatingDriver existingHere = findByName(driver.getName());
  77.         final DelegatingDriver alreadyBound = getAssociatedDelegatingDriver(driver);

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

  100.     }

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

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

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

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

  155.     /** Get the number of parameters with different names.
  156.      * @return number of parameters with different names
  157.      */
  158.     public int getNbParams() {
  159.         return delegating.size();
  160.     }

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

  176.     /** Specialized driver delegating to several other managing
  177.      * the same parameter name.
  178.      */
  179.     public static class DelegatingDriver extends ParameterDriver {

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

  184.         /** Observer for propagating changes between all drivers. */
  185.         private ChangesForwarder forwarder;

  187.         /** Simple constructor.
  188.          * @param driver first driver in the series
  189.          * @exception OrekitException if first drivers throws one
  190.          */
  191.         DelegatingDriver(final ParameterDriver driver) throws OrekitException {
  192.             super(driver.getName(), driver.getReferenceValue(),
  193.                   driver.getScale(), driver.getMinValue(), driver.getMaxValue());
  194.             drivers = new ArrayList<ParameterDriver>();
  195.             drivers.add(driver);

  197.             setValue(driver.getValue());
  198.             setReferenceDate(driver.getReferenceDate());
  199.             setSelected(driver.isSelected());

  201.         }

  203.         /** Set the changes forwarder.
  204.          * @param forwarder new changes forwarder
  205.          * @exception OrekitException if forwarder generates one
  206.          * @since 9.1
  207.          */
  208.         void setForwarder(final ChangesForwarder forwarder)
  209.             throws OrekitException {

  211.             // remove the previous observer if any
  212.             if (this.forwarder != null) {
  213.                 removeObserver(this.forwarder);
  214.                 for (final ParameterDriver driver : drivers) {
  215.                     driver.removeObserver(this.forwarder);
  216.                 }
  217.             }

  219.             // add the new observer
  220.             this.forwarder = forwarder;
  221.             addObserver(forwarder);
  222.             for (final ParameterDriver driver : drivers) {
  223.                 driver.addObserver(forwarder);
  224.             }

  226.         }

  228.         /** Get the changes forwarder.
  229.          * @return changes forwarder
  230.          */
  231.         ChangesForwarder getForwarder() {
  232.             return forwarder;
  233.         }

  235.         /** Add a driver.
  236.          * @param driver driver to add
  237.          * @exception OrekitException if an existing drivers cannot be set to the same value
  238.          */
  239.         private void add(final ParameterDriver driver)
  240.             throws OrekitException {

  242.             for (final ParameterDriver d : drivers) {
  243.                 if (d == driver) {
  244.                     // the driver is already known, don't add it again
  245.                     return;
  246.                 }
  247.             }

  249.             setValue(driver.getValue());
  250.             setReferenceDate(driver.getReferenceDate());

  252.             // if any of the drivers is selected, all must be selected
  253.             if (isSelected()) {
  254.                 driver.setSelected(true);
  255.             } else {
  256.                 setSelected(driver.isSelected());
  257.             }

  259.             driver.addObserver(forwarder);
  260.             drivers.add(driver);

  262.         }

  264.         /** Get the raw drivers to which this one delegates.
  265.          * <p>
  266.          * These raw drivers all manage the same parameter name.
  267.          * </p>
  268.          * @return raw drivers to which this one delegates
  269.          */
  270.         public List<ParameterDriver> getRawDrivers() {
  271.             return Collections.unmodifiableList(drivers);
  272.         }

  274.     }

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

  279.         /** DelegatingDriver we are associated with. */
  280.         private final DelegatingDriver delegating;

  282.         /** Root of the current update chain. */
  283.         private ParameterDriver root;

  285.         /** Depth of the current update chain. */
  286.         private int depth;

  288.         /** Simple constructor.
  289.          * @param delegating delegatingDriver we are associated with
  290.          */
  291.         ChangesForwarder(final DelegatingDriver delegating) {
  292.             this.delegating = delegating;
  293.         }

  295.         /** Get the {@link DelegatingDriver} associated with this instance.
  296.          * @return {@link DelegatingDriver} associated with this instance
  297.          * @since 9.1
  298.          */
  299.         DelegatingDriver getDelegatingDriver() {
  300.             return delegating;
  301.         }

  303.         /** {@inheritDoc} */
  304.         @Override
  305.         public void valueChanged(final double previousValue, final ParameterDriver driver)
  306.             throws OrekitException {
  307.             try {
  308.                 updateAll(driver, d -> {
  309.                     try {
  310.                         d.setValue(driver.getValue());
  311.                     } catch (OrekitException oe) {
  312.                         throw new OrekitExceptionWrapper(oe);
  313.                     }
  314.                 });
  315.             } catch (OrekitExceptionWrapper oew) {
  316.                 throw oew.getException();
  317.             }
  318.         }

  320.         /** {@inheritDoc} */
  321.         @Override
  322.         public void referenceDateChanged(final AbsoluteDate previousReferenceDate, final ParameterDriver driver) {
  323.             updateAll(driver, d -> d.setReferenceDate(driver.getReferenceDate()));
  324.         }

  326.         /** {@inheritDoc} */
  327.         @Override
  328.         public void nameChanged(final String previousName, final ParameterDriver driver) {
  329.             updateAll(driver, d -> d.setName(driver.getName()));
  330.         }

  332.         /** {@inheritDoc} */
  333.         @Override
  334.         public void selectionChanged(final boolean previousSelection, final ParameterDriver driver) {
  335.             updateAll(driver, d -> d.setSelected(driver.isSelected()));
  336.         }

  338.         /** Update all bound parameters.
  339.          * @param driver driver triggering the update
  340.          * @param updater updater to use
  341.          */
  342.         private void updateAll(final ParameterDriver driver, final Updater updater) {

  344.             final boolean firstCall = depth++ == 0;
  345.             if (firstCall) {
  346.                 root = driver;
  347.             }

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

  361.             if (--depth == 0) {
  362.                 // this is the end of the root call
  363.                 root = null;
  364.             }

  366.         }

  368.     }

  370.     /** Interface for updating parameters. */
  371.     @FunctionalInterface
  372.     private interface Updater {
  373.         /** Update a driver.
  374.          * @param driver driver to update
  375.          */
  376.         void update(ParameterDriver driver);
  377.     }

  379. }
Created with JaCoCo 0.7.9.201702052155