FORUM Tom's Hardware » Programmation » C / C++ / Java » [Java] Aide pour le démarrage d'un programme
 

[Java] Aide pour le démarrage d'un programme

Overclocking & Tuning : fifi2191 et 79 utilisateurs inconnus

 Mot :   Pseudo :  
 
Bas de page
Auteur
 Sujet : [Java] Aide pour le démarrage d'un programme
 
Man_Utd
Plus d'informations
n°22067
05-06-2006 à 09:06:41

Bonjour,
 
j'aurais besoin d'aide pour commencer mon projet
En espérant que vous puissiez m'apporter une aide.
 
PS :les interfaces imposées sont jointes au message
 
Merci par avance

Citation :


Description du Projet
 
Le programme Foogle (foo-google) est un programme qui crée un index à partir d'un fichier et qui permet de faire des requètes de recherche de mots en utilisant les opérateurs ET et OU pour trouver l'ensemble des lignes satisfaisant la requète.
 
 
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ésultat 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.
 
 
Architecture du Logiciel
 
Pour vous aidez et nous permettre de tester automatiquement votre logiciel,
un ensemble d'interface est imposée, vous ne devez en aucun cas toucher leur code.
Exemples d'utilisation des interfaces :
Création d'un index :

Code :
  1. FoogleFacade foogle=new FoogleFacadeImpl();
  2. ContextStrategy contextStrategy=
  3.     foogle.getContextStrategyMap().get("none" );
  5. Index index=foogle.createIndex(
  6.     new File("bbe.txt" ),contextStrategy);
  8. foogle.saveIndex(index,new File("bbe.idx" ));


 
Recherche dans un index :

Code :
  1. Index index2=foogle.loadIndex(new File("bbe.idx" ));
  2. System.out.println("indexed filename:"+index2.getFilename());
  4. QueryFactory factory2=foogle.createQueryFactory(index2);
  5. Query query2=factory2.and(factory2.query("God" ),
  6.     factory2.query("solid" ));
  8. ContextStrategy contextStrategy2=index2.getContextStrategy();
  9. for(Result result2:query2.execute(10)) {
  10.     System.out.println("line:"+result2.getLine());
  11.     System.out.println("ctx:"+contextStrategy2.getContext(result2));
  12. }

Man_Utd
Plus d'informations
n°22068
05-06-2006 à 09:06:57

Voici les différentes interfaces qui sont fournis avec l'énoncé

Code :
  1. import java.util.Collection;
  3. /** Represents a context strategy i.e. how to obtain a context
  4. *  of the indexed words.
  5. *   
  6. *  
  7. * @see FoogleFacade#getAllContextStrategies()
  8. * @see FoogleFacade#createIndex(ContextStrategy)
  9. */
  10. public interface ContextStrategy {
  11.   /** Retruns the name of the Strategy.
  12.    * @return the name of the current strategy.
  13.    */
  14.   public String getName();
  15.  
  16.   /** Returns the context of a result,
  17.    *  this result must be created by a query on an
  18.    *  index that use the current strategy.
  19.    *  
  20.    * @param result of a qery on an index that
  21.    *  used this strategy.
  22.    * @return an unmodifiable list of words representing
  23.    *  the context of the result.
  24.    *   
  25.    * @throws IllegalArgumentException if the result is not created
  26.    *  with an index using this strategy.
  27.    *   
  28.    *@see Index#getContextStrategy()
  29.    */
  30.   public Collection<? extends CharSequence> getContext(Result result);
  31. }
  37. import java.io.File;
  38. import java.io.IOException;
  39. import java.io.Reader;
  41. import java.util.Map;
  42. import java.util.regex.Pattern;
  44. /** Access point for creating, loading, saving foogle index and
  45. *  performs some queries on it.
  46. *  
  47. */
  48. public interface FoogleFacade {
  49.   /** Creates an in-memory index with a specified strategy
  50.    *  and appends all words extracted of a specific file.
  51.    * @param strategy the context strategy used to create the index.
  52.    * @param file all words of the file will be appended in the index.  
  53.    * @return a new in-memory index.
  54.    * @throws IOException if the file doesn't exists or is unreadable.
  55.    */
  56.   public Index createIndex(File file,ContextStrategy strategy) throws IOException;
  57.  
  58.   /** Creates an in-memory index with a specified strategy
  59.    *  and appends all words extracted of a specific file.
  60.    *  All words are appended with the line of the reader and the specifed filename.  
  61.    *   
  62.    *  Words are separated using the java whitespace rule
  63.    *  <code>\p{javaWhitespace}</code> (see {@link Pattern})
  64.    *  and word are indexed is its length is greater or equals to 3.  
  65.    *   
  66.    * @param strategy the context strategy used to create the index.
  67.    * @param filename filename used for all word from the reader.
  68.    * @param reader all words contained in the reader will be appended line by line
  69.    *  in the index.  
  70.    * @return a new in-memory index.
  71.    * @throws IOException if the file doesn't exists or is unreadable.
  72.    *  
  73.    */
  74.   public Index createIndex(String filename,Reader reader,ContextStrategy strategy) throws IOException;
  75.  
  76.   /** Creates an in-memory index with a specified strategy
  77.    *  and appends all words extracted of a specific file in the specified index.
  78.    *  All words are appended with the line of the reader and the specifed filename.  
  79.    * @param strategy the context strategy used to create the index.
  80.    * @param filename filename used for all word from the reader.
  81.    * @param reader all words contained in the reader will be appended line by line
  82.    *        in the index.  
  83.    * @param accepter specifies how to separate word in the reader and
  84.    *        which words are indexable.
  85.    * @return a new in-memory index.
  86.    * @throws IOException if the file doesn't exists or is unreadable.
  87.    *  
  88.    * @see  
  89.    */
  90.   public Index createIndex(String filename,Reader reader,WordAccepter accepter,ContextStrategy strategy) throws IOException;
  92.  
  93.   /** Loads an index stored in a file in memory.
  94.    * @param indexFile file that store the index.
  95.    * @return an in-memory index corresponding to the file.
  96.    * @throws IOException raised if there is input/output problems.
  97.    */
  98.   public Index loadIndex(File indexFile)  throws IOException;
  99.  
  100.   /** Saves an index in a spacific file.
  101.    * @param index the index to store.
  102.    * @param indexFile file that will store the index.
  103.    * @throws IOException raised if there is input/output problems.
  104.    */
  105.   public void saveIndex(Index index,File indexFile) throws IOException;
  106.  
  107.   /** Returns a query factory specific to an index.
  108.    * @param index the queries will be created on this index.
  109.    * @return a new query factory.
  110.    *  
  111.    * @see Query#execute(int)
  112.    */
  113.   public QueryFactory createQueryFactory(Index index);
  114.  
  115.   /** Returns all context strategies understood by the facade.
  116.    *  This method must returned at least the "none" context strategy.
  117.    * @return an unmodifiable map of context strategies associated
  118.    *  with their names.
  119.    */
  120.   public Map<String,? extends ContextStrategy> getContextStrategyMap(); 
  121. }
  128. /** Represents an index of Foogle.
  129. *  
  130. *  
  131. */
  132. public interface Index {
  133.   /** Returns the name of the indexed file.
  134.    * @return the name of the indexed file.
  135.    */
  136.   public String getFilename();
  137.  
  138.   /** Returns the context startegy used by the current index.
  139.    * @return the context strategy.
  140.    *  
  141.    * @see FoogleFacade#createIndex(ContextStrategy)
  142.    * @see FoogleFacade#getAllContextStrategies()
  143.    */
  144.   public ContextStrategy getContextStrategy();
  145. }
  155. /** Represents a query to an index.
  156. *  The query is specific to an index.
  157. *   
  158. *  
  159. * @see QueryFactory
  160. * @see FoogleFacade#createQueryFactory(Index)
  161. */
  162. public interface Query {
  163.   /** Query the index to find results corresponding to a
  164.    *  specific query.
  165.    *  
  166.    * @return the result of the query.
  167.    *  
  168.    * @see Query#execute(int)
  169.    */
  170.   public Iterable<? extends Result> execute();
  171.  
  172.   /** Query the index to find results corresponding to a
  173.    *  specific query.
  174.    *   
  175.    *  @param maxCount a positive integer  
  176.    *  
  177.    * @return the result of the query.
  178.    *  
  179.    * @see QueryFactory
  180.    * @see FoogleFacade#createQueryBuilder(String)
  181.    */
  182.   public Iterable<? extends Result> execute(int maxCount);
  183. }
  190. import java.util.regex.Pattern;
  192. /** Factory used to create index queries,
  193. *  The factory is specific to an index.
  194. *   
  195. *  All results returned by {@link Query#execute()}
  196. *  on these queries are garanteed to have distinct
  197. *  line numbers (see {@link Result#getLine()}).
  198. *
  199. */
  200. public interface QueryFactory {
  201.   /** Creates a query for a simple word.
  202.    *  
  203.    * @param word the queried word.
  204.    * @return a new query.
  205.    */
  206.   public Query query(CharSequence word);
  207.  
  208.   /** Creates a query for a regex.
  209.    *  
  210.    * @param pattern the queried regex.
  211.    * @return a new query.
  212.    */
  213.   public Query query(Pattern pattern);
  214.  
  215.   /** Create a new query by oring query1 and query2.
  216.    *   
  217.    * @param query1 the first query.
  218.    * @param query2 the second query.
  219.    * @return the new query.
  220.    */
  221.   public Query or(Query query1,Query query2);
  222.  
  223.   /** Create a new query by anding query1 and query2.
  224.    * @param query1 the first query.
  225.    * @param query2 the second query.
  226.    * @return the new query.
  227.    */
  228.   public Query and(Query query1,Query query2);
  229. }
  237. /** Result of a query, represents a location in a line of a file.
  238. *  
  239. *  A result can have a specific context value associated with it
  240. *  depending on the index strategy, use  
  241. *  {@link ContextStrategy#getContext(Result)} to obtain such context.
  242. *  
  243. *  
  244. * @see Index#executeQuery(Query)
  245. */
  246. public interface Result {
  247.   /** Returns the line number containing
  248.    *  the result
  249.    * @return a line number.
  250.    */
  251.   public int getLine();
  252. }
  260. import java.util.Scanner;
  261. import java.util.regex.Pattern;
  263. /** This interface specifies
  264. *  how words are delimited in a text
  265. *  using a regex pattern
  266. *  {@link #getDelimiterRegex()}
  267. *  and which word are indexed
  268. *  {@link #isIndexable(CharSequence)}.
  269. *  
  270. */
  271. public interface WordAccepter {
  272.   /** Returns the regex pattern used to separate words.
  273.    * @return a regex pattern.
  274.    *  
  275.    * @see Scanner#useDelimiter(Pattern)
  276.    */
  277.   public Pattern getDelimiterRegex();
  278.  
  279.   /** Indicates if a word should be indexed or not.
  280.    * @param word the word
  281.    * @return true if the word is indexable, false otherwise.
  282.    */
  283.   public boolean isIndexable(CharSequence word);
  284. }
KangOl
Profil : Pointeur
Plus d'informations
n°22074
05-06-2006 à 11:18:32

non, on fait pas de résoltution d'exercice ici :o
 
commence toi meme (si on t'as donné cet exercice c'est que tu es censé avoir le niveau) et reviens si tu as des problèmes


---------------
Da Bidz Triad©®™: Bidz Interceptor
.:: Smileyz version 4.2 [050625]::. -- Code source disponible sous licence GPL.
[u

Aller à :
  FORUM Tom's Hardware » Programmation » C / C++ / Java » [Java] Aide pour le démarrage d'un programme
 

Plan du forum
Forum MesDiscussions.Net, Version 2007.1.2
© 2000-2007 No1Dev
Page générée en 0.300 secondes
Annonces Google
Produits relatifs
Publicité
Sujets relatifs
voir tout
Actualités relatives
Les dernières actualités
voir tout
Les derniers tests
voir tout
Les ressources relatives
Les téléchargements