Blog – Page 2

Les bases – Rechercher plusieurs informations

Dans Generic System, il est possible de rechercher spécifiquement un Generic (recherche simple), ou bien un ensemble de Generic (recherche avancée). Quand un ensemble de résultats doit être retourné, Generic System ne renvoie pas de liste de Generic, mais un Snapshot.

Introduction

Qu’est-ce qu’un Snapshot ?

D’un point de vue fonctionnel, un Snapshot est un ensemble de résultats qui est conscient de son contexte. Le Snapshot est directement en relation avec le modèle de persistence des données, contrairement aux Collections Java qui possèdent un cache en interne contenant les informations.

D’un point de vue technique, un Snapshot est d’une part un fournisseur de Stream et d’autre part un aware Iterable. Comme nous allons le voir par la suite, un Snapshot peut être requêté directement en utilisant des filtres de Stream.

Comparaison Snapshot / Collection

Pour prendre un exemple simple, nous allons créer une instance de Vehicle puis la stocker soit dans une Collection, soit dans un Snapshot. Nous allons ensuite vérifier que notre Collection et notre Snapshot contiennent bien cette instance. Puis nous ajoutons une nouvelle instance de Vehicle, et nous vérifions que notre Collection et notre Snapshot contiennent bien les deux instances.

Continue reading Les bases – Rechercher plusieurs informations

Attribute, Filter, Holder, instance, Link, Relation, result, search, Snapshot, Stream, Type

Avancé – La représentation de l’information au sein de Generic System

À votre avis, comment est représentée l’information dans Generic System ? Est-ce sous forme de table (de manière scalaire) comme pour les bases de données relationnelles ? Ou plutôt dans un arbre, comme pour les fichiers XML ?

Modèle de représentation de l’information

Generic System enregistre l’information dans un graphe. Celui-ci a une seule racine : le nœud qui représente Engine. Tous les nœuds du graphe sont des objets qui implémentent l’interface Generic, y compris Engine. Ils ont la particularité d’être immuables et ont un cycle de vie simplifié : ils naissent et peuvent mourir. En aucun cas ils ne peuvent être modifiés.

Tous les nœuds contiennent dès leur construction une et une seule donnée. Celle-ci joue un rôle de désignant pour la structure de l’information et un rôle de désigné pour les occurrences de cette information. Par exemple, le nom d’une personne est le désignant et la personne est le désigné. Cette donnée doit être Serializable et implémenter correctement les méthodes equals() et hashCode().

Relations entre les nœuds

Les nœuds sont reliés entre eux par le principe « ancêtres / dépendances » : les ancêtres d’un nœud dépendant doivent exister pendant toute la durée de vie de ce dernier.

Trois types de liaison « ancêtres / dépendances » coexistent dans Generic System : l’instanciation, l’héritage et la composition.
Les ancêtres d’un Generic sont donc son « meta », ses « supers » et ses « composants ». Ces dépendances sont ses « instances », ses « héritiers » et ses « composites ».

Continue reading Avancé – La représentation de l’information au sein de Generic System

ancestors, components, composites, composition, dependencies, graph, inheritance, inheritings, instances, instantiation, meta, representation of the information, supers, value

Avancé – Engine et son point d’accès le Cache

Depuis le temps que vous utilisez Engine, vous devez être impatient de voir comment il fonctionne. Alors allons y.

Engine

Le moteur de Generic System est représenté par Engine. Ce moteur peut être exécuté selon 2 modes :

persistant : exécute le système en enregistrant physiquement l’information.
embarqué : exécute le système en mémoire sans aucun mécanisme de persistance.

Pour démarrer le moteur en mode persistant, vous devez préciser le nom du moteur et le répertoire où seront stockées et récupérées les archives de Generic System.

// Create an engine named myDataBase and which is persistent
Engine engine = new Engine("myDataBase", System.getenv("HOME") + "/my_directory_path");

1 2	// Create an engine named myDataBase and which is persistent Engine engine = new Engine("myDataBase", System.getenv("HOME") + "/my_directory_path");

En mode embarqué, le moteur se démarre tout simplement ainsi :

// Create an engine which is in memory
Engine engine = new Engine();

1 2	// Create an engine which is in memory Engine engine = new Engine();

Dans la suite de cette article, nous considérerons une exécution sans mécanisme de persistance.
Mais vous ne pouvez pas utiliser Engine directement, vous devez passer par l’intermédiaire d’un Cache.

Continue reading Avancé – Engine et son point d’accès le Cache

Cache, Create, Engine, mount

Avancé – Utiliser les contraintes de Generic System

Toute base de données qui se respecte permet de poser des contraintes.
Generic System le permet également. Abordons dans un premier temps comment les utiliser.

Utilisation des contraintes

Prenons trois contraintes utilisateur et voyons comment les appliquer avec notre exemple maintenant bien connu de Vehicle.

PropertyConstraint

La première contrainte est PropertyConstraint.
Une nouvelle gamme de voiture est récemment apparue sur le marché et ne peut avoir qu’une seule options à la fois. Par chance, c’est justement la contrainte que nous voulons tester !

Engine engine = new Engine();

// Create a type Vehicle
Generic vehicle = engine.addInstance("Vehicle");
// Create the attribute Options for the type Vehicle
Generic options = vehicle.addAttribute("Options");
// Only one value for Options : enable property constraint
options.enablePropertyConstraint();

// Create an instance of Vehicle
Generic myVehicle = vehicle.addInstance("myVehicle");
// Add values for Options
myVehicle.addHolder(options, "music player"); // OK

// Persist changes
engine.getCurrentCache().flush();

try {
	myVehicle.addHolder(options, "air conditioning");
} catch (RollbackException e) {
	assert e.getCause() instanceof PropertyConstraintViolationException;
}

Engine engine = new Engine();

// Create a type Vehicle

Generic vehicle = engine.addInstance("Vehicle");

// Create the attribute Options for the type Vehicle

Generic options = vehicle.addAttribute("Options");

// Only one value for Options : enable property constraint

options.enablePropertyConstraint();

// Create an instance of Vehicle

Generic myVehicle = vehicle.addInstance("myVehicle");

// Add values for Options

myVehicle.addHolder(options, "music player"); // OK

// Persist changes

engine.getCurrentCache().flush();

try {

myVehicle.addHolder(options, "air conditioning");

} catch (RollbackException e) {

assert e.getCause() instanceof PropertyConstraintViolationException;

}

Continue reading Avancé – Utiliser les contraintes de Generic System

Constraint, Holder, instance

Avancé – Les contraintes dans Generic System

Dans les bases de données relationnelles, de nombreuses contraintes existent : clé primaire, clé étrangère, non null…
Dans Generic System, il existe aussi des contraintes. C’est ce à quoi nous allons nous intéresser maintenant.

Les contraintes

Toutes les contraintes sont vérifiées lors du flush() du cache, mais certaines sont aussi vérifiées immédiatement (lors de l’ajout ou de la suppression d’un type, d’une instance, etc.).
Commençons par un tour d’horizon des différentes contraintes. Mais juste avant cela, vous devez savoir une chose : certaines contraintes sont paramétrables par l’utilisateur, d’autres par le système lui-même. Les contraintes utilisateur sont des contraintes que vous pouvez choisir de poser, alors que les contraintes système ne peuvent pas être désactivées.

Continue reading Avancé – Les contraintes dans Generic System

Constraint