Définition du TypeSystem

La construction d'un TypeSystem a de particulier l'utilisation du super type FSArray.

Tout d'abord il est nécessaire de créer un nouveau type d'annotation, disons MyEmbeddedType, correspondant aux annotations stockées dans le tableau. Rien de particulier concernant ce type si ce n'est qu'il faut le créer avant le type contenant le tableau.

Il est ensuite possible de créer le type dérivant du super type FSArray, disons MyComplexType. C'est ce type qui contient un attribut regroupant des annotations MyEmbeddedType sous la forme d'un tableau. Rien de spécial concernant le type en lui-même, il faut lui ajouter un attribut ayant pour range type FSArray et element type MyEmbeddedType.

Rien de bien complexe donc concernant la création du TypeSystem, si ce n'est qu'il faut tout de même savoir comment ça fonctionne :)

Construction

Pour comprendre le fonctionnement des types à tableaux de type, il faut bien comprendre que FSArray se comporte comme un Array statique en Java.

  1. // Préparation de la donnée tableau factice, c'est pour l'exemple
  2. ArrayList<MyEmbeddedType> lst = new ArrayList<MyEmbeddedType>();
  3. for(int i ; i<10 ; i++) {
  4. MyEmbeddedType mEType = new MyEmbeddedType(cas);
  5. // ... faire quelque chose avec mEType
  6. mEType.addToIndexes();
  7. lst.add(mEType);
  8. }
  9. // Transformation en tableau "statique"
  10. MyEmbeddedType[] mETypes = lst.toArray(new MyEmbeddedType[lst.size()]);
  11. // Création du FSArray
  12. FSArray mETypesFS = new FSArray(cas, mETypes.length);
  13. mETypesFS.copyFromArray(mETypes, 0, 0, mETypes.length);
  14. // Création d'une instance du type complexe et ajout du contenu
  15. MyComplexType mCType = new MyComplexType(cas);
  16. mCType.setMyComplexFeature( mETypesFS );

L'approche proposée ici est de construire un tableau au travers d'une ArrayList dans un premier temps, y ajouter les éléments voulus et faire toutes les opérations nécessaires jusqu'à ce que le contenu soit stabilisé. Il faut garder en tête que l'enregistrement en tant qu'annotation n'a d'intérêt que pour stocker la donnée dans le CAS, i.e. la transmettre aux autres composants de la chaîne.

Une fois le ArrayList construit, il faut le transformer en tableau statique et le copier dans une instance de FSArray à l'aide de la méthode copyFromArray(). Cette dernière prend en paramètre le tableau statique, l'index du tableau à partir duquel recopier le contenu, l'index dans le FSArray à partir duquel recopier les données et le nombre d'entrées à recopier. Dans le code ci-dessus, on recopie l'intégralité du tableau mETypes dès le début du FSArray.

Parcours

Une fois le tableau annoté dans le CAS, l'intérêt est de pouvoir y accéder par les autres composants de la chaîne. La récupération d'annotations de type FSArray n'est pas très différente d'un parcours classique.

  1. // On récupère l'index classique pour obtenir un itérateur
  2. AnnotationIndex arrIdx = (AnnotationIndex) jcas.getAnnotationIndex(MyComplexType.type);
  3. FSIterator arrIt = arrIdx.iterator();
  4. while( arrIt.hasNext() ) {
  5. // On récupère l'annotation complexe
  6. MyComplexType m = (MyComplexType) arrIt.next();
  7. // ... et surtout le FSArray qu'il contient
  8. FSArray marray = m.setMyComplexFeature();
  9. // Désormais il suffit de convertir l'annotation en Array java et l'utiliser telle quelle, par exemple :
  10. for(FeatureStructure elt: marray.toArray()) {
  11. MyEmbeddedType item = (MyEmbeddedType) elt;
  12. // amusez-vous avec ;)
  13. }
  14. }

Le parcours se fait donc plus ou moins de la même manière qu'une annotation classique, il faut toutefois penser à :

  1. Convertir le FSArray en un tableau Java classique
  2. Passer par l'intermédiaire d'instances de FeatureStructure lors du parcours du tableau si nécessaire avant de récupérer le type désiré (MyEmbeddedType dans le cas présent).