# Ebullition

Une application Java et JavaFX pour gérer des capteurs de température.

## Conception

### Interfaces partagées

```mermaid
classDiagram
    class Tickable {
        +tick()*
    }
    <<interface>> Tickable
    class Nameable {
        +getName()* String
        +getDisplayName() String
    }
    <<interface>> Nameable
    class Identifiable {
        +getId()* int
        +setName(name : String)*
    }
    <<interface>> Identifiable
    class ObservableIdentifiable {
        +idProperty()* ReadOnlyIntProperty
        +getId() int
        +nameProperty()* StringProperty
        +getName() String
        +setName(name : String)
        +displayNameExpression() StringExpression
        +getDisplayName() String
    }
    <<interface>> ObservableIdentifiable
    class SensorFactory {
        +create(registry : SensorRegistry, name : String)* Sensor
    }
    <<interface>> SensorFactory
    class AutoUpdateStrategyFactory {
        +create()* AutoUpdateStrategy
    }
    <<interface>> AutoUpdateStrategyFactory
    Nameable <|-- Identifiable
    Identifiable <|-- ObservableIdentifiable
    Nameable <|-- SensorFactory
    Nameable <|-- AutoUpdateStrategyFactory
```

L'interface `Tickable` définit une méthode `tick` qui est appelée périodiquement par un thread.

Tous les objets héritent en Java de `java.lang.Object` et ont donc une méthode `toString` utilisée principalement pour déboguer.
Lorsqu'un objet est fait pour être affiché à l'utilisateur, ce n'est pas du débogage.
L'interface `Nameable` définit les méthodes `getName` et `getDisplayName` qui retourne les noms à afficher pour ces objets.

Un objet peut être identifié par un identifiant unique, un `UUID` ou un `int`.
L'interface `Identifiable` définit la méthode `getId` qui permet de récupérer cet identifiant sous forme d'entier.
Elle définit aussi une méthode `setName` pour changer le nom de l'objet.

Des objets qui implémentent `Nameable` ou `Identifiable` ne sont pas nécessairement observables.
C'est pourquoi l'interface `ObservableIdentifiable` hérite de ces deux interfaces et expose les propriétés observables pour l'identifiant et le nom.
Il s'agit du même nom que les méthodes `getId` et `getName` mais en exposant une propriété observable.

D'autres éléments de l'application sont nommables, comme certaines fabriques d'objets : `SensorFactory` crée des capteurs et `AutoUpdateStrategyFactory` crée des stratégies d'actualisation automatique.
Ces deux interfaces héritent de `Nameable` pour proposer un affichage de ces fabriques dans l'application.

### Capteurs

```mermaid
classDiagram
    class ObservableIdentifiable {
        ...
    }
    <<interface>> ObservableIdentifiable
    class Tickable {
        +tick()*
    }
    <<interface>> Tickable
    class Sensor {
        -id : IntegerProperty
        -name : StringProperty
        -displayName : StringExpression
        -temperature : DoubleProperty
        +Sensor(id : int, name : String)
        +idProperty() int
        +nameProperty() StringProperty
        +displayNameExpression() StringExpression
        +temperatureProperty() ReadOnlyDoubleProperty
        +getTemperature() double
    }
    class ManualSensor {
        +temperatureProperty() DoubleProperty
    }
    class AutoSensor {
        -updateStrategy : ObjectProperty~AutoUpdateStrategy~
        +tick()
        +getUpdateStrategy() AutoUpdateStrategy
        +setUpdateStrategy(s : AutoUpdateStrategy)
        +updateStrategyProperty() ReadOnlyObjectProperty~AutoUpdateStrategy~
    }
    class VirtualSensor {
        -sources : ObservableList~DataSource~
        -sourcesProperty : ListProperty~DataSource~
        +addSource(s : Sensor, weight : double)
        +removeSource(s : Sensor) bool
        +sourcesProperty() ReadOnlyListProperty~DataSource~
        #compute()
    }
    class DataSource {
        -sensor : Sensor
        -weight : DoubleProperty
        +sensor() Sensor
        +weight() double
    }
    Sensor <|-- ManualSensor
    Sensor <|-- AutoSensor
    Sensor <|-- VirtualSensor
    ObservableIdentifiable <|.. Sensor
    Tickable <|.. AutoSensor
    DataSource "*" <-- VirtualSensor
    Sensor "1" <-- DataSource
```

Un capteur est un objet observable et identifiable.

S'il peut être mis à jour périodiquement comme c'est le cas pour les capteurs automatiques `AutoSensor`, il implémente l'interface `Tickable`.

Un capteur manuel ne fait qu'autoriser publiquement la modification de la température par rapport à la classe abstraite `Sensor`.

Un capteur virtuel est composé de plusieurs sources de température.
C'est une variante du patron de conception composite : chaque capteur virtuel contient une liste de capteurs et de poids associés avec des objets `DataSource`.