/branches/v2_0_0_prep/libraries/libGeocoding/src/org/gvsig/geocoding/impl/LuceneGeocoderImpl.java - Diff - Application: gvSIG desktop - gvSIG

Revision 32088 branches/v2_0_0_prep/libraries/libGeocoding/src/org/gvsig/geocoding/impl/LuceneGeocoderImpl.java

     import org.gvsig.geocoding.address.ComposedAddress;
     import org.gvsig.geocoding.address.Literal;
     import org.gvsig.geocoding.address.NumberAddress;
     import org.gvsig.geocoding.index.FeatureIndexedEvent;
     import org.gvsig.geocoding.index.IndexListener;
     import org.gvsig.geocoding.pattern.GeocodingPattern;
     import org.gvsig.geocoding.result.GeocodingResult;
     import org.gvsig.geocoding.result.ScoredFeature;
-...
     	private Logger log = LoggerFactory.getLogger(LuceneGeocoderImpl.class);
     	private GeocodingPattern pattern = null;
     	private DataStore store = null;
     	@SuppressWarnings("unused")
     	private DataManager manager = null;
     	private int position = 0;
     	private IndexListener indexListener;
     	/*
     	 * This path is a temporal folder. This code is a copy of the
     	 * libRemoteServices and LibRaster
-...
+    	}
     	/**
     	 * Geocoding process
+    	 *
     	 * @param address
     	 * @return results
     	 */
     	public Set<GeocodingResult> geocode(Address address)
     			throws LocatorException, DataException {
-...
+    	}
     	/**
     	 * First scouting process, search literal elements in data store and return
     	 * a list with ok scored features
+    	 *
     	 * @param relationsLiteral
     	 * @param addressLiteral
-...
     		double minScore = getPattern().getSettings().getScore();
     		// Create index writer
     		IndexWriter indexWriter = null;
     		try {
     			indexWriter = createIndex(store, relationsLiteral);
     		} catch (Exception e) {
     			log.error("Error creating index", e);
+    		}
     		// if index writer is not null run search process
     		if (indexWriter != null) {
     			// search
     			Hits hits = null;
     		// search
     		Hits hits =  seachOnIndex(relationsLiteral, addressLiteral);
     		// if there are hits in search process
     		if (hits != null) {
     			// filter results
     			try {
     				hits = seachOnIndex(relationsLiteral, addressLiteral);
     				scorefeats = filterHitsByScore(store, hits, minScore);
     			} catch (Exception e) {
     				log.error("Error searching on index", e);
     				log.error("Error filtering hits by score", e);
     				scorefeats.clear();
+    			}
     			// if there are hits on search process
     			if (hits != null || hits.length() > 0) {
     				// filter
     				try {
     					scorefeats = filterHitsByScore(store, hits, minScore);
     				} catch (Exception e) {
     					log.error("Error filtering hits by score", e);
+    				}
+    			}
+    		}
     		return scorefeats;
-...
     	 * @param relationsLiteral
     	 * @param addressLiteral
     	 * @return
     	 * @throws CorruptIndexException
     	 * @throws IOException
     	 * @throws ParseException
     	 */
     	private Hits seachOnIndex(Literal relationsLiteral, Literal addressLiteral)
     			throws CorruptIndexException, IOException, ParseException {
+    			 {
     		log.info("Buscar ...");
     		IndexSearcher searcher = new IndexSearcher(tempDirectoryPath);
     		IndexSearcher searcher = null;
     		try {
     			searcher = new IndexSearcher(tempDirectoryPath);
     		} catch (Exception e) {
     			log.debug("Error building index searcher", e);
     			log.debug("Rebuild the index file because the initial index is wrong");
     			try {
     				this.indexer(store, relationsLiteral);
     			} catch (Exception e1) {
     				log.debug("Error building index searcher", e1);
     				return null;
+    			}
+    		}
     		if (searcher != null) {
     			String[] input = addressLiteral.getStringValuesArray();
     			String[] fields = relationsLiteral.getStringValuesArray();
     		String[] input = addressLiteral.getStringValuesArray();
     		String[] fields = relationsLiteral.getStringValuesArray();
     		Query query = MultiFieldQueryParser.parse(input, fields,
     				new StandardAnalyzer());
     		Hits hits = searcher.search(query);
     		return hits;
     			Query query = null;
     			try {
     				query = MultiFieldQueryParser.parse(input, fields,
     						new StandardAnalyzer());
     			} catch (ParseException e) {
     				log.debug("Error building the query", e);
     				return null;
+    			}
     			Hits hits = null;
     			if(query != null){
     				try {
     					hits = searcher.search(query);
     				} catch (IOException e) {
     					log.debug("Error in the searching process", e);
     					return null;
+    				}
+    			}
     			return hits;
     		} else {
     			return null;
+    		}
+    	}
     	/**
+    	 *
     	 * @param store
     	 * @param hits
     	 * @param score
     	 * @return
     	 * @throws IOException
     	 * @throws DataException
-...
     		FeatureStore fstore = (FeatureStore) store;
     		List<ScoredFeature> scoreFeats = new ArrayList<ScoredFeature>();
     		for (int i = 0; i < hits.length(); i++) {
     			if (hits.score(i) > score) {
     			if (hits.score(i) * 100 > score) {
     				Document doc = hits.doc(i);
     				String id = doc.get(GeocoID);
     				FeatureSet fset = fstore.getFeatureSet();
-...
+    	 *
     	 * @param store
     	 * @param relationsLiteral
     	 * @return
     	 * @throws DataException
     	 * @throws CorruptIndexException
     	 * @throws LockObtainFailedException
     	 * @throws IOException
     	 */
     	private IndexWriter createIndex(DataStore store, Literal relationsLiteral)
     	public void indexer(DataStore store, Literal relationsLiteral)
     			throws DataException, CorruptIndexException,
     			LockObtainFailedException, IOException {
     		log.info("Create indexes ...");
     		log.debug("Create indexes ...");
     		IndexWriter indexWriter = new IndexWriter(tempDirectoryPath,
     				new StandardAnalyzer(), true);
-...
     		Feature feat = null;
     		Iterator it = features.fastIterator();
     		// process situation
     		this.position = 0;
     		while (it.hasNext()) {
     			Document doc = new org.apache.lucene.document.Document();
-...
     				doc.add(field);
+    			}
     			indexWriter.addDocument(doc);
     			// throw indexed event
     			if(this.indexListener != null){
     				this.indexListener.featureIndexed(new FeatureIndexedEvent(this));
+    			}
     			// new position
     			this.position++;
+    		}
     		indexWriter.optimize();
     		return indexWriter;
+    	}
     	/**
+    	 *
     	 * @param listener
     	 */
     	public void registreIndexListener(IndexListener listener){
     		this.indexListener = listener;
+    	}
     	/**
+    	 *
     	 * @return
     	 */
     	public int getIndexPosition() {
     		return position;
+    	}
+    }

Also available in: Unified diff