Menu
▾
▴
[Fudaa-svn-commit] SF.net SVN: fudaa:[9447] trunk/soft/fudaa-crue
|
From: <de...@us...> - 2016-10-21 14:42:14
|
Revision: 9447
http://sourceforge.net/p/fudaa/svn/9447
Author: deniger
Date: 2016-10-21 14:42:11 +0000 (Fri, 21 Oct 2016)
Log Message:
-----------
Utilisation de la notation diamond
Modified Paths:
--------------
trunk/soft/fudaa-crue/crue-emh/src/main/java/org/fudaa/dodico/crue/metier/helper/OrdCalcCloner.java
trunk/soft/fudaa-crue/crue-emh/src/test/java/org/fudaa/dodico/crue/metier/helper/OrdCalcClonerTest.java
trunk/soft/fudaa-crue/ui-modelling/src/main/java/org/fudaa/fudaa/crue/modelling/calcul/CalculNodeFactory.java
Modified: trunk/soft/fudaa-crue/crue-emh/src/main/java/org/fudaa/dodico/crue/metier/helper/OrdCalcCloner.java
===================================================================
--- trunk/soft/fudaa-crue/crue-emh/src/main/java/org/fudaa/dodico/crue/metier/helper/OrdCalcCloner.java 2016-10-21 09:28:45 UTC (rev 9446)
+++ trunk/soft/fudaa-crue/crue-emh/src/main/java/org/fudaa/dodico/crue/metier/helper/OrdCalcCloner.java 2016-10-21 14:42:11 UTC (rev 9447)
@@ -4,11 +4,14 @@
package org.fudaa.dodico.crue.metier.helper;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
import org.fudaa.dodico.crue.common.transformer.TransformerHelper;
import org.fudaa.dodico.crue.metier.comparator.ObjetNommeByNameComparator;
import org.fudaa.dodico.crue.metier.emh.Calc;
@@ -16,6 +19,9 @@
import org.fudaa.dodico.crue.metier.emh.EMHScenario;
import org.fudaa.dodico.crue.metier.emh.OrdCalc;
import org.fudaa.dodico.crue.metier.emh.OrdCalcScenario;
+import org.fudaa.dodico.crue.metier.emh.ui.CalcOrdCalcUiState;
+import org.fudaa.dodico.crue.metier.emh.ui.OrdCalcScenarioUiState;
+import org.fudaa.dodico.crue.metier.etude.ManagerEMHScenario;
/**
*
@@ -25,21 +31,42 @@
public static class Result {
+ /**
+ * contient les ordre de calcul definit dans le scenario*
+ */
public List<OrdCalc> ordCalcs = new ArrayList<>();
+ /**
+ * contient les ordCalc definit dans le fichier ui ocal persistant les editions de l'utilisateur*
+ */
+ public List<OrdCalc> ordCalcsinUI = new ArrayList<>();
+ /**
+ * les calculs dans l ordre attendu.
+ */
public List<Calc> calcs = new ArrayList<>();
}
- public Result cloneAndSort(EMHScenario scenario) {
- return cloneOrdCalcAndCalc(scenario.getDonCLimMScenario(), scenario.getOrdCalcScenario());
+ public Result cloneAndSort(EMHScenario scenario, ManagerEMHScenario managerEMHScenario) {
+ return cloneOrdCalcAndCalc(scenario.getDonCLimMScenario(), scenario.getOrdCalcScenario(), managerEMHScenario.getUiOCalData());
}
- public Result cloneOrdCalcAndCalc(DonCLimMScenario dclm, OrdCalcScenario ocal) {
- Result res = new Result();
+ public Result cloneOrdCalcAndCalc(DonCLimMScenario dclm, OrdCalcScenario ocal, OrdCalcScenarioUiState uiOCalData) {
List<Calc> calcs = dclm.getCalc();
List<Calc> clonedCalcs = new ArrayList<>();
for (Calc calc : calcs) {
clonedCalcs.add(calc.deepClone());
}
+ Result res = null;
+ if (uiOCalData == null) {
+ res = sortCalcWithNoSavedUi(ocal, clonedCalcs);
+ } else {
+ res = sortCalcWithSavedUi(ocal, clonedCalcs, uiOCalData);
+ }
+ return res;
+
+ }
+
+ protected Result sortCalcWithNoSavedUi(OrdCalcScenario ocal, List<Calc> clonedCalcs) {
+ Result res = new Result();
Map<String, Calc> clonedCalcsByName = TransformerHelper.toMapOfNom(clonedCalcs);
List<OrdCalc> ordCalcs = ocal.getOrdCalc();
List<Calc> pseudoPermActivated = new ArrayList<>();
@@ -47,10 +74,10 @@
List<Calc> transActivated = new ArrayList<>();
List<Calc> transNonActivated = new ArrayList<>();
- Set<String> actifCalc = new HashSet<>();
+ Set<String> namesOfActiveCalcul = new HashSet<>();
for (OrdCalc ordCalc : ordCalcs) {
String calcName = ordCalc.getCalc().getNom();
- actifCalc.add(calcName);
+ namesOfActiveCalcul.add(calcName);
final Calc calc = clonedCalcsByName.get(calcName);
res.ordCalcs.add(ordCalc.deepCloneButNotCalc(calc));
if (ordCalc.isPseudoPermanent()) {
@@ -60,7 +87,7 @@
}
}
for (Calc calc : clonedCalcs) {
- if (!actifCalc.contains(calc.getNom())) {
+ if (!namesOfActiveCalcul.contains(calc.getNom())) {
if (calc.isPermanent()) {
pseudoPermNonActivated.add(calc);
} else {
@@ -78,4 +105,59 @@
res.calcs.addAll(transNonActivated);
return res;
}
+
+ protected Result sortCalcWithSavedUi(OrdCalcScenario ocal, List<Calc> clonedCalcs, OrdCalcScenarioUiState uiOCalData) {
+ Result res = new Result();
+ Map<String, Calc> clonedCalcsByName = TransformerHelper.toMapOfNom(clonedCalcs);
+ final List<String> calcNameInOrder = uiOCalData.getCalcNameInOrder();
+ boolean isCoherent = isUiSavedCalcAccordingToCalcs(clonedCalcs, calcNameInOrder);
+ if (!isCoherent) {
+ Logger.getLogger(OrdCalcCloner.class.getName()).log(Level.WARNING, "The ocal ui file is not coherent with the ocal data");
+ return sortCalcWithNoSavedUi(ocal, clonedCalcs);
+ }
+ List<OrdCalc> ordCalcsInScenario = ocal.getOrdCalc();
+ Set<String> namesOfActiveCalcul = new HashSet<>();
+ for (OrdCalc ordCalc : ordCalcsInScenario) {
+ String calcName = ordCalc.getCalc().getNom();
+ namesOfActiveCalcul.add(calcName);
+ final Calc calc = clonedCalcsByName.get(calcName);
+ res.ordCalcs.add(ordCalc.deepCloneButNotCalc(calc));
+ }
+ final List<CalcOrdCalcUiState> uiStates = uiOCalData.getUiStates();
+ for (CalcOrdCalcUiState uiState : uiStates) {
+ final String calcName = uiState.getCalcId();
+ if (!namesOfActiveCalcul.contains(calcName)) {
+ final OrdCalc ordCalcSaved = uiState.getOrdCalc();
+ final Calc calc = clonedCalcsByName.get(calcName);
+ assert calc != null : "uiOrdCalc: should not be null as the method isUiSavedCalcAccordingToCalcs should have tested it";
+ res.ordCalcsinUI.add(ordCalcSaved.deepCloneButNotCalc(calc));
+ }
+ }
+ for (String calcName : calcNameInOrder) {
+ final Calc calc = clonedCalcsByName.get(calcName);
+ assert calc != null : "should not be null as the method isUiSavedCalcAccordingToCalcs should have tested it";
+ res.calcs.add(calc);
+ }
+ return res;
+ }
+
+ /**
+ *
+ * @param clonedCalcs la liste des calculs presents dans l'etude
+ * @param calcNameInOrder la liste des calculs presents dans le fichier ui-ocal permettant de persister les editions de l'utilisateur
+ * @return true si les 2 données sont coherentes et si on peut les utiliser.
+ */
+ protected boolean isUiSavedCalcAccordingToCalcs(Collection<Calc> clonedCalcs, final Collection<String> calcNameInOrder) {
+ //on va d'abord voir si le tout est cohérent:
+ Map<String, Calc> clonedCalcsByName = TransformerHelper.toMapOfNom(clonedCalcs);
+ if (clonedCalcs.size() == calcNameInOrder.size()) {
+ for (String string : calcNameInOrder) {
+ if (!clonedCalcsByName.containsKey(string)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ return false;
+ }
}
Modified: trunk/soft/fudaa-crue/crue-emh/src/test/java/org/fudaa/dodico/crue/metier/helper/OrdCalcClonerTest.java
===================================================================
--- trunk/soft/fudaa-crue/crue-emh/src/test/java/org/fudaa/dodico/crue/metier/helper/OrdCalcClonerTest.java 2016-10-21 09:28:45 UTC (rev 9446)
+++ trunk/soft/fudaa-crue/crue-emh/src/test/java/org/fudaa/dodico/crue/metier/helper/OrdCalcClonerTest.java 2016-10-21 14:42:11 UTC (rev 9447)
@@ -3,12 +3,19 @@
*/
package org.fudaa.dodico.crue.metier.helper;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
import org.fudaa.dodico.crue.config.ccm.CrueConfigMetierLoaderDefaultTest;
+import org.fudaa.dodico.crue.metier.emh.Calc;
import org.fudaa.dodico.crue.metier.emh.CalcPseudoPerm;
import org.fudaa.dodico.crue.metier.emh.CalcPseudoPermBrancheOrificeManoeuvre;
import org.fudaa.dodico.crue.metier.emh.DonCLimMScenario;
import org.fudaa.dodico.crue.metier.emh.OrdCalcPseudoPermIniCalcCI;
+import org.fudaa.dodico.crue.metier.emh.OrdCalcPseudoPermIniCalcPrecedent;
import org.fudaa.dodico.crue.metier.emh.OrdCalcScenario;
+import org.fudaa.dodico.crue.metier.emh.ui.OrdCalcScenarioUiState;
import org.fudaa.dodico.crue.metier.helper.OrdCalcCloner.Result;
import static org.junit.Assert.*;
import org.junit.Test;
@@ -27,18 +34,96 @@
DonCLimMScenario dclm = new DonCLimMScenario();
OrdCalcScenario ocal = new OrdCalcScenario();
CalcPseudoPerm pseudo = new CalcPseudoPerm();
- final CalcPseudoPermBrancheOrificeManoeuvre calcPseudoPermBrancheOrificeManoeuvre = new CalcPseudoPermBrancheOrificeManoeuvre(CrueConfigMetierLoaderDefaultTest.DEFAULT);
+ final CalcPseudoPermBrancheOrificeManoeuvre calcPseudoPermBrancheOrificeManoeuvre = new CalcPseudoPermBrancheOrificeManoeuvre(
+ CrueConfigMetierLoaderDefaultTest.DEFAULT);
pseudo.addCalcPseudoPermBrancheOrificeManoeuvre(calcPseudoPermBrancheOrificeManoeuvre);
OrdCalcPseudoPermIniCalcCI ci = new OrdCalcPseudoPermIniCalcCI();
ci.setCalcPseudoPerm(pseudo);
dclm.addCalcPseudoPerm(pseudo);
ocal.addOrdCalc(ci);
OrdCalcCloner cloner = new OrdCalcCloner();
- Result cloneOrdCalcAndCalc = cloner.cloneOrdCalcAndCalc(dclm, ocal);
+ Result cloneOrdCalcAndCalc = cloner.cloneOrdCalcAndCalc(dclm, ocal, null);
assertEquals(1, cloneOrdCalcAndCalc.calcs.size());
assertEquals(1, cloneOrdCalcAndCalc.ordCalcs.size());
assertTrue(cloneOrdCalcAndCalc.calcs.get(0) == cloneOrdCalcAndCalc.ordCalcs.get(0).getCalc());
assertFalse(cloneOrdCalcAndCalc.calcs.get(0) == pseudo);
assertFalse(cloneOrdCalcAndCalc.ordCalcs.get(0) == ci);
}
+
+ @Test
+ public void testCloneOrdCalcAndCalcUI() {
+ DonCLimMScenario dclm = new DonCLimMScenario();
+ OrdCalcScenario ocal = new OrdCalcScenario();
+ CalcPseudoPerm pseudo = new CalcPseudoPerm();
+ pseudo.setNom("CC_P1");
+ final CalcPseudoPermBrancheOrificeManoeuvre calcPseudoPermBrancheOrificeManoeuvre = new CalcPseudoPermBrancheOrificeManoeuvre(
+ CrueConfigMetierLoaderDefaultTest.DEFAULT);
+ pseudo.addCalcPseudoPermBrancheOrificeManoeuvre(calcPseudoPermBrancheOrificeManoeuvre);
+ OrdCalcPseudoPermIniCalcCI ordCalc = new OrdCalcPseudoPermIniCalcCI();
+ ordCalc.setCalcPseudoPerm(pseudo);
+ dclm.addCalcPseudoPerm(pseudo);
+ ocal.addOrdCalc(ordCalc);
+
+ CalcPseudoPerm pseudo2 = new CalcPseudoPerm();
+ pseudo2.setNom("CC_P2");
+ dclm.addCalcPseudoPerm(pseudo2);
+
+
+ OrdCalcScenarioUiState ui = new OrdCalcScenarioUiState();
+ //ici dans l'ordre on inverse les calcul
+ ui.addCalcOrdCalcUiStates("CC_P2", new OrdCalcPseudoPermIniCalcPrecedent());
+ ui.addCalcOrdCalcUiStates("CC_P1", new OrdCalcPseudoPermIniCalcPrecedent());
+ //donc
+ int idxCCP2 = 0;
+ int idxCCP1 = 1;
+
+ OrdCalcCloner cloner = new OrdCalcCloner();
+ Result cloneOrdCalcAndCalc = cloner.cloneOrdCalcAndCalc(dclm, ocal, ui);
+ //test des calculs:
+ assertEquals(2, cloneOrdCalcAndCalc.calcs.size());
+ //attention l'ordre est inversion
+ assertTrue(cloneOrdCalcAndCalc.calcs.get(idxCCP2) == cloneOrdCalcAndCalc.ordCalcsinUI.get(0).getCalc());
+ assertFalse(cloneOrdCalcAndCalc.calcs.get(idxCCP2) == pseudo2);
+
+ assertTrue(cloneOrdCalcAndCalc.calcs.get(idxCCP1) == cloneOrdCalcAndCalc.ordCalcs.get(0).getCalc());
+ assertFalse(cloneOrdCalcAndCalc.calcs.get(idxCCP1) == pseudo);
+
+ //les ordres de calcul
+ assertEquals(1, cloneOrdCalcAndCalc.ordCalcs.size());
+ assertEquals("CC_P1", cloneOrdCalcAndCalc.ordCalcs.get(0).getCalc().getId());
+ assertTrue(cloneOrdCalcAndCalc.ordCalcs.get(0) instanceof OrdCalcPseudoPermIniCalcCI);
+ assertFalse(cloneOrdCalcAndCalc.ordCalcs.get(0) == ordCalc);
+ //les ordres de calcul UI
+ assertEquals(1, cloneOrdCalcAndCalc.ordCalcsinUI.size());
+ assertEquals("CC_P2", cloneOrdCalcAndCalc.ordCalcsinUI.get(0).getCalc().getId());
+ assertTrue(cloneOrdCalcAndCalc.ordCalcsinUI.get(0) instanceof OrdCalcPseudoPermIniCalcPrecedent);
+
+ }
+
+ @Test
+ public void testIsUiSavedCalcAccordingToCalcs() {
+ OrdCalcCloner cloner = new OrdCalcCloner();
+ List<String> calcInOrder = Arrays.asList("CC_P1", "CC_P2");
+ Collection<Calc> calcs = createCalcs("CC_P1");
+ assertFalse(cloner.isUiSavedCalcAccordingToCalcs(calcs, calcInOrder));
+ calcs = createCalcs("CC_P1", "CC_P2");
+ assertTrue(cloner.isUiSavedCalcAccordingToCalcs(calcs, calcInOrder));
+ calcs = createCalcs("CC_P1", "CC_P3");
+ assertFalse(cloner.isUiSavedCalcAccordingToCalcs(calcs, calcInOrder));
+ }
+
+ private static Calc createCalc(String id) {
+ CalcPseudoPerm res = new CalcPseudoPerm();
+ res.setNom(id);
+ return res;
+ }
+
+ private static Collection<Calc> createCalcs(String... ids) {
+ List<Calc> calcs = new ArrayList<>();
+ for (String id : ids) {
+ calcs.add(createCalc(id));
+ }
+ return calcs;
+ }
+
}
Modified: trunk/soft/fudaa-crue/ui-modelling/src/main/java/org/fudaa/fudaa/crue/modelling/calcul/CalculNodeFactory.java
===================================================================
--- trunk/soft/fudaa-crue/ui-modelling/src/main/java/org/fudaa/fudaa/crue/modelling/calcul/CalculNodeFactory.java 2016-10-21 09:28:45 UTC (rev 9446)
+++ trunk/soft/fudaa-crue/ui-modelling/src/main/java/org/fudaa/fudaa/crue/modelling/calcul/CalculNodeFactory.java 2016-10-21 14:42:11 UTC (rev 9447)
@@ -47,6 +47,12 @@
private final DonLoiHYConteneur donLoiHYConteneurCloned;
private final Map<String, Loi> clonedLoisByName;
+ public CalculNodeFactory(OutlineView outlineView) {
+ this.outlineView = outlineView;
+ donLoiHYConteneurCloned = (DonLoiHYConteneur) outlineView.getClientProperty(DonLoiHYConteneur.class);
+ clonedLoisByName = TransformerHelper.toMapOfNom(donLoiHYConteneurCloned.getLois());
+ }
+
protected Children createChildren(Calc calc, Map<Calc, OrdCalc> ordCalcByCalcs, DonLoiHYConteneur donLoiHYConteneur) {
List<Node> nodes = new ArrayList<>();
List<DonCLimM> listeDCLM = calc.getlisteDCLM();
@@ -68,19 +74,14 @@
return NodeHelper.createArray(nodes);
}
- public CalculNodeFactory(OutlineView outlineView) {
- this.outlineView = outlineView;
- donLoiHYConteneurCloned = (DonLoiHYConteneur) outlineView.getClientProperty(DonLoiHYConteneur.class);
- clonedLoisByName = TransformerHelper.toMapOfNom(donLoiHYConteneurCloned.getLois());
- }
-
public List<CalculNode> createNodes() {
if (modellingScenarioService.getScenarioLoaded() == null) {
return Collections.emptyList();
}
List<CalculNode> nodes = new ArrayList<>();
OrdCalcCloner cloner = new OrdCalcCloner();
- Result cloneOrdCalcAndCalc = cloner.cloneAndSort(modellingScenarioService.getScenarioLoaded());
+ Result cloneOrdCalcAndCalc = cloner.
+ cloneAndSort(modellingScenarioService.getScenarioLoaded(), modellingScenarioService.getManagerScenarioLoaded());
final Map<Calc, OrdCalc> ordCalcByCalc = CalcHelper.getOrdCalcByCalc(cloneOrdCalcAndCalc.ordCalcs);
//TODO trier les calculs ici:
final CrueConfigMetier ccm = modellingScenarioService.getSelectedProjet().getPropDefinition();
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
