Menu
▾
▴
[Fudaa-svn-commit] SF.net SVN: fudaa:[4611] trunk/soft/fudaa-crue
|
From: <had...@us...> - 2009-04-03 16:08:43
|
Revision: 4611
http://fudaa.svn.sourceforge.net/fudaa/?rev=4611&view=rev
Author: hadouxad
Date: 2009-04-03 16:08:15 +0000 (Fri, 03 Apr 2009)
Log Message:
-----------
* Refactorisation de l'application:
o les fichiers de tests sont dans le package des tests, plus de chemins en dur...
o Refactorisation des finder dans un package helper, ces m?\195?\169thodes statiques sont appel?\195?\169es pour r?\195?\169cup?\195?\169rer les emh.
o Rennomage de certaines classes (factory->converter...)
* Mise en place des tests unitaires
o Mise en place des tests unitaires dans le sous projet dodico
o Ecriture d'une interface qui d?\195?\169finit le contrat minimal de m?\195?\169thodes ?\195?\160 tester pour les tests unitaires (lecture,ecriture, les 2 , ecriture d'au moins une methode de test asser en lecture et ecriture)
o Mise en place du r?\195?\169pertoire de fichiers de tests utilis?\195?\169s par tous les tests unitaires : le r?\195?\169pertoire se nomme fichierTest et situe dans le package de test org.fudaa.dodico.crue.dao
o Exemples mis en place pour les tests DRSO et ETU.
Modified Paths:
--------------
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoPersistDCSP.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoPersistDFRT.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoPersistDPTG.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoPersistDPTI.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoPersistDRSO.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoPersistETU.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoPersistOPTG.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoStructuresFormatDCSP.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoStructuresFormatDFRT.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoStructuresFormatDPTG.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoStructuresFormatDPTI.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoStructuresFormatDRSO.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoStructuresFormatETU.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/validatorXml/ValidatorXml.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/inout/fileformat/EtuFileFormat.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/metier/emh/CatEMHBranche.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/metier/emh/CatEMHCasier.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/metier/emh/CatEMHNoeud.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/metier/emh/CatEMHSection.java
trunk/soft/fudaa-crue/dodico/src/test/java/org/fudaa/dodico/crue/dao/AppCrueTest.java
trunk/soft/fudaa-crue/dodico/src/test/java/org/fudaa/dodico/crue/dao/TestCrueDCSPFile.java
trunk/soft/fudaa-crue/dodico/src/test/java/org/fudaa/dodico/crue/dao/TestCrueDFRTFile.java
trunk/soft/fudaa-crue/dodico/src/test/java/org/fudaa/dodico/crue/dao/TestCrueDPTGFile.java
trunk/soft/fudaa-crue/dodico/src/test/java/org/fudaa/dodico/crue/dao/TestCrueDPTIFile.java
trunk/soft/fudaa-crue/dodico/src/test/java/org/fudaa/dodico/crue/dao/TestCrueDRSOFile.java
trunk/soft/fudaa-crue/dodico/src/test/java/org/fudaa/dodico/crue/dao/TestCrueETU.java
trunk/soft/fudaa-crue/dodico/src/test/java/org/fudaa/dodico/crue/dao/TestCrueInterface.java
trunk/soft/fudaa-crue/dodico/src/test/java/org/fudaa/dodico/crue/dao/TestCrueOPTGFile.java
trunk/soft/fudaa-crue/fudaa/src/main/java/org/fudaa/fudaa/test/AppCrueTest.java
Added Paths:
-----------
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterCommon.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDCSP.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDFRT.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDPTG.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDPTI.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDRSO.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterETU.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/metier/helper/
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/metier/helper/EMHBrancheHelper.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/metier/helper/EMHCasierHelper.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/metier/helper/EMHNoeudHelper.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/metier/helper/EMHSectionHelper.java
trunk/soft/fudaa-crue/dodico/src/test/java/org/fudaa/dodico/crue/dao/fichierTest/
trunk/soft/fudaa-crue/dodico/src/test/java/org/fudaa/dodico/crue/dao/fichierTest/Etude.etu.xml
Removed Paths:
-------------
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoFactoryCommon.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoFactoryDCSP.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoFactoryDFRT.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoFactoryDPTG.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoFactoryDPTI.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoFactoryDRSO.java
trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoFactoryETU.java
trunk/soft/fudaa-crue/fudaa/src/main/java/org/fudaa/fudaa/test/java/org/fudaa/
Copied: trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterCommon.java (from rev 4607, trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoFactoryCommon.java)
===================================================================
--- trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterCommon.java (rev 0)
+++ trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterCommon.java 2009-04-03 16:08:15 UTC (rev 4611)
@@ -0,0 +1,145 @@
+package org.fudaa.dodico.crue.dao;
+
+import java.util.Date;
+
+import org.fudaa.ctulu.CtuluAnalyze;
+import org.fudaa.dodico.crue.common.CrueResource;
+import org.fudaa.dodico.crue.metier.emh.PtProfil;
+
+/**
+ * Plusieurs m\xE9thodes et classes communes utilis\xE9es pour les factory.
+ *
+ * @author Adrien Hadoux
+ */
+public class CrueDaoConverterCommon {
+
+ public static String VersionCrue = "0.0";
+ public static String Commentaire = "Genere par Fudaa le " + new Date(System.currentTimeMillis());
+
+ // -- listing des diff\xE9rents fichiers et leur noms utilis\xE9s --//
+ public static String ETU = "ETU";
+
+ public static String DRSO = "DRSO";
+ public static String ORES = "ORES";
+ public static String OCAL = "OCAL";
+ public static String PCAL = "PCAL";
+ public static String DCLM = "DCLM";
+ public static String DLHY = "DLHY";
+ public static String OPTR = "OPTR";
+ public static String OPTG = "OPTG";
+ public static String OPTI = "OPTI";
+ public static String PNUM = "PNUM";
+ public static String DPTI = "DPTI";
+ public static String DCSP = "DCSP";
+ public static String DPTG = "DPTG";
+ public static String DFRT = "DFRT";
+ public static String DC = "DC";
+ public static String DH = "DH";
+
+ // -- fichiers de resultats --//
+ public static String FICHIERRESULTAT = "RESULTAT";
+
+ public static String RPTR = "RPTR";
+ public static String RPTG = "RPTG";
+ public static String RPTI = "RPTI";
+ public static String RCAL = "RCAL";
+
+ /**
+ * Construit un ptProfil a partir d'une chaine de caracteres. Utilis\xE9 pour DPTG
+ *
+ * @param buff
+ * @param listeMessageError
+ * @param nameError
+ * @return
+ */
+ public static PtProfil createFormString(final StringBuffer buff, final CtuluAnalyze analyser, final String nameError) {
+ final int indiceCesure = buff.lastIndexOf(" ");
+ final String val1 = buff.substring(0, indiceCesure);
+ final String val2 = buff.substring(indiceCesure + 1, buff.length());
+ double x = 0;
+ try {
+ x = Double.parseDouble(val1);
+
+ } catch (final NumberFormatException e) {
+ analyser.addInfo(CrueResource.getS("Profil: " + nameError + ": impossible de r\xE9cup\xE9rer la lim debut du contenu: "
+ + buff));
+ }
+ double y = 0;
+ try {
+ y = Double.parseDouble(val2);
+ } catch (final NumberFormatException e) {
+ analyser.addInfo(CrueResource.getS("Profil: " + nameError + ": impossible de r\xE9cup\xE9rer la lim debut du contenu: "
+ + buff));
+ }
+
+ final PtProfil profil = new PtProfil(x, y);
+ return profil;
+ }
+
+ public static PtProfil createFormString(final String buff, final CtuluAnalyze analyser, final String nameError) {
+ return createFormString(new StringBuffer(buff), analyser, nameError);
+ }
+
+ /**
+ * Message qui indique la balise n'est pas reconnue par les structures de donn\xE9es EMH.
+ *
+ * @param balise
+ * @param nomRef
+ * @return
+ */
+ public static String unknowEMH(final String balise, final String nomEMH) {
+ return CrueResource.getS(balise + ": Il n'existe pas de structure de donn\xE9e EMH pour l'objet " + nomEMH);
+ }
+
+ public static String unknowdataFromFile(final String balise, final String FileType, final String nomEMH) {
+ return CrueResource.getS(balise + ": Il n'existe pas de structure de donn\xE9e " + FileType + " pour l'objet "
+ + nomEMH);
+ }
+
+ /**
+ * Message qui indique la balise n'est pas reconnue par les structures de donn\xE9es EMH.
+ *
+ * @param balise
+ * @param nomRef
+ * @return
+ */
+ public static String unknowReference(final String balise, final String nomRef) {
+ return CrueResource.getS(balise + ": Impossible de trouver " + balise + " de r\xE9f\xE9rence " + nomRef);
+
+ }
+
+ /**
+ * Envoie un message formatt\xE9 pour une erreur de doublons d'id
+ *
+ * @param balise
+ * @param nomRef
+ * @return
+ */
+ public static String errorIdNonUnique(final String balise, final String nomRef) {
+ return CrueResource.getS("<" + balise + ">: l'id " + nomRef + " est en doublon, il ne sera donc pas ");
+
+ }
+
+ public static String messageBaliseError(final String balise, final String message) {
+ return CrueResource.getS(balise + ": " + message);
+
+ }
+
+ /**
+ * Message qui indique la balise n'est pas reconnue par les structures de donn\xE9es EMH.
+ *
+ * @param balise
+ * @param nomRef
+ * @return
+ */
+ public static String listEmpty(final String balise) {
+ return CrueResource.getS("Sections <" + balise + ">: la liste est vide.");
+
+ }
+
+ public static String emhEmpty(final String balise) {
+ return CrueResource.getS("EMH: Aucune donn\xE9es EMH trouv\xE9e pour <" + balise + ">.");
+
+ }
+
+}
Property changes on: trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterCommon.java
___________________________________________________________________
Added: svn:mergeinfo
+
Copied: trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDCSP.java (from rev 4607, trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoFactoryDCSP.java)
===================================================================
--- trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDCSP.java (rev 0)
+++ trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDCSP.java 2009-04-03 16:08:15 UTC (rev 4611)
@@ -0,0 +1,670 @@
+package org.fudaa.dodico.crue.dao;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.fudaa.ctulu.CtuluAnalyze;
+import org.fudaa.dodico.crue.common.CrueResource;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.BrancheAbstract;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.BrancheBarrageFilEau;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.BrancheBarrageFilEauAbstract;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.BrancheBarrageGenerique;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.BrancheBarrageRhone;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.BrancheClassiqueAbstract;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.BrancheOrifice;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.BranchePDCAbstract;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.BranchePdc;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.BrancheSaintVenant;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.BrancheSeuilAbstract;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.BrancheSeuilLateral;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.BrancheSeuilOrificeAbstract;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.BrancheSeuilTransversal;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.ElemSeuil;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.ElemSeuilOrifice;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.ElemSeuilPdc;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.SectionBrancheAbstract;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.SectionIdem;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.SectionInterpolee;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.SectionProfil;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDCSP.SectionSansGeometrie;
+import org.fudaa.dodico.crue.metier.emh.CatEMHBranche;
+import org.fudaa.dodico.crue.metier.emh.CatEMHSection;
+import org.fudaa.dodico.crue.metier.emh.DonCalcSansPrt;
+import org.fudaa.dodico.crue.metier.emh.DonCalcSansPrtBarrageFilEau;
+import org.fudaa.dodico.crue.metier.emh.DonCalcSansPrtBrancheOrifice;
+import org.fudaa.dodico.crue.metier.emh.DonCalcSansPrtBranchePDC;
+import org.fudaa.dodico.crue.metier.emh.DonCalcSansPrtBrancheSaintVenant;
+import org.fudaa.dodico.crue.metier.emh.DonCalcSansPrtBrancheSeuilLateral;
+import org.fudaa.dodico.crue.metier.emh.DonCalcSansPrtBrancheSeuilTransversal;
+import org.fudaa.dodico.crue.metier.emh.DonCalcSansPrtSection;
+import org.fudaa.dodico.crue.metier.emh.EMH;
+import org.fudaa.dodico.crue.metier.emh.EMHBrancheBarrageFilEau;
+import org.fudaa.dodico.crue.metier.emh.EMHBrancheBarrageGenerique;
+import org.fudaa.dodico.crue.metier.emh.EMHBrancheBarrageRhone;
+import org.fudaa.dodico.crue.metier.emh.EMHBrancheOrifice;
+import org.fudaa.dodico.crue.metier.emh.EMHBranchePdc;
+import org.fudaa.dodico.crue.metier.emh.EMHBrancheSaintVenant;
+import org.fudaa.dodico.crue.metier.emh.EMHBrancheSeuilLongitudinale;
+import org.fudaa.dodico.crue.metier.emh.EMHBrancheSeuilTransversal;
+import org.fudaa.dodico.crue.metier.emh.EMHSectionIdem;
+import org.fudaa.dodico.crue.metier.emh.EMHSectionInterpolee;
+import org.fudaa.dodico.crue.metier.emh.EMHSectionProfil;
+import org.fudaa.dodico.crue.metier.emh.EMHSectionSansGeometrie;
+import org.fudaa.dodico.crue.metier.emh.ElemSeuilAvecPdc;
+import org.fudaa.dodico.crue.metier.emh.Loi;
+import org.fudaa.dodico.crue.metier.helper.EMHBrancheHelper;
+import org.fudaa.dodico.crue.metier.helper.EMHSectionHelper;
+
+/**
+ * Factory qui se charge de remplir les structures DAO du ficheir DCSP avec les donn\xE9es m\xE9tier et inversement.
+ *
+ * @author Adrien Hadoux
+ */
+public class CrueDaoConverterDCSP {
+
+ public static int cptEntries = 1;
+
+ /**
+ * Remplit completement la structure persistante a partir des objets DSCP. Optimise le remplissage en listante les
+ * donn\xE9es emh une seule fois et en forwardant les objets aux bons endroits
+ *
+ * @param persistance
+ * @param data
+ * @param listeMessageError
+ */
+ public static void remplirPersistanceDCSP(final CrueDaoPersistDCSP persistance, final List<EMH> data,
+ final CtuluAnalyze analyser) {
+
+ persistance.Sections = new ArrayList<SectionBrancheAbstract>();
+ persistance.Branches = new ArrayList<BrancheAbstract>();
+
+ // CrueDaoFactoryDCSP.remplirPersistanceAvecBrancheDSCP(persistance.Branches,data,listeMessageError);
+
+ if (data == null || data.size() == 0) {
+ analyser.addError(CrueDaoConverterCommon.emhEmpty(CrueDaoConverterCommon.DCSP), cptEntries++);
+ } else for (final EMH emh : data) {
+ if (emh instanceof CatEMHBranche) {
+ // -- remplissage des sections de branches --//
+ final CatEMHBranche branche = (CatEMHBranche) emh;
+
+ final List<DonCalcSansPrt> listeDoncalc = branche.getDSCP();
+ for (final DonCalcSansPrt dataCalc : listeDoncalc) {
+ if (dataCalc != null) {
+ CrueDaoConverterDCSP.remplirPersistanceAvecBrancheDSCP(persistance.Branches, branche, dataCalc, analyser);
+ } else {
+ analyser.addError(CrueDaoConverterCommon.unknowdataFromFile("Branches", CrueDaoConverterCommon.DCSP, branche
+ .getNom()), cptEntries++);
+ }
+ }
+
+ } else if (emh instanceof CatEMHSection) {
+ final CatEMHSection section = (CatEMHSection) emh;
+ final List<DonCalcSansPrt> listeDoncalc = section.getDSCP();
+ for (final DonCalcSansPrt dataCalc : listeDoncalc) {
+ if (dataCalc != null && dataCalc instanceof DonCalcSansPrtSection) {
+ // -- remplissage des sections --//
+ remplirPersistanceAvecSectionsBrancheDSCP(persistance.Sections, section, (DonCalcSansPrtSection) dataCalc,
+ analyser);
+
+ } else {
+ analyser.addError(CrueDaoConverterCommon.unknowdataFromFile("Section", CrueDaoConverterCommon.DCSP, section
+ .getNom()), cptEntries++);
+ }
+
+ }
+
+ }
+
+ }
+
+ }
+
+ /**
+ * Remplit completement la structure metier a partir des objets persistants DSCP. Optimise le remplissage en listante
+ * les donn\xE9es emh une seule fois et en forwardant les objets aux bons endroits
+ *
+ * @param persistance
+ * @param data
+ * @param analyser
+ */
+ public static void remplirMetierDCSP(final CrueDaoPersistDCSP persistance, final List<EMH> data,
+ final CtuluAnalyze analyser) {
+
+ // -- remplissage des branches --//
+ CrueDaoConverterDCSP.remplirBrancheAvecPersistanceDSCP(persistance.Branches, data, analyser);
+
+ // -- remplissage des sections --//
+ CrueDaoConverterDCSP.remplirSectionsAvecPersistanceDSCP(persistance.Sections, data, analyser);
+
+ }
+
+ /**
+ * Methode qui remplit une arrayList d'objets persistants qui constituent le fichier fichier DSCP: les Branches.
+ *
+ * @param data
+ * @return
+ */
+ public static void remplirPersistanceAvecBrancheDSCP(final List<BrancheAbstract> listePersistante,
+ final CatEMHBranche branche, final DonCalcSansPrt dataCalc, final CtuluAnalyze analyser) {
+ final String suffixe = CrueDaoPersistDRSO.SUFFIXE_REF_DRSO;
+ BrancheAbstract branchePersist = null;
+ if (branche instanceof EMHBrancheBarrageFilEau) {
+ final EMHBrancheBarrageFilEau new_name = (EMHBrancheBarrageFilEau) branche;
+ branchePersist = new BrancheBarrageFilEau();
+
+ if (dataCalc instanceof DonCalcSansPrtBarrageFilEau) {
+ final BrancheBarrageFilEau br = (BrancheBarrageFilEau) branchePersist;
+
+ // -- recuperation de la formule --//
+ if (((DonCalcSansPrtBarrageFilEau) dataCalc).getRegimeDenove_Zam() != null) br.Loi = ((DonCalcSansPrtBarrageFilEau) dataCalc)
+ .getRegimeDenove_Zam().getNom();
+ br.QLimInf = ((DonCalcSansPrtBarrageFilEau) dataCalc).getQLimInf();
+ br.QLimSup = ((DonCalcSansPrtBarrageFilEau) dataCalc).getQLimSup();
+ // -- on remplit la liste des elements seuils --//
+
+ br.ElemSeuils = remplirPersistanceAvecSeuilsBarragesDSCP(((DonCalcSansPrtBarrageFilEau) dataCalc).getListElt());
+
+ } else {
+ analyser
+ .addError(
+ CrueResource
+ .getS("Branche : Donnee DSCP incorrecte (attendu. donnees branche barrage Fil d'eau) pour l'objet branche de r\xE9f\xE9rence"
+ + branche.getNom()), cptEntries++);
+ }
+
+ } else if (branche instanceof EMHBrancheBarrageGenerique) {
+ final EMHBrancheBarrageGenerique new_name = (EMHBrancheBarrageGenerique) branche;
+ branchePersist = new BrancheBarrageGenerique();
+ // -- recuperation de la donnee de calcul de la branche --//
+ if (dataCalc instanceof DonCalcSansPrtBarrageFilEau) {
+ final BrancheBarrageGenerique br = (BrancheBarrageGenerique) branchePersist;
+
+ // -- recuperation de la formule --//
+ if (((DonCalcSansPrtBarrageFilEau) dataCalc).getRegimeDenove_Zam() != null) br.Loi = ((DonCalcSansPrtBarrageFilEau) dataCalc)
+ .getRegimeDenove_Zam().getNom();
+ br.QLimInf = ((DonCalcSansPrtBarrageFilEau) dataCalc).getQLimInf();
+ br.QLimSup = ((DonCalcSansPrtBarrageFilEau) dataCalc).getQLimSup();
+ // -- on remplit la liste des elements seuils --//
+
+ br.ElemSeuils = remplirPersistanceAvecSeuilsBarragesDSCP(((DonCalcSansPrtBarrageFilEau) dataCalc).getListElt());
+
+ } else {
+ analyser
+ .addError(
+ CrueResource
+ .getS("Branche : Donnee DSCP incorrecte (attendu. donnees branche barrage Generique) pour l'objet branche de r\xE9f\xE9rence"
+ + branche.getNom()), cptEntries++);
+ }
+
+ } else if (branche instanceof EMHBrancheBarrageRhone) {
+ final EMHBrancheBarrageRhone new_name = (EMHBrancheBarrageRhone) branche;
+ branchePersist = new BrancheBarrageRhone();
+ // -- recuperation de la donnee de calcul de la branche --//
+
+ if (dataCalc instanceof DonCalcSansPrtBarrageFilEau) {
+ final BrancheBarrageRhone br = (BrancheBarrageRhone) branchePersist;
+
+ // -- recuperation de la formule --//
+ if (((DonCalcSansPrtBarrageFilEau) dataCalc).getRegimeDenove_Zam() != null) br.Loi = ((DonCalcSansPrtBarrageFilEau) dataCalc)
+ .getRegimeDenove_Zam().getNom();
+ br.QLimInf = ((DonCalcSansPrtBarrageFilEau) dataCalc).getQLimInf();
+ br.QLimSup = ((DonCalcSansPrtBarrageFilEau) dataCalc).getQLimSup();
+ // -- on remplit la liste des elements seuils --//
+
+ br.ElemSeuils = remplirPersistanceAvecSeuilsBarragesDSCP(((DonCalcSansPrtBarrageFilEau) dataCalc).getListElt());
+
+ } else {
+ analyser
+ .addError(
+ CrueResource
+ .getS("Branche : Donnee DSCP incorrecte (attendu. donnees branche barrage Rhone) pour l'objet branche de r\xE9f\xE9rence"
+ + branche.getNom()), cptEntries++);
+ }
+
+ }
+ // else if (branche instanceof EMHBrancheBarrageRhone) {
+ // EMHBrancheBarrageRhone new_name = (EMHBrancheBarrageRhone) branche;
+ // branchePersist=new main.java.org.fudaa.dodico.crue.dao.DaoStructuresFormatDSCP.BrancheBarrageRhone();
+ // }
+ // else if (branche instanceof EMHBrancheEnchainement) {
+ // EMHBrancheEnchainement new_name = (EMHBrancheEnchainement) branche;
+ // branchePersist=new main.java.org.fudaa.dodico.crue.dao.DaoStructuresFormatDSCP.BrancheEnchainement();
+ // }else if (branche instanceof EMHBrancheNiveauxAssocies) {
+ // EMHBrancheNiveauxAssocies new_name = (EMHBrancheNiveauxAssocies) branche;
+ // branchePersist=new main.java.org.fudaa.dodico.crue.dao.DaoStructuresFormatDSCP.BrancheNiveauxAssocies();
+ // }
+ else if (branche instanceof EMHBrancheOrifice) {
+
+ branchePersist = new BrancheOrifice();
+
+ // -- recuperation de la donnee de calcul de la branche --//
+
+ if (dataCalc instanceof DonCalcSansPrtBrancheOrifice) {
+ final BrancheOrifice br = (BrancheOrifice) branchePersist;
+
+ // -- recuperation de la formule --//
+ br.FormulePdc = ((DonCalcSansPrtBrancheOrifice) dataCalc).getFormulePdc();
+ // -- on remplit la liste des elements seuils --//
+ br.ElemOrifices = remplirPersistanceAvecOrificesSeuilsDSCP(((DonCalcSansPrtBrancheOrifice) dataCalc)
+ .getElement());
+ } else {
+ analyser
+ .addError(
+ CrueResource
+ .getS("Branche : Donnee DSCP incorrecte (attendu. donnees branche Orifice) pour l'objet branche de r\xE9f\xE9rence"
+ + branche.getNom()), cptEntries++);
+ }
+
+ } else if (branche instanceof EMHBranchePdc) {
+ final EMHBranchePdc new_name = (EMHBranchePdc) branche;
+ branchePersist = new BranchePdc();
+
+ // -- recuperation de la donnee de calcul de la branche --//
+
+ if (dataCalc instanceof DonCalcSansPrtBranchePDC) {
+ final BranchePdc br = (BranchePdc) branchePersist;
+
+ // -- recuperation de la formule --//
+ if (((DonCalcSansPrtBranchePDC) dataCalc).getPdc_DZ() != null) br.Loi = ((DonCalcSansPrtBranchePDC) dataCalc)
+ .getPdc_DZ().getNom();
+
+ } else {
+ analyser
+ .addError(
+ CrueResource
+ .getS("Branche : Donnee DSCP incorrecte (attendu. donnees branche seuil Longitudinal) pour l'objet branche de r\xE9f\xE9rence"
+ + branche.getNom()), cptEntries++);
+ }
+
+ } else if (branche instanceof EMHBrancheSaintVenant) {
+ final EMHBrancheSaintVenant new_name = (EMHBrancheSaintVenant) branche;
+ branchePersist = new BrancheSaintVenant();
+ // -- recuperation de la donnee de calcul de la branche --//
+
+ if (dataCalc instanceof DonCalcSansPrtBrancheSaintVenant) {
+ final BrancheClassiqueAbstract br = (BrancheClassiqueAbstract) branchePersist;
+
+ br.CoefBeta = ((DonCalcSansPrtBrancheSaintVenant) dataCalc).getCoeffBeta();
+ br.CoefRuis = ((DonCalcSansPrtBrancheSaintVenant) dataCalc).getCoefRuis();
+ br.CoefRuisQdm = ((DonCalcSansPrtBrancheSaintVenant) dataCalc).getCoeffRuisQdm();
+
+ // //-- remplissage des sections de branches --//
+ // br.Sections=remplirPersistanceAvecSectionsBrancheDSCP( branche.getListeSections(), analyser);
+ } else {
+ analyser
+ .addError(
+ CrueResource
+ .getS("Branche : Donnee DSCP incorrecte (attendu. donnees branche SaintVenant) pour l'objet branche de r\xE9f\xE9rence"
+ + branche.getNom()), cptEntries++);
+ }
+
+ } else if (branche instanceof EMHBrancheSeuilLongitudinale) {
+ final EMHBrancheSeuilLongitudinale new_name = (EMHBrancheSeuilLongitudinale) branche;
+ branchePersist = new BrancheSeuilLateral();
+
+ // -- recuperation de la donnee de calcul de la branche --//
+
+ if (dataCalc instanceof DonCalcSansPrtBrancheSeuilLateral) {
+ final BrancheSeuilLateral br = (BrancheSeuilLateral) branchePersist;
+
+ // -- recuperation de la formule --//
+ br.FormulePdc = ((DonCalcSansPrtBrancheSeuilLateral) dataCalc).getFormulePdc();
+ // -- on remplit la liste des elements seuils --//
+ br.ElemSeuils = remplirPersistanceAvecSeuilsDSCP(((DonCalcSansPrtBrancheSeuilLateral) dataCalc).getListElt());
+
+ } else {
+ analyser
+ .addError(
+ CrueResource
+ .getS("Branche : Donnee DSCP incorrecte (attendu. donnees branche seuil Longitudinal) pour l'objet branche de r\xE9f\xE9rence"
+ + branche.getNom()), cptEntries++);
+ }
+
+ } else if (branche instanceof EMHBrancheSeuilTransversal) {
+ final EMHBrancheSeuilTransversal new_name = (EMHBrancheSeuilTransversal) branche;
+ branchePersist = new BrancheSeuilTransversal();
+
+ // -- recuperation de la donnee de calcul de la branche --//
+
+ if (dataCalc instanceof DonCalcSansPrtBrancheSeuilTransversal) {
+ final BrancheSeuilTransversal br = (BrancheSeuilTransversal) branchePersist;
+ // -- recuperation de la formule --//
+ br.FormulePdc = ((DonCalcSansPrtBrancheSeuilTransversal) dataCalc).getFormulePdc();
+ // -- on remplit la liste des elements seuils --//
+ br.ElemSeuils = remplirPersistanceAvecSeuilsDSCP(((DonCalcSansPrtBrancheSeuilTransversal) dataCalc)
+ .getListElt());
+ } else {
+ analyser
+ .addError(
+ CrueResource
+ .getS("Branche : Donnee DSCP incorrecte (attendu. donnees branche seuil transversal) pour l'objet branche de r\xE9f\xE9rence"
+ + branche.getNom()), cptEntries++);
+ }
+
+ }
+ // else if (branche instanceof EMHBrancheStrickler) {
+ // EMHBrancheStrickler new_name = (EMHBrancheStrickler) branche;
+ // branchePersist=new main.java.org.fudaa.dodico.crue.dao.DaoStructuresFormatDSCP.BrancheStrickler();
+ // }
+
+ if (branchePersist != null) {
+ branchePersist.NomRef = suffixe + branche.getNom();
+
+ listePersistante.add(branchePersist);
+ } else {
+ analyser.addError(CrueDaoConverterCommon.unknowEMH("Branche", branche.getNom()), cptEntries++);
+ }
+
+ }
+
+ /**
+ * Genere une liste d'elements seuils persistante a partir de la liste m\xE9tier lue.
+ *
+ * @param listeEltSeuilsPersist
+ * @return
+ */
+ public static List<ElemSeuilPdc> remplirPersistanceAvecSeuilsDSCP(final List<ElemSeuilAvecPdc> listeEltSeuilsEMH) {
+ final List<ElemSeuilPdc> listeSeuilsPersist = new ArrayList<ElemSeuilPdc>();
+ for (final ElemSeuilAvecPdc seuilMetier : listeEltSeuilsEMH) {
+ final ElemSeuilPdc seuilPersist = new ElemSeuilPdc();
+ seuilPersist.CoefD = seuilMetier.getCoeffD();
+ seuilPersist.CoefPdc = seuilMetier.getCoeffPdc();
+ seuilPersist.Larg = seuilMetier.getLarg();
+ seuilPersist.Zseuil = seuilMetier.getZSeuil();
+
+ listeSeuilsPersist.add(seuilPersist);
+ }
+
+ return listeSeuilsPersist;
+ }
+
+ /**
+ * Genere une liste d'elements seuils persistante a partir de la liste m\xE9tier lue.
+ *
+ * @param listeEltSeuilsPersist
+ * @return
+ */
+ public static List<ElemSeuil> remplirPersistanceAvecSeuilsBarragesDSCP(
+ final List<org.fudaa.dodico.crue.metier.emh.ElemSeuil> listeEltSeuilsEMH) {
+ final List<ElemSeuil> listeSeuilsPersist = new ArrayList<ElemSeuil>();
+ for (final org.fudaa.dodico.crue.metier.emh.ElemSeuil seuilMetier : listeEltSeuilsEMH) {
+ final ElemSeuil seuilPersist = new ElemSeuil();
+ seuilPersist.CoefD = seuilMetier.getCoeffD();
+
+ seuilPersist.Larg = seuilMetier.getLarg();
+ seuilPersist.Zseuil = seuilMetier.getZSeuil();
+
+ listeSeuilsPersist.add(seuilPersist);
+ }
+
+ return listeSeuilsPersist;
+ }
+
+ /**
+ * Genere une liste d'elements seuils persistante a partir de la liste metier lue.
+ *
+ * @param listeEltSeuilsPersist
+ * @return
+ */
+ public static List<ElemSeuilOrifice> remplirPersistanceAvecOrificesSeuilsDSCP(
+ final List<org.fudaa.dodico.crue.metier.emh.ElemOrifice> listeEMhSeuils) {
+ final List<ElemSeuilOrifice> listeEltSeuilsPersist = new ArrayList<ElemSeuilOrifice>();
+ for (final org.fudaa.dodico.crue.metier.emh.ElemOrifice seuilMetier : listeEMhSeuils) {
+ final ElemSeuilOrifice seuilPersist = new ElemSeuilOrifice();
+ seuilPersist.CoefD = seuilMetier.getCoeffQ();
+ seuilPersist.Larg = seuilMetier.getLarg();
+ seuilPersist.Zseuil = seuilMetier.getZSeuil();
+
+ seuilPersist.CoefCtrLim = seuilMetier.getCoeffCtrLim();
+ seuilPersist.Sens = seuilMetier.getSens();
+
+ listeEltSeuilsPersist.add(seuilPersist);
+ }
+
+ return listeEltSeuilsPersist;
+ }
+
+ /**
+ * Methode qui remplit une arrayList d'objets persistants Sections qui sont contenues dans une branche: concerne le
+ * fichier fichier DSCP: les Branches.
+ *
+ * @param data
+ * @return
+ */
+ public static void remplirPersistanceAvecSectionsBrancheDSCP(final List<SectionBrancheAbstract> listePersistante,
+ final CatEMHSection section, final DonCalcSansPrtSection prtSection, final CtuluAnalyze analyser) {
+
+ SectionBrancheAbstract sectionPersist = null;
+ if (section instanceof EMHSectionIdem) {
+ sectionPersist = new SectionIdem();
+ } else if (section instanceof EMHSectionInterpolee) {
+ sectionPersist = new SectionInterpolee();
+ } else if (section instanceof EMHSectionProfil) {
+ sectionPersist = new SectionProfil();
+ } else if (section instanceof EMHSectionSansGeometrie) {
+ sectionPersist = new SectionSansGeometrie();
+ }
+
+ if (section.getDataCalcul() != null) {
+ sectionPersist.NomRef = CrueDaoPersistDRSO.SUFFIXE_REF_DRSO + section.getNom();
+ sectionPersist.CoefConv = prtSection.getCoeffConv();
+ sectionPersist.CoefDiv = prtSection.getCoeffDiv();
+ sectionPersist.CoefPond = prtSection.getCoeffPond();
+ }
+
+ listePersistante.add(sectionPersist);
+
+ }
+
+ /**
+ * Methode qui met a jour les objets m\xE9tier EMH branches a partir des donn\xE9es persistantes de DPTI et les
+ * pr\xE9chargements de DRSO
+ *
+ * @param data
+ * @return
+ */
+ public static void remplirBrancheAvecPersistanceDSCP(final List<BrancheAbstract> listePersistants,
+ final List<EMH> data, final CtuluAnalyze analyser) {
+ if (listePersistants == null || listePersistants.size() == 0) {
+ analyser.addError(CrueResource.getS("Branches: la liste est vide."), cptEntries++);
+ } else for (final Object persist : listePersistants) {
+ if (persist instanceof BrancheAbstract) {
+ final BrancheAbstract branchePersist = (BrancheAbstract) persist;
+ String reference = branchePersist.NomRef;
+ if (reference.contains(CrueDaoPersistDRSO.SUFFIXE_REF_DRSO)) {
+ reference = reference.replace(CrueDaoPersistDRSO.SUFFIXE_REF_DRSO, "");
+ }
+ final CatEMHBranche branche = EMHBrancheHelper.findByReference(reference, data);
+ if (branche == null) {
+ analyser.addError(CrueResource.getS("Branche : Impossible de trouver la branche de r\xE9f\xE9rence " + reference),
+ cptEntries++);
+ } else {
+ if (branchePersist instanceof BrancheClassiqueAbstract) {
+ final BrancheClassiqueAbstract br = (BrancheClassiqueAbstract) branchePersist;
+ final DonCalcSansPrtBrancheSaintVenant dataCalcul = new DonCalcSansPrtBrancheSaintVenant();
+ dataCalcul.setCoeffBeta(br.CoefBeta);
+ dataCalcul.setCoefRuis(br.CoefRuis);
+ dataCalcul.setCoeffRuisQdm(br.CoefRuisQdm);
+ branche.addDSCP(dataCalcul);
+ // -- remplissage des sections --//
+ // remplirSectionsAvecPersistanceDSCP(br.Sections, branche, analyser);
+ }
+ // -- branche seuil --//
+ else if (branchePersist instanceof BrancheSeuilAbstract) {
+ final BrancheSeuilAbstract br = (BrancheSeuilAbstract) branchePersist;
+
+ if ((branche instanceof EMHBrancheSeuilLongitudinale)) {
+ final DonCalcSansPrtBrancheSeuilLateral dataCalcul = new DonCalcSansPrtBrancheSeuilLateral();
+
+ // -- recuperation de la formule --//
+ dataCalcul.setFormulePdc(br.FormulePdc);
+ // -- on remplit la liste des elements seuils --//
+ dataCalcul.setListElt(remplirSeuilsAvecPersistanceDSCP(br.ElemSeuils));
+ branche.addDSCP(dataCalcul);
+ } else if ((branche instanceof EMHBrancheSeuilTransversal)) {
+ final DonCalcSansPrtBrancheSeuilTransversal dataCalcul = new DonCalcSansPrtBrancheSeuilTransversal();
+
+ // -- recuperation de la formule --//
+ dataCalcul.setFormulePdc(br.FormulePdc);
+ // -- on remplit la liste des elements seuils --//
+ dataCalcul.setListElt(remplirSeuilsAvecPersistanceDSCP(br.ElemSeuils));
+ branche.addDSCP(dataCalcul);
+ } else {
+ analyser.addError(CrueResource.getS("Branche : Les donnees de la branche de r\xE9f\xE9rence " + reference
+ + " doivent \xEAtre de type Transversal ou Longitudinal (liste de seuils+ formule pdc)"), cptEntries++);
+ }
+
+ }
+ // -- branche seuils orifices --//
+ else if (branchePersist instanceof BrancheSeuilOrificeAbstract) {
+ final BrancheSeuilOrificeAbstract br = (BrancheSeuilOrificeAbstract) branchePersist;
+ final DonCalcSansPrtBrancheOrifice dataCalcul = new DonCalcSansPrtBrancheOrifice();
+ // -- recuperation de la formule --//
+ dataCalcul.setFormulePdc(br.FormulePdc);
+ // -- on remplit la liste des elements seuils --//
+ dataCalcul.setElement(remplirOrificesSeuilsAvecPersistanceDSCP(br.ElemOrifices));
+ branche.addDSCP(dataCalcul);
+ }
+ // -- branche seuils PDC --//
+ else if (branchePersist instanceof BranchePDCAbstract) {
+ final BranchePDCAbstract br = (BranchePDCAbstract) branchePersist;
+ final DonCalcSansPrtBranchePDC dataCalcul = new DonCalcSansPrtBranchePDC();
+ // -- recuperation de la formule --//
+ final Loi newLoi = new Loi();
+ newLoi.setNom(br.Loi);
+ dataCalcul.setPdc_DZ(newLoi);
+ branche.addDSCP(dataCalcul);
+ } else if (branchePersist instanceof BrancheBarrageFilEauAbstract) {
+ final BrancheBarrageFilEauAbstract br = (BrancheBarrageFilEauAbstract) branchePersist;
+ final DonCalcSansPrtBarrageFilEau dataCalcul = new DonCalcSansPrtBarrageFilEau();
+
+ // -- recuperation de la formule --//
+ final Loi newLoi = new Loi();
+ newLoi.setNom(br.Loi);
+ dataCalcul.setRegimeDenove_Zam(newLoi);
+ dataCalcul.setQLimInf(br.QLimInf);
+ dataCalcul.setQLimSup(br.QLimSup);
+
+ // -- on remplit la liste des elements seuils --//
+ dataCalcul.setListElt(remplirSeuilsBarragesAvecPersistanceDSCP(br.ElemSeuils));
+ branche.addDSCP(dataCalcul);
+
+ }
+
+ else {
+ analyser.addError(CrueResource.getS("Branche : Donn\xE9es non correcte. La branche de r\xE9f\xE9rence " + reference
+ + " contient des \xE9l\xE9ments de calcul innatendu."), cptEntries++);
+ }
+ }
+
+ }
+ }
+
+ }
+
+ /**
+ * Genere une liste d'elements seuils persistante a partir de la liste m\xE9tier lue.
+ *
+ * @param listeEltSeuilsPersist
+ * @return
+ */
+ public static List<ElemSeuilAvecPdc> remplirSeuilsAvecPersistanceDSCP(final List<ElemSeuilPdc> listeSeuilsPersist) {
+ final List<ElemSeuilAvecPdc> listeEltSeuilsEMH = new ArrayList<ElemSeuilAvecPdc>();
+ for (final ElemSeuilPdc seuilPersist : listeSeuilsPersist) {
+ final ElemSeuilAvecPdc seuilMetier = new ElemSeuilAvecPdc();
+ seuilMetier.setCoeffD(seuilPersist.CoefD);
+ seuilMetier.setCoeffPdc(seuilPersist.CoefPdc);
+ seuilMetier.setLarg(seuilPersist.Larg);
+ seuilMetier.setZSeuil(seuilPersist.Zseuil);
+
+ listeEltSeuilsEMH.add(seuilMetier);
+ }
+
+ return listeEltSeuilsEMH;
+ }
+
+ /**
+ * Genere une liste d'elements seuils persistante a partir de la liste m\xE9tier lue.
+ *
+ * @param listeEltSeuilsPersist
+ * @return
+ */
+ public static List<org.fudaa.dodico.crue.metier.emh.ElemSeuil> remplirSeuilsBarragesAvecPersistanceDSCP(
+ final List<ElemSeuil> listeSeuilsPersist) {
+ final List<org.fudaa.dodico.crue.metier.emh.ElemSeuil> listeEltSeuilsEMH = new ArrayList<org.fudaa.dodico.crue.metier.emh.ElemSeuil>();
+ for (final ElemSeuil seuilPersist : listeSeuilsPersist) {
+ final org.fudaa.dodico.crue.metier.emh.ElemSeuil seuilMetier = new org.fudaa.dodico.crue.metier.emh.ElemSeuil();
+ seuilMetier.setCoeffD(seuilPersist.CoefD);
+
+ seuilMetier.setLarg(seuilPersist.Larg);
+ seuilMetier.setZSeuil(seuilPersist.Zseuil);
+
+ listeEltSeuilsEMH.add(seuilMetier);
+ }
+
+ return listeEltSeuilsEMH;
+ }
+
+ /**
+ * Genere une liste d'elements seuils m\xE9tier a partir de la liste persistante lue.
+ *
+ * @param listeEltSeuilsPersist
+ * @return
+ */
+ public static List<org.fudaa.dodico.crue.metier.emh.ElemOrifice> remplirOrificesSeuilsAvecPersistanceDSCP(
+ final List<ElemSeuilOrifice> listeEltSeuilsPersist) {
+ final List<org.fudaa.dodico.crue.metier.emh.ElemOrifice> listeEMhSeuils = new ArrayList<org.fudaa.dodico.crue.metier.emh.ElemOrifice>();
+ for (final ElemSeuilOrifice seuilPersist : listeEltSeuilsPersist) {
+ final org.fudaa.dodico.crue.metier.emh.ElemOrifice seuilMetier = new org.fudaa.dodico.crue.metier.emh.ElemOrifice();
+ seuilMetier.setCoeffQ(seuilPersist.CoefD);
+ seuilMetier.setLarg(seuilPersist.Larg);
+ seuilMetier.setZSeuil(seuilPersist.Zseuil);
+
+ seuilMetier.setCoeffCtrLim(seuilPersist.CoefCtrLim);
+ seuilMetier.setSens(seuilPersist.Sens);
+
+ listeEMhSeuils.add(seuilMetier);
+ }
+
+ return listeEMhSeuils;
+ }
+
+ /**
+ * Methode qui met a jour les objets m\xE9tier EMH sections de branches a partir des donn\xE9es persistantes qui constituent
+ * a quatrieme partie du fichier DSCP: les Sections.
+ *
+ * @param data
+ * @return
+ */
+ public static void remplirSectionsAvecPersistanceDSCP(final List<SectionBrancheAbstract> listePersistantsSection,
+ final List<EMH> data, final CtuluAnalyze analyser) {
+
+ if (listePersistantsSection == null || listePersistantsSection.size() == 0) {
+ analyser.addError(CrueResource.getS("Sections : la liste est vide."), cptEntries++);
+ } else for (final Object persist : listePersistantsSection) {
+ if (persist instanceof SectionBrancheAbstract) {
+ final SectionBrancheAbstract sectionPersist = (SectionBrancheAbstract) persist;
+
+ // -- on d\xE9clare une version abstraite EMH m\xE9tier du type --//
+ CatEMHSection section = null;
+ String reference = sectionPersist.NomRef;
+
+ if (reference.contains(CrueDaoPersistDRSO.SUFFIXE_REF_DRSO)) {
+ reference = reference.replace(CrueDaoPersistDRSO.SUFFIXE_REF_DRSO, "");
+ }
+ section = EMHSectionHelper.findByReference(reference, data);
+
+ if (section != null) {
+ final DonCalcSansPrtSection dataCalcul = new DonCalcSansPrtSection();
+
+ dataCalcul.setCoeffConv(sectionPersist.CoefConv);
+ dataCalcul.setCoeffDiv(sectionPersist.CoefDiv);
+ dataCalcul.setCoeffPond(sectionPersist.CoefPond);
+ section.addDSCP(dataCalcul);
+ } else analyser.addError(CrueDaoConverterCommon.unknowReference("Section", reference), cptEntries++);
+ }
+ }
+
+ }
+
+}
Property changes on: trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDCSP.java
___________________________________________________________________
Added: svn:mergeinfo
+
Copied: trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDFRT.java (from rev 4607, trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoFactoryDFRT.java)
===================================================================
--- trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDFRT.java (rev 0)
+++ trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDFRT.java 2009-04-03 16:08:15 UTC (rev 4611)
@@ -0,0 +1,112 @@
+package org.fudaa.dodico.crue.dao;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.fudaa.ctulu.CtuluAnalyze;
+import org.fudaa.dodico.crue.common.CrueResource;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDFRT.StriRefCPersist;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDFRT.StriRefHPersist;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDFRT.StriRefPersist;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDFRT.StriRefZPersist;
+import org.fudaa.dodico.crue.metier.emh.DonFrt;
+import org.fudaa.dodico.crue.metier.emh.FrottementPoint;
+import org.fudaa.dodico.crue.metier.emh.StriRefC;
+import org.fudaa.dodico.crue.metier.emh.StriRefH;
+import org.fudaa.dodico.crue.metier.emh.StriRefZ;
+
+/**
+ * Factory qui se charge de remplir les structures DAO dufichier DFRT avec les donn\xE9es m\xE9tier et inversement.
+ *
+ * @author Adrien Hadoux
+ */
+public class CrueDaoConverterDFRT {
+
+ public static int cptEntries = 1;
+
+ /**
+ * remplir le fichier DFRT avec les frottemetns
+ *
+ * @param data
+ * @return
+ */
+ public static List<StriRefPersist> remplirPersistanceAvecFrottemetnsDFRT(final List<DonFrt> data,
+ final CtuluAnalyze analyser) {
+ final List<StriRefPersist> listeFrottement = new ArrayList<StriRefPersist>();
+ for (final DonFrt frt : data) {
+ StriRefPersist persist = null;
+ if (frt instanceof StriRefC) persist = new StriRefCPersist(frt.getNom());
+ else if (frt instanceof StriRefH) persist = new StriRefHPersist(frt.getNom());
+ else if (frt instanceof StriRefZ) persist = new StriRefZPersist(frt.getNom());
+
+ // -- commun --//
+ if (persist != null) {
+ if (frt.getListePoints() != null && frt.getListePoints().size() > 0) {
+ persist.listePoints = new ArrayList<String>();
+ for (final FrottementPoint pt : frt.getListePoints()) {
+ persist.listePoints.add(pt.getX() + " " + pt.getY());
+ }
+ }
+ listeFrottement.add(persist);
+ }
+
+ }
+ return listeFrottement;
+ }
+
+ /**
+ * remplir le fichier DFRT avec les frottemetns
+ *
+ * @param data
+ * @return
+ */
+ public static List<DonFrt> remplirFrottemetnsAvecPersistanceDFRT(final List<StriRefPersist> persistListe,
+ final CtuluAnalyze analyser) {
+ final List<DonFrt> data = new ArrayList<DonFrt>();
+ if (persistListe == null || persistListe.size() == 0) {
+ analyser.addError(CrueResource.getS("Frottements : la liste est vide."), cptEntries++);
+ } else for (final StriRefPersist persist : persistListe) {
+ DonFrt frt = null;
+ if (persist instanceof StriRefCPersist) frt = new StriRefC(persist.Nom);
+ else if (persist instanceof StriRefHPersist) frt = new StriRefH(persist.Nom);
+ else if (persist instanceof StriRefZPersist) frt = new StriRefZ(persist.Nom);
+
+ // -- commun --//
+ if (persist != null) {
+ if (persist.listePoints != null) {
+
+ final List<FrottementPoint> listePoints = new ArrayList<FrottementPoint>();
+ for (final String buff : persist.listePoints) {
+
+ final int indiceCesure = buff.lastIndexOf(" ");
+ final String val1 = buff.substring(0, indiceCesure);
+ final String val2 = buff.substring(indiceCesure + 1, buff.length());
+ double x = 0;
+ try {
+ x = Double.parseDouble(val1);
+
+ } catch (final NumberFormatException e) {
+ analyser.addError(CrueResource.getS("Frottement: " + frt.getNom()
+ + ": impossible de r\xE9cup\xE9rer le r\xE9el du contenu: " + buff), cptEntries++);
+ }
+ double y = 0;
+ try {
+ y = Double.parseDouble(val2);
+ } catch (final NumberFormatException e) {
+ analyser.addError(CrueResource.getS("Frottement: " + frt.getNom()
+ + ": impossible de r\xE9cup\xE9rer le r\xE9el du contenu: " + buff), cptEntries++);
+ }
+ listePoints.add(new FrottementPoint(x, y));
+
+ }
+
+ frt.setListePoints(listePoints);
+ }
+ data.add(frt);
+ }
+
+ }
+ return data;
+ }
+
+}
Property changes on: trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDFRT.java
___________________________________________________________________
Added: svn:mergeinfo
+
Copied: trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDPTG.java (from rev 4607, trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoFactoryDPTG.java)
===================================================================
--- trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDPTG.java (rev 0)
+++ trunk/soft/fudaa-crue/dodico/src/main/java/org/fudaa/dodico/crue/dao/CrueDaoConverterDPTG.java 2009-04-03 16:08:15 UTC (rev 4611)
@@ -0,0 +1,366 @@
+package org.fudaa.dodico.crue.dao;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.fudaa.ctulu.CtuluAnalyze;
+import org.fudaa.dodico.crue.common.CrueResource;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDPTG.BrancheSaintVenant;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDPTG.Frottement;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDPTG.Lit;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDPTG.ProfilCasier;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDPTG.ProfilSection;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDPTG.SectionIdem;
+import org.fudaa.dodico.crue.dao.CrueDaoStructuresFormatDPTG.profilDPTG;
+import org.fudaa.dodico.crue.metier.emh.CatEMHBranche;
+import org.fudaa.dodico.crue.metier.emh.CatEMHCasier;
+import org.fudaa.dodico.crue.metier.emh.CatEMHSection;
+import org.fudaa.dodico.crue.metier.emh.CrueData;
+import org.fudaa.dodico.crue.metier.emh.DonFrt;
+import org.fudaa.dodico.crue.metier.emh.DonPrtGeo;
+import org.fudaa.dodico.crue.metier.emh.DonPrtGeoBrancheSaintVenant;
+import org.fudaa.dodico.crue.metier.emh.DonPrtGeoCasierProfil;
+import org.fudaa.dodico.crue.metier.emh.DonPrtGeoProfilCommun;
+import org.fudaa.dodico.crue.metier.emh.DonPrtGeoSectionIdem;
+import org.fudaa.dodico.crue.metier.emh.DonPrtGeoSectionProfil;
+import org.fudaa.dodico.crue.metier.emh.EMH;
+import org.fudaa.dodico.crue.metier.emh.EMHCasierProfil;
+import org.fudaa.dodico.crue.metier.emh.EMHSectionProfil;
+import org.fudaa.dodico.crue.metier.emh.LitNumerote;
+import org.fudaa.dodico.crue.metier.emh.PtProfil;
+import org.fudaa.dodico.crue.metier.helper.EMHBrancheHelper;
+import org.fudaa.dodico.crue.metier.helper.EMHCasierHelper;
+import org.fudaa.dodico.crue.metier.helper.EMHSectionHelper;
+
+/**
+ * Factory qui se charge de remplir les structures DAO du fichier DPTG avec les donn\xE9es m\xE9tier et inversement.
+ *
+ * @author Adrien Hadoux
+ */
+public class CrueDaoConverterDPTG {
+
+ public static int cptEntries = 1;
+
+ /**
+ * Remplit completement la structure persistante a partir des objets donPrtGeo. Optimise le remplissage en listante
+ * les donn\xE9es emh une seule fois et en forwardant les objets aux bons endroits
+ *
+ * @param persistance
+ * @param data
+ * @param listeMessageError
+ */
+ public static void remplirPersistanceDPTG(final CrueDaoPersistDPTG persistance, final CrueData data,
+ final CtuluAnalyze analyser) {
+
+ // -- liste qui assure d'ajouter une seule r\xE9f\xE9rence de profil: car un meme profil peut etre referenc\xE9 plusieurs
+ // fois
+ final List<DonPrtGeoProfilCommun> listeProfilUniqueReference = new ArrayList<DonPrtGeoProfilCommun>();
+
+ persistance.Profils = new ArrayList<profilDPTG>();
+ persistance.Branches = new ArrayList<BrancheSaintVenant>();
+ persistance.Sections = new ArrayList<SectionIdem>();
+
+ if (data.getAllEMH() == null || data.getAllEMH().size() == 0) {
+ analyser.addError(CrueResource.getS("DPTG: la liste est vide."), cptEntries++);
+ } else for (final EMH emh : data.getAllEMH()) {
+ if (emh.getDPTG() != null) {
+
+ final List<DonPrtGeo> donnees = emh.getDPTG();
+
+ for (final DonPrtGeo donnee : donnees) {
+
+ // -- c'est un profil
+ if (donnee instanceof DonPrtGeoProfilCommun) {
+ if (!listeProfilUniqueReference.contains(donnee)) {
+ remplirPersistanceAvecProfilsDPTG(persistance.Profils, (DonPrtGeoProfilCommun) donnee, analyser);
+ // -- on enregistre la reference --//
+ listeProfilUniqueReference.add((DonPrtGeoProfilCommun) donnee);
+
+ }
+ } else if (donnee instanceof DonPrtGeoSectionIdem) {
+ remplirPersistanceAvecSectionsDPTG(persistance.Sections, (DonPrtGeoSectionIdem) donnee, emh, analyser);
+ } else if (donnee instanceof DonPrtGeoBrancheSaintVenant) {
+ remplirPersistanceAvecBranchesDPTG(persistance.Branches, emh, (DonPrtGeoBrancheSaintVenant) donnee,
+ analyser);
+ }
+
+ }
+ }
+ }
+ }
+
+ /**
+ * Remplit la premiere partie du fichier DPTG avec les 2 types d'objets: casiers profils ou sections profils.
+ *
+ * @param data
+ * @param analyser
+ * @return
+ */
+ public static void remplirPersistanceAvecProfilsDPTG(final List<profilDPTG> listePersistante,
+ final DonPrtGeoProfilCommun prtgeo, final CtuluAnalyze analyser) {
+
+ profilDPTG profilPersistant = null;
+ if (prtgeo instanceof DonPrtGeoCasierProfil) {
+ profilPersistant = new ProfilCasier();
+ // -- donneee specifique pour le profil casier --//
+ ((ProfilCasier) profilPersistant).Long = ((DonPrtGeoCasierProfil) prtgeo).getLongueur();
+
+ } else {
+ profilPersistant = new ProfilSection();
+ }
+ profilPersistant.Nom = prtgeo.getNom();
+
+ // -- Ecriture des lits numerotes --//
+ if (prtgeo.getMLitNumerotes() != null && prtgeo.getMLitNumerotes().size() > 0) {
+ profilPersistant.Lits = new ArrayList<Lit>();
+ for (final LitNumerote litMetier : prtgeo.getMLitNumerotes()) {
+ final Lit litPersist = new Lit();
+ litPersist.IsActif = litMetier.getEstActif();
+ litPersist.IsMineur = litMetier.getEstMineur();
+ if (litMetier.getDebut() != null) litPersist.LimDeb = "" + litMetier.getDebut().getYP() + " "
+ + litMetier.getDebut().getZ();
+ else litPersist.LimFin = "";
+ if (litMetier.getFin() != null) litPersist.LimFin = "" + litMetier.getFin().getYP() + " "
+ + litMetier.getFin().getZ();
+ else litPersist.LimFin = "";
+
+ if (litMetier.getMDonFrt() != null) {
+ litPersist.Frot = new Frottement();
+ // -- on ajoute le nom avec un suffixe --//
+ litPersist.Frot.NomRef = CrueDaoPersistDFRT.SUFFIXE_REF_DFRT + litMetier.getMDonFrt().getNom();
+ } else {
+ analyser.addError(CrueResource.getS("LitNumerote du casierProfil" + prtgeo.getNom()
+ + ": pas de frottement existant"), cptEntries++);
+ }
+
+ // -- ajout du lit persistant --//
+ profilPersistant.Lits.add(litPersist);
+ }
+
+ } else {
+ analyser.addError(CrueResource.getS("Profil " + prtgeo.getNom() + ": aucun litNumerotes existant"), cptEntries++);
+ }
+
+ // -- ecriture des series pt --//
+ if (prtgeo.getListeProfils() != null && prtgeo.getListeProfils().size() > 0) {
+ profilPersistant.Serie = new ArrayList<StringBuffer>();
+ for (final PtProfil serie : prtgeo.getListeProfils()) {
+ final StringBuffer buff = new StringBuffer("" + serie.getYP() + " " + serie.getZ());
+ profilPersistant.Serie.add(buff);
+ }
+ } else {
+ analyser.addError(CrueResource.getS("Profil " + prtgeo.getNom() + ": aucune s\xE9rie existante"), cptEntries++);
+ }
+
+ // -- ajout du profil persistant --//
+ listePersistante.add(profilPersistant);
+ }
+
+ public static void remplirPersistanceAvecSectionsDPTG(final List<SectionIdem> listePersistante,
+ final DonPrtGeoSectionIdem prtgeo, final EMH emh, final CtuluAnalyze analyser) {
+
+ final SectionIdem sectionPersist = new SectionIdem();
+ sectionPersist.NomRef = CrueDaoPersistDRSO.SUFFIXE_REF_DRSO + emh.getNom();
+ sectionPersist.Dz = prtgeo.getDW();
+ listePersistante.add(sectionPersist);
+ }
+
+ public static void remplirPersistanceAvecBranchesDPTG(final List<BrancheSaintVenant> listePersistante, final EMH emh,
+ final DonPrtGeoBrancheSaintVenant prtgeo, final CtuluAnalyze analyser) {
+ final BrancheSaintVenant branchePersist = new BrancheSaintVenant();
+ branchePersist.NomRef = CrueDaoPersistDRSO.SUFFIXE_REF_DRSO + emh.getNom();
+ branchePersist.CoefSinuo = prtgeo.getCoefSinuo();
+
+ listePersistante.add(branchePersist);
+
+ }
+
+ /**
+ * S'occupe de remplir les donn\xE9es m\xE9tier a partir des donn\xE9es persistantes. ATTENTION: n\xE9cessite de charger les
+ * fichiers DRSO et DFRT: ces donn\xE9es sont n\xE9cessaires car des r\xE9f\xE9rences sont pr\xE9sentes dans le fichier DPTG.
+ *
+ * @param persistance
+ * @param data
+ * @param frottements
+ * @param analyser
+ */
+ public static void remplirMetierDPTG(final CrueDaoPersistDPTG persistance, final CrueData data,
+ final CtuluAnalyze analyser) {
+ if (persistance == null) {
+ analyser.addError(CrueResource.getS("DPTG: Aucunes donn\xE9es DPTG."), cptEntries++);
+ } else {
+ // -- cas des Profils --//
+ remplirProfilsAvecPersistencaDPTG(persistance.Profils, data.getAllEMH(), data.getFrottements(), analyser);
+
+ // -- cas des Sections --//
+ remplirSectionsAvecPersistencaDPTG(persistance.Sections, data.getSections(), analyser);
+
+ // -- cas des branches --//
+ remplirBranchesAvecPersistanceDPTG(persistance.Branches, data.getBranches(), analyser);
+
+ }
+ }
+
+ public static void remplirProfilsAvecPersistencaDPTG(final List<profilDPTG> listePersistante, final List<EMH> data,
+ final List<DonFrt> frottements, final CtuluAnalyze analyser) {
+
+ if (listePersistante == null || listePersistante.size() == 0) {
+ analyser.addError(CrueResource.getS("DPTG: Aucunes donn\xE9es pour les profils."), cptEntries++);
+ return;
+ }
+ for (final profilDPTG profilPersist : listePersistante) {
+
+ // -- on recupere la branche qu'il faut --//
+ String profil = profilPersist.Nom;
+ if (profil.contains(CrueDaoPersistDRSO.SUFFIXE_REF_DRSO)) {
+ profil = profil.replace(CrueDaoPersistDRSO.SUFFIXE_REF_DRSO, "");
+ }
+ // -- on tente de trouver tous les objets referenc\xE9 par ce profil --//
+ final List<EMH> listeEMHUtilisantProfil = new ArrayList<EMH>();
+ final List<EMHCasierProfil> emhProfilcasier = EMHCasierHelper.findByProfil(profil, data);
+ final List<EMHSectionProfil> emhProfilsection = EMHSectionHelper.findByProfil(profil, data);
+
+ listeEMHUtilisantProfil.addAll(emhProfilcasier);
+ listeEMHUtilisantProfil.addAll(emhProfilsection);
+
+ if (listeEMHUtilisantProfil == null || listeEMHUtilisantProfil.size() == 0) {
+ analyser.addError(CrueResource.getS("Reference Profil DPTG : Impossible de trouver le profil de nom " + profil
+ + " dans la liste des casier profils et sections profils de DRSO."), cptEntries++);
+ } else {
+
+ // -- on r\xE9cup\xE8re le casier ou le profil et on le stocke dans le emh --//
+ DonPrtGeoProfilCommun profilGeo = null;
+ if (profilPersist instanceof ProfilCasier) {
+ profilGeo = new DonPrtGeoCasierProfil();
+ // -- donnee particulieres a ProfilCasier --//
+ ((DonPrtGeoCasierProfil) profilGeo).setLongueur(((ProfilCasier) profilPersist).Long);
+ } else profilGeo = new DonPrtGeoSectionProfil();
+
+ // -- on remplit son contenu --//
+ profilGeo.setNom(profilPersist.Nom);
+
+ // -- on remplit les litsNommes --//
+ if (profilPersist.Lits != null) {
+ final List<LitNumerote> listeLits = new ArrayList<LitNumerote>();
+
+ for (final Lit litPersis...
[truncated message content] |
