@startuml

namespace ecoparasite {

    class Application {
        + {static} main
    }

    namespace ecoparasite.input {

        class InputFactory {
           - {static} String DATA_FOLDER
           + {static} String buildDataPath()
           + {static} RawData readData()
           - {static} RawData createRawData()
        }

        class RawData {
           - ArrayList<ArrayList<String>> data
           + RawData()
           + ArrayList<ArrayList<String>> getData()
           + String toString()
           + HashSet<String> getColumnsNames()
           + HashSet<String> getDataFromColumn()
           + HashMap<String,String> getEntry()
        }

        InputFactory o--> RawData

        interface DataParsing {
            + HashSet<T> parse()
        }

        exception InputFileException {
            - String dataFilePath
            + String getMessage()
        }

        exception RawDataOverflow {
            - int excepted
            - int limit
            + String getMessage()
        }

        exception InvalidParsingException {
            - int parsingId
            - String parsingClass
        }

    }

    namespace ecoparasite.poissons {

        class Poisson {
            - String id
            - Double length
            - Double weight
            - Double infestation
            ---
            + Poisson()
            .. Getters ..
            + String toString()
        }

        class Merlu extends Poisson implements ecoparasite.input.DataParsing {
            + Merlu()
        }

        class Mackerel extends Poisson implements ecoparasite.input.DataParsing {
            + Mackerel()
        }

        class PartiePoisson {
            - String name
            - Double infestation
            + PartiePoisson(String name, Double infestation)
        }

        Poisson o--> PartiePoisson : # fishParts
    }

    namespace ecoparasite.population {

        class Population implements ecoparasite.input.DataParsing {
            - String id
            - HashMap<Integer,PopulationArgs> perYear
            + Population()
        }

        Population o--> PopulationArgs : - total

        class PopulationArgs {
            - int year
            - int number
            - Double intensity
            - Double abondance
            + PopulationArgs()
        }

        PopulationArgs o--> PopulationArgInterval : - length
        PopulationArgs o--> PopulationArgInterval : - width
        PopulationArgs o--> PopulationArgInterval : - prevalence
        PopulationArgs o--> PopulationArgInterval : - ic

        class PopulationArgInterval {
            - Double min
            - Double max
            - Double mean
            + PopulationArgInterval()
            + PopulationArgInterval()
            + Double transformToDouble()
            + {static} PopulationArgInterval fromString()
        }

        class PopulationParsing {
            + {static} HashSet<Population> parseParasitesPeru()
            - {static} void applyValueForParasitesPeru()
        }
    }

    namespace ecoparasite.completion {
        class Completion {
            + {static} completeColumnsMoyenne()
            + {static} completeColumnsLinear()
        }
    }

    namespace ecoparasite.nettoyage {
        class Nettoyage {
            + {static} nettoieColumns()
        }
    }

    namespace ecoparasite.representation {
        class ValeursXY {
            - double x
            - double y
            + {static} HashSet<ValeursXY> convertToXY()
        }
    }

    namespace ecoparasite.svg {
        class SVGFactory {
            + {static} createSVG()
            + {static} createSVGCode()
            + {static} createFile()
        }

        class Coordonnees {
            - double x
            - double y
        }

        class SVGResizing {
            - double minX
            - double maxX
            - double minY
            - double maxY
            + resize()
        }

        class SVGBuilder {
            - ArrayList<Double> pointsX
            - ArrayList<Double> pointsY
            - double minPointsX
            - double minPointsY
            - double maxPointsX
            - double maxPointsY
            + SVGBuilder()
            + getResizer()
            + buildAll()
            + buildAxes()
            + buildXTicks()
            + buildYTicks()
            + buildPoints()
            + buildRegression()
            - getBeginAxeX()
            - getBeginAxeY()
            + {static} calcPointsAxes()
            + {static} niceStep()
            + {static} roundMin()
            + {static} roundMax()
        }

        exception IncorrectAxesPointsException {
        }

        SVGBuilder o--> SVGResizing : - resizer

    }

    namespace ecoparasite.svg.elements {

        class ElementsFactory {
            + {static} SVGAxes()
        }

        abstract class Element {
            + {abstract} toSVG()
        }

        Element o--> ecoparasite.svg.Coordonnees : # coordonnees

        class Circle extends Element {
            - int rayon
            - String color
        }

        class Line extends Element {
            - int lineWidth
            - String color
        }

        class Text extends Element {
            - String text
            - String color
            - int size
        }

        Line o--> ecoparasite.svg.Coordonnees : # coordonneesB
    }

}
Exception <|-- InputFileException
Exception <|-- RawDataOverflow
Exception <|-- IncorrectAxesPointsException

@enduml