Qu'est-ce que ça signifit ?

Ligne de Commande du Logiciel

Le logiciel doit se présenter sous la forme d'un jar exécutable.
La ligne de commande permet de créer l'index ou d'effectuer des requêtes sur un index déjà crée

java -jar foogle.jar [index|query] [option spécifique dépendant de index ou query]
index :
java -jar foogle.jar index [-strategy name] [-minlength length]fichier.ext
crée un index à partir d'un fichier.ext, le nom du fichier sera fichier.ext.idx
-minlength indique le nombre de lettre minimum du mot pour qu'il appartienne
à l'index.
-strategy permet de spécifier une stratégie de contexte par son nom.

Le contexte correspond aux mots avant et après un mot recherché.
(par défaut: none)
La stratégie "none" indique que le contexte (la ligne ou une partie de la ligne n'est pas stockée dans l'index.
La stratégie "near" indique que le contexte correspond au mot précédent ainsi qu'au mot suivant le mot courant.

Exemple de résulta avec un contexte "near", avec le fichier :
hello toto how are you ?
well, i'm fine, well Dee fine.

Pour la requête toto & how (les contextes sont agglomérés):
line 1: hello toto how are

Pour la requête fine (le mots fine est présent plusieurs fois):
line 2: well fine well ... Dee fine

De façon optionnel vous pouvez ajouter un contexte intelligent.

query :
java -jar foogle.jar query [-n count] fichier.ext.idx expr
effectue une requête expr sur l'index fichier.ext.idx et affiche l'ensemble des lignes satisfaisant la requête.
-n permet de spécifier le nombre de résultat voulu.
Les requêtes sur l'index correspond à un arbre au format préfixé,
exemple "& toto | titi @t?t?" est équivalent à l'arbre
 
          &
toto            | 
        titi           @t?t?
L'opérateur ET ('&') reporte la ligne uniquement si les deux mots
appartiennent à la ligne.
L'opérateur OU ('|') reporte la ligne si un des deux mots appartient à la ligne.
L'opérateur @ permet d'indiquer une expression régulière (au format PERL) pour rechercher les mots.
De façon optionnel, il est possible dans le cas des OU lorsque l'on fixe le nombre de résultat voulu de ne pas calculer l'ensemble de tous les résultats possibles. De plus, lors de requête concernant beaucoup de résultat possible, il
est possible de manipuler des itérateurs plutôt que des listes pour éviter d'avoir de grosses structures de données intermédiaires.

import java.util.Collection;
public interface ContextStrategy {
  public String getName();
  
  public Collection<? extends CharSequence> getContext(Result result);
}

--------------------------------------------------------------------------

import java.io.File;
import java.io.IOException;
import java.io.Reader;

import java.util.Map;
import java.util.regex.Pattern;


public interface FoogleFacade {
  public Index createIndex(File file,ContextStrategy strategy) throws IOException;
  
  public Index createIndex(String filename,Reader reader,ContextStrategy strategy) throws IOException;
  
  public Index createIndex(String filename,Reader reader,WordAccepter accepter,ContextStrategy strategy) throws IOException;

  public Index loadIndex(File indexFile)  throws IOException;
  
  public void saveIndex(Index index,File indexFile) throws IOException;
  
  public QueryFactory createQueryFactory(Index index);
  
  public Map<String,? extends ContextStrategy> getContextStrategyMap();  
}


public interface Index {
  public String getFilename();
  
  public ContextStrategy getContextStrategy();
}


public interface Query {
  public Iterable<? extends Result> execute();

  public Iterable<? extends Result> execute(int maxCount);
}

--------------------------------------------------------------------------

import java.util.regex.Pattern;

public interface QueryFactory {
 
  public Query query(CharSequence word);
  
  public Query query(Pattern pattern);
  
  public Query or(Query query1,Query query2);
  
  public Query and(Query query1,Query query2);
}


public interface Result {
  public int getLine();
}

--------------------------------------------------------------------------

import java.util.Scanner;
import java.util.regex.Pattern;


public interface WordAccepter {
 
  public Pattern getDelimiterRegex();
  
  public boolean isIndexable(CharSequence word);
}