Les bases – Création de types, de sous-types et d’instances

Introduction

Les points d’entrée dans Generic System sont Engine et Cache. Ces notions seront abordées plus en détails dans le billet Avancé – Engine et son point d’accès le Cache.
Dans la suite de cette article, nous allons aborder les notions de bases du fonctionnement de Generic System à travers quelques exemples simples.

Qu’est-ce qu’un Generic ?

Dans le monde Java, tout est objet (ou presque). Dans le modèle relationnel, tout est table. Et bien dans Generic System, tout est Generic ! C’est le terme générique employé pour désigner un type, une instance, une relation, un holder, un lin, etc. Ces différentes notions seront abordées au cours des prochains articles :

Ainsi dans Generic System, l’information est enregistrée dans un graphe qui a pour racine le nœud représentant Engine. Tous les nœuds du graphe implémentent ensuite l’interface Generic.

Démarrage de Engine

Nous allons donc commencer par créer un moteur Engine pour y stocker nos données.
Si vous avez lu l’article d’introduction, vous savez que le moteur d’informations de Generic System peut être exécuté selon 2 modes : embarqué ou persistant.

mode embarqué : le système est exécuté en mémoire seulement, il n’y a pas de persistance.
mode persistant : le système est exécute en mémoire, et le graphe de Generic est régulièrement persisté sur le disque.

Le mode que vous choisirez pour cette démonstration n’a pas d’importance. Voici comment procéder :

// Create an engine in memory (not persistent)
Engine engine = new Engine();

// Or, create a persistent Engine
Engine engine = new Engine("example", System.getenv("HOME") + "/genericsystem/basic_example");

// Create an engine in memory (not persistent)

Engine engine = new Engine();

// Or, create a persistent Engine

Engine engine = new Engine("example", System.getenv("HOME") + "/genericsystem/basic_example");

Bien entendu, vous devrez utiliser le mode persistant si vous souhaitez conserver une copie de vos données !

Pour simplifier la compréhension de Generic System, nous allons commencer par les bases : comment créer un type et une instance ? Tout au long de l’article, nous allons nous appuyer sur des exemples simples.

Type et instance

En programmation orientée objet en java, un type correspond à une classe et une instance à une instance de cette classe.
En base de données relationnelle, un type est une table et une instance est un enregistrement.

Comment créer un type ?

La création d’un type dans Generic System est très simple :

// Create a type Vehicle
Generic vehicle = engine.addInstance("Vehicle");

1 2	// Create a type Vehicle Generic vehicle = engine.addInstance("Vehicle");

Vous voyez ? Il suffit de déclarer une nouvelle instance sur notre Engine grâce à la méthode addInstance.

Unicité

Le nom d’un type, ou d’un Generic en général, doit être unique. Si vous tentez d’ajouter un type alors qu’un type porte déjà le même nom, Generic System lèvera une exception ExistsException :

Engine engine = new Engine();

Generic myCar = engine.addInstance("Toyota Auris");
try {
	Generic yourCar = engine.addInstance("Toyota Auris");
} catch (RollbackException e) {
	// An instance with the same name already exists!
	assert e.getCause() instanceof ExistsException;
}

Engine engine = new Engine();

Generic myCar = engine.addInstance("Toyota Auris");

try {

Generic yourCar = engine.addInstance("Toyota Auris");

} catch (RollbackException e) {

// An instance with the same name already exists!

assert e.getCause() instanceof ExistsException;

}

Il existe donc une méthode setInstance qui fonctionne comme addInstance si l’instance n’existe pas, et comme getInstance si elle existe déjà :

Generic yourCar = engine.setInstance("Toyota Auris");
assert myCar == yourCar;

1 2	Generic yourCar = engine.setInstance("Toyota Auris"); assert myCar == yourCar;

Comment créer une instance ?

La création d’une instance ressemble très fortement à la création d’un type. En effet, vous allez là aussi faire appel à la méthode addInstance mais à partir de type et non plus de engine.
Pour reprendre notre exemple, créer une instance de notre type vehicle permet d’ajouter un nouveau véhicule :

// Add a new vehicle (instance of Vehicle)
Generic myVehicle = vehicle.addInstance("myVehicle");

1 2	// Add a new vehicle (instance of Vehicle) Generic myVehicle = vehicle.addInstance("myVehicle");

Il est bien sûr possible de créer plusieurs instances d’un même type :

// Instantiate a second vehicle
Generic yourVehicle = vehicle.addInstance("yourVehicle");

1 2	// Instantiate a second vehicle Generic yourVehicle = vehicle.addInstance("yourVehicle");

Et enfin, il ne faut pas oublier de persister nos changements dans le moteur de Generic System pour qu’ils soient validés :

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

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

Vous trouverez plus d’informations concernant le cache et la méthode flush() dans l’article Avancé – Engine et son point d’accès le Cache.

Représentation schématique

Voici comment pourrait être représentée de façon schématique la structure que nous venons de créer :

[3D]Représentation d'un type et de ses instances

[SCHEMA]Représentation d'un type et de ses instances

Type et sous-type : l’héritage

Generic System permet de créer très facilement un sous-type en spécialisant un type. Pour reprendre l’analogie avec le monde objet, un type serait une classe mère, et un sous-type serait une classe fille qui spécialise la classe mère.

Dans notre exemple, le type Vehicle peut être assimilé à une classe abstraite qui représente un véhicule générique : voiture, camion, moto, etc.
Nous pouvons donc compléter notre exemple en créant des sous-types de Vehicle : Car et Motorcycle

// Now, we want to create two kinds of vehicles: car and motorcycle
Generic motorcycle = engine.addInstance(vehicle, "Motorcycle");
Generic car = engine.addInstance(vehicle, "Car");

// Now, we want to create two kinds of vehicles: car and motorcycle

Generic motorcycle = engine.addInstance(vehicle, "Motorcycle");

Generic car = engine.addInstance(vehicle, "Car");

Comme vous l’avez constaté, il y a une petite subtilité lorsque l’on souhaite créer un sous-type. C’est toujours la méthode addInstance qui est appelée à partir d' engine, mais le nom du type est passé en paramètre. C’est comme si l’on demandait à Generic System de nous créer un nouveau type Car qui spécialise le type existant Vehicle.

Bien entendu, un sous-type peut être manipulé de la même façon qu’un type :

// Add new cars
Generic myCar = car.addInstance("myAudi");
Generic yourCar = car.addInstance("yourRenault");

// Add new motorcycles
Generic myMoto = motorcycle.addInstance("myYamaha");
Generic yourMoto = motorcycle.addInstance("yourBMW");

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

// Add new cars

Generic myCar = car.addInstance("myAudi");

Generic yourCar = car.addInstance("yourRenault");

// Add new motorcycles

Generic myMoto = motorcycle.addInstance("myYamaha");

Generic yourMoto = motorcycle.addInstance("yourBMW");

// Persist the changes

engine.getCurrentCache().flush();

Pour comparer avec l’exemple précédent, voici comment pourrait être représentée la structure que nous venons de créer :

Représentation d'un type et de sous-types dans Generic System

En résumé

Il est très facile de créer des types, des sous-types et des instances avec Generic System. Il suffit d’utiliser la méthode addInstance :

engine.addInstance("Vehicle") crée un nouveau type Vehicle ;
engine.addInstance(vehicle, "Car") crée un nouveau sous-type de vehicle appelé Car.
vehicle.addInstance("myVehicle") crée une instance de Vehicle ;
car.addInstance("myCar") crée une instance de Car.

En particulier, la gestion de l’héritage est beaucoup plus simple qu’en base de données relationnelle. En effet, pour l’exemple simple d’un type véhicule qui possède deux sous-type voiture et moto, on aurait le choix entre :

une table avec des redondances dans les données (parties spécifiques à voiture ou moto)
deux tables avec des redondances dans les données (partie spécifique à véhicule)
trois tables avec de nombreuses clés primaires et étrangères

Avec Generic System, on crée simplement un type et des sous-types, puis on ajoute les instances.

Articles qui pourraient vous intéresser :

Create, instance, subtype, Type