ParameterDriversList.java

  1. /* Copyright 2002-2017 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.         for (final DelegatingDriver d : delegating) {
  77.             if (d.getName().equals(driver.getName())) {
  78.                 // the parameter is already managed by existing drivers

  80.                 for (final ParameterDriver existing : d.drivers) {
  81.                     if (existing == driver) {
  82.                         // the driver is already known, don't duplicate it
  83.                         return;
  84.                     }
  85.                 }

  87.                 // this is a new driver for an already managed parameter
  88.                 d.add(driver);
  89.                 return;

  91.             }
  92.         }

  94.         // this is the first driver we have for this parameter name
  95.         delegating.add(new DelegatingDriver(driver));

  97.     }

  99.     /** Sort the parameters lexicographically.
  100.      */
  101.     public void sort() {
  102.         Collections.sort(delegating, new Comparator<DelegatingDriver>() {
  103.             /** {@inheritDoc} */
  104.             @Override
  105.             public int compare(final DelegatingDriver d1, final DelegatingDriver d2) {
  106.                 return d1.getName().compareTo(d2.getName());
  107.             }
  108.         });
  109.     }

  111.     /** Filter parameters to keep only one type of selection status.
  112.      * @param selected if true, only {@link ParameterDriver#isSelected()
  113.      * selected} parameters will be kept, the other ones will be removed
  114.      */
  115.     public void filter(final boolean selected) {
  116.         for (final Iterator<DelegatingDriver> iterator = delegating.iterator(); iterator.hasNext();) {
  117.             if (iterator.next().isSelected() != selected) {
  118.                 iterator.remove();
  119.             }
  120.         }
  121.     }

  123.     /** Get the number of parameters with different names.
  124.      * @return number of parameters with different names
  125.      */
  126.     public int getNbParams() {
  127.         return delegating.size();
  128.     }

  130.     /** Get delegating drivers for all parameters.
  131.      * <p>
  132.      * The delegating drivers are <em>not</em> the same as
  133.      * the drivers added to the list, but they delegate to them.
  134.      * </p>
  135.      * <p>
  136.      * All delegating drivers manage parameters with different names.
  137.      * </p>
  138.      * @return unmodifiable view of the list of delegating drivers
  139.      */
  140.     public List<DelegatingDriver> getDrivers() {
  141.         return Collections.unmodifiableList(delegating);
  142.     }

  144.     /** Specialized driver delegating to several other managing
  145.      * the same parameter name.
  146.      */
  147.     public static class DelegatingDriver extends ParameterDriver {

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

  152.         /** Observer for propagating changes between all drivers. */
  153.         private final ChangesForwarder forwarder;

  155.         /** Simple constructor.
  156.          * @param driver first driver in the series
  157.          * @exception OrekitException if first drivers throws one
  158.          */
  159.         DelegatingDriver(final ParameterDriver driver) throws OrekitException {
  160.             super(driver.getName(), driver.getReferenceValue(),
  161.                   driver.getScale(), driver.getMinValue(), driver.getMaxValue());
  162.             drivers = new ArrayList<ParameterDriver>();
  163.             drivers.add(driver);

  165.             setValue(driver.getValue());
  166.             setReferenceDate(driver.getReferenceDate());
  167.             setSelected(driver.isSelected());

  169.             // when the value or reference date of the delegating driver change,
  170.             // all underlying drivers must reproduce the change
  171.             forwarder = new ChangesForwarder();

  173.             addObserver(forwarder);
  174.             driver.addObserver(forwarder);

  176.         }

  178.         /** Add a driver.
  179.          * @param driver driver to add
  180.          * @exception OrekitException if an existing drivers cannot be set to the same value
  181.          */
  182.         private void add(final ParameterDriver driver)
  183.             throws OrekitException {

  185.             setValue(driver.getValue());
  186.             setReferenceDate(driver.getReferenceDate());

  188.             // if any of the drivers is selected, all must be selected
  189.             if (isSelected()) {
  190.                 driver.setSelected(true);
  191.             } else {
  192.                 setSelected(driver.isSelected());
  193.             }

  195.             driver.addObserver(forwarder);
  196.             drivers.add(driver);

  198.         }

  200.         /** Get the raw drivers to which this one delegates.
  201.          * <p>
  202.          * These raw drivers all manage the same parameter name.
  203.          * </p>
  204.          * @return raw drivers to which this one delegates
  205.          */
  206.         public List<ParameterDriver> getRawDrivers() {
  207.             return Collections.unmodifiableList(drivers);
  208.         }

  210.         /** Local observer for propagating changes, avoiding infinite recursion. */
  211.         private class ChangesForwarder implements ParameterObserver {

  213.             /** Root of the current update chain. */
  214.             private ParameterDriver root;

  216.             /** Depth of the current update chain. */
  217.             private int depth;

  219.             /** {@inheritDoc} */
  220.             @Override
  221.             public void valueChanged(final double previousValue, final ParameterDriver driver)
  222.                 throws OrekitException {
  223.                 try {
  224.                     updateAll(driver, d -> {
  225.                         try {
  226.                             d.setValue(driver.getValue());
  227.                         } catch (OrekitException oe) {
  228.                             throw new OrekitExceptionWrapper(oe);
  229.                         }
  230.                     });
  231.                 } catch (OrekitExceptionWrapper oew) {
  232.                     throw oew.getException();
  233.                 }
  234.             }

  236.             /** {@inheritDoc} */
  237.             @Override
  238.             public void referenceDateChanged(final AbsoluteDate previousReferenceDate, final ParameterDriver driver) {
  239.                 updateAll(driver, d -> d.setReferenceDate(driver.getReferenceDate()));
  240.             }

  242.             /** {@inheritDoc} */
  243.             @Override
  244.             public void nameChanged(final String previousName, final ParameterDriver driver) {
  245.                 updateAll(driver, d -> d.setName(driver.getName()));
  246.             }

  248.             /** {@inheritDoc} */
  249.             @Override
  250.             public void selectionChanged(final boolean previousSelection, final ParameterDriver driver) {
  251.                 updateAll(driver, d -> d.setSelected(driver.isSelected()));
  252.             }

  254.             /** Update all bound parameters.
  255.              * @param driver driver triggering the update
  256.              * @param updater updater to use
  257.              */
  258.             private void updateAll(final ParameterDriver driver, final Updater updater) {

  260.                 final boolean firstCall = depth++ == 0;
  261.                 if (firstCall) {
  262.                     root = driver;
  263.                 }

  265.                 if (driver == DelegatingDriver.this) {
  266.                     // propagate change downwards, which will trigger recursive calls
  267.                     for (final ParameterDriver d : drivers) {
  268.                         if (d != root) {
  269.                             updater.update(d);
  270.                         }
  271.                     }
  272.                 } else if (firstCall) {
  273.                     // first call started from an underlying driver, propagate change upwards
  274.                     updater.update(DelegatingDriver.this);
  275.                 }

  277.                 if (--depth == 0) {
  278.                     // this is the end of the root call
  279.                     root = null;
  280.                 }

  282.             }

  284.         }

  286.     }

  288.     /** Interface for updating parameters. */
  289.     @FunctionalInterface
  290.     private interface Updater {
  291.         /** Update a driver.
  292.          * @param driver driver to update
  293.          */
  294.         void update(ParameterDriver driver);
  295.     }

  297. }
Created with JaCoCo 0.7.9.201702052155