Create

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.

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

Create, instance, subtype, Type

Les bases – Création de relations et de links

Introduction

Generic System permet de créer des types, des sous-types et des instances. Il est aussi possible de créer des attributs et des propriétés, et de leur attribuer des valeurs en créant des holders.

Mais comment relier les types entre eux ? Il existe pour cela des relations et des liens (links). Les relations peuvent impliquer plusieurs éléments :

binaire (2 éléments) ;
ternaire (3 éléments) ;
…
n-aire (n éléments).

Contrairement aux bases de données relationnelles, la gestion des relations n-aires est particulièrement simple avec Generic System.

Nous allons poursuivre cette démonstration avec notre exemple de l’article Les bases – Création de types, de sous-types et d’instances.

Cas simple : relation binaire

Une relation binaire nous permet de relier deux types. Pour reprendre notre exemple, on peut imaginer que nos véhicules possèdent une couleur.

Création de la relation

Nous allons donc créer un nouveau type Color ainsi que deux instances red et yellow :

// Create a new type (Color) and a few instances (colors)
Generic color = engine.addInstance("Color");
Generic red = color.addInstance("red");
Generic yellow = color.addInstance("yellow");

// Create a new type (Color) and a few instances (colors)

Generic color = engine.addInstance("Color");

Generic red = color.addInstance("red");

Generic yellow = color.addInstance("yellow");

Continue reading Les bases – Création de relations et de links

Create, Link, Relation

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é – Relations : OneToOne, OneToMany, ManyToOne et ManyToMany

Nous allons aborder un chapître assez simple, où nous allons revenir plus en détail sur les relations. Pour cela, assurez-vous d’avoir bien compris les notions de relations et de contraintes. Si ce n’est pas le cas, vous pouvez consulter les articles qui en parlent :

Avant de commencer, précisons que le thème que nous allons traiter dans ce chapître sera présenté pour les relations binaires, mais qu’il peut également être étendu aux relations n-aires.

Préparons le terrain

Avant d’aborder plus en profondeur les relations, il vous faut apprendre une nouvelle notion. Rassurez-vous, celle-ci est simple à comprendre.

Savez-vous ce qu’on appelle l’axe d’une relation dans Generic System ?

Il s’agit du type situé à la position i de la relation, i étant le numéro de l’axe. Appliquons cela à notre relation bien connue VehicleColor.

L’axe 0 de VehicleColor est Vehicle puisqu’il est à la position 0 dans la relation.
L’axe 1 est quand à lui Color puisque situé à la position 1 de la relation.

Enfin, retenez bien 2 termes : la base désigne l’axe 0 d’une relation, les targets désignent les autres axes de la relation.
Ainsi, la target 1 est l’axe 1 de la relation, la target 2 désigne l’axe 2 de la relation, et ainsi de suite.

Les différents types de relation

Il existe 4 types de relation : OneToOne, OneToMany, ManyToOne, ManyToMany.
Nous allons voir chacune d’elles et utiliser pour cela la SingularConstraint.

Continue reading Avancé – Relations : OneToOne, OneToMany, ManyToOne et ManyToMany

axe, base, Create, Relation, SingularConstraint, target

Avancé – La gestion des Tree

Generic System permet de persister des arbres. Pour commencer nous avons besoin de créer un arbre, puis de l’instancier. Une instance sans super est interprétée par Generic System comme la racine de l’arbre. Pour ajouter une feuille ou une branche à un nœud, il faut créer une instance de l’arbre en précisant ce nœud comme super.

Premier exemple

Tout développeur web connaît la structure de base d’une page web. Voyons comment créer un arbre HTML simple avec Generic System :

Engine engine = new Engine();

// Create a tree called tags
Generic tags = engine.addInstance("Tags");

// Create the root html
Generic html = tags.addInstance("html");

// Create the children header, body and footer
Generic head = tags.addInstance(html, "header");
Generic body = tags.addInstance(html, "body");
Generic foot = tags.addInstance(html, "footer");

// Create the children p and table for the node body
tags.addInstance(body, "p");
tags.addInstance(body, "table");

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

Engine engine = new Engine();

// Create a tree called tags

Generic tags = engine.addInstance("Tags");

// Create the root html

Generic html = tags.addInstance("html");

// Create the children header, body and footer

Generic head = tags.addInstance(html, "header");

Generic body = tags.addInstance(html, "body");

Generic foot = tags.addInstance(html, "footer");

// Create the children p and table for the node body

tags.addInstance(body, "p");

tags.addInstance(body, "table");

// Persist changes

engine.getCurrentCache().flush();

Continue reading Avancé – La gestion des Tree

Create, inheritance, Node, pass through, Tree

Tag: Create

Introduction

Qu’est-ce qu’un Generic ?

Démarrage de Engine

Introduction

Cas simple : relation binaire

Création de la relation

Engine

Préparons le terrain

Les différents types de relation

Premier exemple