Menu
▾
▴
[Fudaa-svn-commit] SF.net SVN: fudaa:[9655] trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/ fudaa/dodico/crue
|
From: <de...@us...> - 2017-06-30 13:18:21
|
Revision: 9655
http://sourceforge.net/p/fudaa/svn/9655
Author: deniger
Date: 2017-06-30 13:18:19 +0000 (Fri, 30 Jun 2017)
Log Message:
-----------
Classes AOC
Added Paths:
-----------
trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/
trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/
trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueAOCReaderWriter.java
trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueConverterAOC.java
trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueDaoAOC.java
trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueDaoStructureAOC.java
Added: trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueAOCReaderWriter.java
===================================================================
--- trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueAOCReaderWriter.java (rev 0)
+++ trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueAOCReaderWriter.java 2017-06-30 13:18:19 UTC (rev 9655)
@@ -0,0 +1,29 @@
+/**
+ *
+ */
+package org.fudaa.dodico.crue.io.aoc;
+
+import org.fudaa.dodico.crue.io.common.CrueDataXmlReaderWriterImpl;
+import org.fudaa.dodico.crue.projet.aoc.AocCampagne;
+
+import java.io.File;
+
+/**
+ * @author CANEL Christophe
+ *
+ */
+public class CrueAOCReaderWriter extends CrueDataXmlReaderWriterImpl<CrueDaoAOC, AocCampagne> {
+ public CrueAOCReaderWriter(String version)
+ {
+ this(version, null);
+ }
+/**
+ *
+ * @param version
+ * @param otfaFile on l'utilise pour l'initialiser dans OtfaCampagne.
+ */
+ public CrueAOCReaderWriter(String version, File otfaFile)
+ {
+ super("aoc", version, new CrueConverterAOC(otfaFile), new CrueDaoStructureAOC());
+ }
+}
Added: trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueConverterAOC.java
===================================================================
--- trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueConverterAOC.java (rev 0)
+++ trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueConverterAOC.java 2017-06-30 13:18:19 UTC (rev 9655)
@@ -0,0 +1,191 @@
+/**
+ *
+ */
+package org.fudaa.dodico.crue.io.aoc;
+
+import org.fudaa.ctulu.CtuluLog;
+import org.fudaa.dodico.crue.common.transformer.DateDurationConverter;
+import org.fudaa.dodico.crue.io.common.CrueDataConverter;
+import org.fudaa.dodico.crue.metier.CrueData;
+import org.fudaa.dodico.crue.projet.aoc.*;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author deniger
+ */
+public class CrueConverterAOC implements CrueDataConverter<CrueDaoAOC, AocCampagne> {
+
+ private final File aocFile;
+
+ public CrueConverterAOC(File otfaFile) {
+ this.aocFile = otfaFile;
+ }
+
+ public CrueConverterAOC() {
+ this(null);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public AocCampagne convertDaoToMetier(CrueDaoAOC dao, CrueData dataLinked, CtuluLog analyser) {
+ AocCampagne metier = new AocCampagne();
+
+ metier.setCommentaire(dao.getCommentaire());
+ metier.setAuteurCreation(dao.AuteurCreation);
+ metier.setDateCreation(DateDurationConverter.getDate(dao.DateCreation));
+ metier.setAuteurModification(dao.AuteurDerniereModif);
+ if (dao.DateDerniereModif != null) {
+ metier.setDateModification(DateDurationConverter.getDate(dao.DateDerniereModif));
+ }
+ metier.setEtudeChemin(dao.EtudeAssociee.Chemin);
+ metier.setNomScenario(dao.EtudeAssociee.NomScenario);
+ metier.setTypeCalageCritere(dao.TypeCalage.Critere);
+ metier.setTypeCalageDonnees(dao.TypeCalage.Donnees);
+
+ metier.getCalage().setAlgorithme(dao.Calage.Algorithme);
+ metier.getCalage().setType(dao.Calage.Type);
+
+ metier.getCalage().setNombreIterationSeul(dao.Calage.Seul.NombreIteration);
+ metier.getCalage().setNombreIterationTir(dao.Calage.TestRepetabilite.NombreIterationTir);
+ metier.getCalage().setNombreIterationValidationCroisee(dao.Calage.ValidationCroisee.NombreIteration);
+ metier.getCalage().setNombreTir(dao.Calage.TestRepetabilite.NombreTir);
+ metier.getCalage().setPonderationApprentissage(dao.Calage.ValidationCroisee.PonderationApprentissage);
+ metier.getCalage().setPonderationValidation(dao.Calage.ValidationCroisee.PonderationValidation);
+
+ //EchelleSections
+ final List<CrueDaoStructureAOC.EchelleSection> sections = dao.DonneesCampagne.EchellesSections.sections;
+ if (sections != null) {
+ for (CrueDaoStructureAOC.EchelleSection section : sections) {
+ metier.getDonnees().getEchellesSections().addSection(section.PK, section.SectionRef);
+ }
+ }
+ //LoisCalculsPermanents
+ final List<CrueDaoStructureAOC.LoiCalculPermanent> loiCalculPermanents = dao.DonneesCampagne.LoisCalculsPermanents.calculs;
+ if (loiCalculPermanents != null) {
+ for (CrueDaoStructureAOC.LoiCalculPermanent calculPermanent : loiCalculPermanents) {
+ metier.getDonnees().getLoisCalculsPermanents()
+ .addLoiCalculPermanent(calculPermanent.CalculRef, calculPermanent.LoiRef,
+ calculPermanent.Ponderation);
+ }
+ }
+ //LoisCalculsTransitoire
+ final List<CrueDaoStructureAOC.LoiCalculTransitoire> loiCalculTransitoires = dao.DonneesCampagne.LoisCalculsTransitoires.calculs;
+ if (loiCalculTransitoires != null) {
+ for (CrueDaoStructureAOC.LoiCalculTransitoire calculPermanent : loiCalculTransitoires) {
+ metier.getDonnees().getLoisCalculsTransitoires()
+ .addLoiCalculTransitoire(calculPermanent.CalculRef, calculPermanent.LoiRef,
+ calculPermanent.SectionRef,
+ calculPermanent.Ponderation);
+ }
+ }
+ //LoisCalculsTransitoire
+ final List<CrueDaoStructureAOC.LoiStrickler> loiStricklers = dao.DonneesCampagne.LoisStrickler.stricklers;
+ if (loiStricklers != null) {
+ for (CrueDaoStructureAOC.LoiStrickler strickler : loiStricklers) {
+ metier.getDonnees().getLoisStrickler()
+ .addStrickler(
+ strickler.LoiRef,
+ strickler.Min,
+ strickler.Ini,
+ strickler.Max);
+ }
+ }
+ return metier;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public AocCampagne getConverterData(CrueData in) {
+ return null;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public CrueDaoAOC convertMetierToDao(AocCampagne metier, CtuluLog analyser) {
+ CrueDaoAOC dao = new CrueDaoAOC();
+ dao.EtudeAssociee = new CrueDaoStructureAOC.EtudeAssociee();
+ dao.setCommentaire(metier.getCommentaire());
+ dao.AuteurCreation = metier.getAuteurCreation();
+ if (metier.getDateCreation() != null) {
+ dao.DateCreation = DateDurationConverter.dateToXsd(metier.getDateCreation());
+ }
+ dao.AuteurDerniereModif = metier.getAuteurModification();
+ if (metier.getDateModification() != null) {
+ dao.DateDerniereModif = DateDurationConverter.dateToXsd(metier.getDateModification());
+ }
+ dao.EtudeAssociee.Chemin = metier.getEtudeChemin();
+ dao.EtudeAssociee.NomScenario = metier.getNomScenario();
+
+ dao.TypeCalage = new CrueDaoStructureAOC.TypeCalage();
+ dao.TypeCalage.Critere = metier.getTypeCalageCritere();
+ dao.TypeCalage.Donnees = metier.getTypeCalageDonnees();
+
+ dao.Calage = new CrueDaoStructureAOC.Calage();
+ dao.Calage.Seul = new CrueDaoStructureAOC.CalageSeul();
+ dao.Calage.TestRepetabilite = new CrueDaoStructureAOC.CalageTestRepetabilite();
+ dao.Calage.ValidationCroisee = new CrueDaoStructureAOC.CalageValidationCroisee();
+ dao.Calage.Algorithme = metier.getCalage().getAlgorithme();
+ dao.Calage.Type = metier.getCalage().getType();
+
+ dao.Calage.Seul.NombreIteration = metier.getCalage().getNombreIterationSeul();
+ dao.Calage.TestRepetabilite.NombreIterationTir = metier.getCalage().getNombreIterationTir();
+ dao.Calage.TestRepetabilite.NombreTir = metier.getCalage().getNombreTir();
+ dao.Calage.ValidationCroisee.NombreIteration = metier.getCalage().getNombreIterationValidationCroisee();
+ dao.Calage.ValidationCroisee.PonderationApprentissage = metier.getCalage().getPonderationApprentissage();
+ dao.Calage.ValidationCroisee.PonderationValidation = metier.getCalage().getPonderationValidation();
+
+ final AocEchellesSections echellesSections = metier.getDonnees().getEchellesSections();
+ //donnees campagne
+ dao.DonneesCampagne = new CrueDaoStructureAOC.DonneesCampagne();
+ //Echelles section
+ dao.DonneesCampagne.EchellesSections = new CrueDaoStructureAOC.EchellesSections();
+ dao.DonneesCampagne.EchellesSections.sections = new ArrayList<>();
+ for (AocEchellesSection aocEchellesSection : echellesSections.getEchellesSectionList()) {
+ dao.DonneesCampagne.EchellesSections.sections
+ .add(CrueDaoStructureAOC.create(aocEchellesSection.getPk(),
+ aocEchellesSection.getSectionRef()));
+ }
+ //permanent
+ dao.DonneesCampagne.LoisCalculsPermanents = new CrueDaoStructureAOC.LoisCalculsPermanents();
+ dao.DonneesCampagne.LoisCalculsPermanents.calculs = new ArrayList<>();
+ for (AocLoiCalculPermanent loiPermanent : metier.getDonnees().getLoisCalculsPermanents()
+ .getLois()) {
+ dao.DonneesCampagne.LoisCalculsPermanents.calculs
+ .add(new CrueDaoStructureAOC.LoiCalculPermanent(loiPermanent.getCalculRef(),
+ loiPermanent.getLoiRef(), loiPermanent.getPonderation()));
+ }
+
+ //transitoire
+ dao.DonneesCampagne.LoisCalculsTransitoires = new CrueDaoStructureAOC.LoisCalculsTransitoires();
+ dao.DonneesCampagne.LoisCalculsTransitoires.calculs = new ArrayList<>();
+ for (AocLoiCalculTransitoire loiTransitoire : metier.getDonnees().getLoisCalculsTransitoires()
+ .getLois()) {
+ dao.DonneesCampagne.LoisCalculsTransitoires.calculs
+ .add(new CrueDaoStructureAOC.LoiCalculTransitoire(loiTransitoire.getCalculRef(),
+ loiTransitoire.getLoiRef(), loiTransitoire.getSectionRef(),
+ loiTransitoire.getPonderation()));
+ }
+ //stricklers
+ dao.DonneesCampagne.LoisStrickler = new CrueDaoStructureAOC.LoisStrickler();
+ dao.DonneesCampagne.LoisStrickler.stricklers = new ArrayList<>();
+ for (AocLoiStrickler loiTransitoire : metier.getDonnees().getLoisStrickler()
+ .getLois()) {
+ dao.DonneesCampagne.LoisStrickler.stricklers
+ .add(new CrueDaoStructureAOC.LoiStrickler(
+ loiTransitoire.getLoiRef(),
+ loiTransitoire.getMin(),
+ loiTransitoire.getIni(),
+ loiTransitoire.getMax()));
+ }
+ return dao;
+ }
+}
Added: trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueDaoAOC.java
===================================================================
--- trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueDaoAOC.java (rev 0)
+++ trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueDaoAOC.java 2017-06-30 13:18:19 UTC (rev 9655)
@@ -0,0 +1,20 @@
+/**
+ *
+ */
+package org.fudaa.dodico.crue.io.aoc;
+
+import org.fudaa.dodico.crue.common.io.AbstractCrueDao;
+
+/**
+ * @author CANEL Christophe
+ */
+public class CrueDaoAOC extends AbstractCrueDao {
+ public String AuteurCreation;
+ public String DateCreation;
+ public String AuteurDerniereModif;
+ public String DateDerniereModif;
+ public CrueDaoStructureAOC.EtudeAssociee EtudeAssociee;
+ public CrueDaoStructureAOC.TypeCalage TypeCalage;
+ public CrueDaoStructureAOC.Calage Calage;
+ public CrueDaoStructureAOC.DonneesCampagne DonneesCampagne;
+}
Added: trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueDaoStructureAOC.java
===================================================================
--- trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueDaoStructureAOC.java (rev 0)
+++ trunk/soft/fudaa-crue/crue-aoc/src/main/java/org/fudaa/dodico/crue/io/aoc/CrueDaoStructureAOC.java 2017-06-30 13:18:19 UTC (rev 9655)
@@ -0,0 +1,245 @@
+/**
+ *
+ */
+package org.fudaa.dodico.crue.io.aoc;
+
+import com.thoughtworks.xstream.XStream;
+import org.apache.commons.collections.bidimap.DualHashBidiMap;
+import org.fudaa.ctulu.CtuluLog;
+import org.fudaa.dodico.crue.io.common.CrueDataDaoStructure;
+import org.fudaa.dodico.crue.io.common.EnumsConverter;
+import org.fudaa.dodico.crue.projet.aoc.EnumAocCalageAlgorithme;
+import org.fudaa.dodico.crue.projet.aoc.EnumAocCalageType;
+import org.fudaa.dodico.crue.projet.aoc.EnumAocTypeCalageCritere;
+import org.fudaa.dodico.crue.projet.aoc.EnumAocTypeCalageDonnees;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author deniger
+ */
+public class CrueDaoStructureAOC implements CrueDataDaoStructure {
+
+ /**
+ * @return map de correspondance pour les enums
+ */
+ public static DualHashBidiMap createTypeCalageDonneesMap() {
+ final DualHashBidiMap res = new DualHashBidiMap();
+ res.put(EnumAocTypeCalageDonnees.PERMANENT, "Permanent");
+ res.put(EnumAocTypeCalageDonnees.TRANSITOIRE_HYDROGRAMME, "TransitoireLimnigramme");
+ res.put(EnumAocTypeCalageDonnees.TRANSITOIRE_LIMNIGRAMME, "TransitoireHydrogramme");
+ return res;
+ }
+
+ /**
+ * @return map de correspondance pour les enums
+ */
+ public static DualHashBidiMap createTypeCalageCriteresMap() {
+ final DualHashBidiMap res = new DualHashBidiMap();
+ res.put(EnumAocTypeCalageCritere.ERREUR_QUADRATIQUE, "ErreurQuadratique");
+ res.put(EnumAocTypeCalageCritere.ECART_NIVEAUX_MAX, "EcartNiveauxMax");
+ res.put(EnumAocTypeCalageCritere.ECART_NIVEAUX_MAX, "EcartNiveauxMax");
+ res.put(EnumAocTypeCalageCritere.ECART_TEMPS_ARRIVEE_MAX, "EcartTempsArriveeMax");
+ res.put(EnumAocTypeCalageCritere.ECART_VOLUMES, "EcartVolumes");
+ return res;
+ }
+
+ /**
+ * @return map de correspondance pour les enums
+ */
+ public static DualHashBidiMap createCalageTypeMap() {
+ final DualHashBidiMap res = new DualHashBidiMap();
+ res.put(EnumAocCalageType.SEUL, "Seul");
+ res.put(EnumAocCalageType.TEST_REPETABILITE, "TestRepetabilite");
+ res.put(EnumAocCalageType.ANALYSE_SENSIBILITE, "AnalyseSensibilite");
+ res.put(EnumAocCalageType.VALIDATION_CROISEE, "ValidationCroisee");
+ return res;
+ }
+
+ /**
+ * @return map de correspondance pour les enums
+ */
+ public static DualHashBidiMap createCalageAlgorithmeMap() {
+ final DualHashBidiMap res = new DualHashBidiMap();
+ res.put(EnumAocCalageAlgorithme.RECUIT, "Recuit");
+ res.put(EnumAocCalageAlgorithme.MONTE_CARLO, "MonteCarlo");
+ return res;
+ }
+
+ public static EchelleSection create(String pk, String sectionRef) {
+ EchelleSection res = new EchelleSection();
+ res.SectionRef = sectionRef;
+ res.PK = pk;
+ return res;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void configureXStream(XStream xstream, CtuluLog analyze,
+ org.fudaa.dodico.crue.config.loi.LoiTypeContainer props) {
+ //on configure les alias
+ xstream.alias("AOC", CrueDaoAOC.class);
+ xstream.alias("EtudeAssociee", EtudeAssociee.class);
+ xstream.alias("TypeCalage", TypeCalage.class);
+ xstream.alias("Calage", Calage.class);
+ xstream.alias("Seul", CalageSeul.class);
+ xstream.alias("CalageTestRepetabilite", CalageTestRepetabilite.class);
+ xstream.alias("CalageValidationCroisee", CalageValidationCroisee.class);
+ xstream.alias("DonneesCampagne", DonneesCampagne.class);
+
+ xstream.alias("EchellesSections", EchellesSections.class);
+ xstream.alias("EchelleSection", EchelleSection.class);
+ xstream.useAttributeFor(EchelleSection.class, "PK");
+ xstream.useAttributeFor(EchelleSection.class, "SectionRef");
+
+ xstream.alias("LoisCalculsPermanents", LoisCalculsPermanents.class);
+ xstream.alias("LoiCalculPermanent", LoiCalculPermanent.class);
+ xstream.useAttributeFor(LoiCalculPermanent.class, "CalculRef");
+ xstream.useAttributeFor(LoiCalculPermanent.class, "LoiRef");
+ xstream.useAttributeFor(LoiCalculPermanent.class, "Ponderation");
+
+ xstream.alias("LoisCalculsTransitoires", LoisCalculsTransitoires.class);
+ xstream.alias("LoiCalculTransitoire", LoiCalculTransitoire.class);
+ xstream.useAttributeFor(LoiCalculTransitoire.class, "CalculRef");
+ xstream.useAttributeFor(LoiCalculTransitoire.class, "LoiRef");
+ xstream.useAttributeFor(LoiCalculTransitoire.class, "SectionRef");
+ xstream.useAttributeFor(LoiCalculTransitoire.class, "Ponderation");
+
+ xstream.alias("LoisStrickler", LoisStrickler.class);
+ xstream.alias("LoiStrickler", LoiStrickler.class);
+ xstream.useAttributeFor(LoiStrickler.class, "LoiRef");
+ xstream.useAttributeFor(LoiStrickler.class, "Min");
+ xstream.useAttributeFor(LoiStrickler.class, "Ini");
+ xstream.useAttributeFor(LoiStrickler.class, "Max");
+
+ xstream.addImplicitCollection(EchellesSections.class, "sections");
+ xstream.addImplicitCollection(LoisCalculsPermanents.class, "calculs");
+ xstream.addImplicitCollection(LoisCalculsTransitoires.class, "calculs");
+ xstream.addImplicitCollection(LoisStrickler.class, "stricklers");
+
+ xstream.registerConverter(EnumsConverter
+ .createEnumConverter(createTypeCalageCriteresMap(), EnumAocTypeCalageCritere.class, analyze));
+ xstream.registerConverter(EnumsConverter
+ .createEnumConverter(createTypeCalageDonneesMap(), EnumAocTypeCalageDonnees.class, analyze));
+ xstream.registerConverter(
+ EnumsConverter.createEnumConverter(createCalageTypeMap(), EnumAocCalageType.class, analyze));
+ xstream.registerConverter(EnumsConverter
+ .createEnumConverter(createCalageAlgorithmeMap(), EnumAocCalageAlgorithme.class, analyze));
+ }
+
+ public static class EtudeAssociee {
+ public String Chemin;
+ public String NomScenario;
+ }
+
+ public static class TypeCalage {
+ public EnumAocTypeCalageDonnees Donnees;
+ public EnumAocTypeCalageCritere Critere;
+ }
+
+ public static class Calage {
+ public EnumAocCalageType Type;
+ public EnumAocCalageAlgorithme Algorithme;
+ public CalageSeul Seul;
+ public CalageTestRepetabilite TestRepetabilite;
+ public CalageValidationCroisee ValidationCroisee;
+ }
+
+ public static class CalageSeul {
+ public int NombreIteration;
+ }
+
+ public static class CalageTestRepetabilite {
+ public int NombreIterationTir;
+ public int NombreTir;
+ }
+
+ public static class CalageValidationCroisee {
+ public int NombreIteration;
+ public double PonderationApprentissage;
+ public double PonderationValidation;
+ }
+
+ public static class DonneesCampagne {
+ public EchellesSections EchellesSections;
+ public LoisCalculsPermanents LoisCalculsPermanents;
+ public LoisCalculsTransitoires LoisCalculsTransitoires;
+ public LoisStrickler LoisStrickler;
+ }
+
+ public static class EchellesSections {
+ public List<EchelleSection> sections;
+ }
+
+ public static class LoisCalculsPermanents {
+ public List<LoiCalculPermanent> calculs = new ArrayList<>();
+ }
+
+ public static class LoisCalculsTransitoires {
+ public List<LoiCalculTransitoire> calculs = new ArrayList<>();
+ }
+
+ public static class LoisStrickler {
+ public List<LoiStrickler> stricklers = new ArrayList<>();
+ }
+
+ public static class EchelleSection {
+ public String PK;
+ public String SectionRef;
+ }
+
+ public static class LoiCalculPermanent {
+ public String CalculRef;
+ public String LoiRef;
+ public int Ponderation;
+
+ public LoiCalculPermanent() {
+
+ }
+
+ public LoiCalculPermanent(String calculRef, String loiRef, int ponderation) {
+ CalculRef = calculRef;
+ LoiRef = loiRef;
+ Ponderation = ponderation;
+ }
+ }
+
+ public static class LoiCalculTransitoire {
+ public String CalculRef;
+ public String LoiRef;
+ public String SectionRef;
+ public int Ponderation;
+
+ public LoiCalculTransitoire() {
+
+ }
+
+ public LoiCalculTransitoire(String calculRef, String loiRef, String sectionRef, int ponderation) {
+ CalculRef = calculRef;
+ LoiRef = loiRef;
+ SectionRef = sectionRef;
+ Ponderation = ponderation;
+ }
+ }
+
+ public static class LoiStrickler {
+ public String LoiRef;
+ public int Min;
+ public int Ini;
+ public int Max;
+
+ public LoiStrickler() {
+
+ }
+
+ public LoiStrickler(String loiRef, int min, int ini, int max) {
+ LoiRef = loiRef;
+ Min = min;
+ Ini = ini;
+ Max = max;
+ }
+ }
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
