source: vlo/branches/vlo-3.3-oeaw/vlo-importer/src/main/java/eu/clarin/cmdi/vlo/importer/PostProcessorsWithVocabularyMap.java @ 6721

package eu.clarin.cmdi.vlo.importer;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import eu.clarin.cmdi.vlo.pojo.VariantsMap;
import eu.clarin.cmdi.vlo.pojo.VocabularyEntry;
import eu.clarin.cmdi.vlo.transformers.VariantsMapMarshaller;

/* 
 * abstract class that encapsulates common map creation from mapping files
 * for some postprocessors like LanguageCodePostProcessor*
 * 
 * brings one more level in class hierarchy between interface PostPorcessor and concrete implementations
 * 
 * @author dostojic
 * 
 */

public abstract class PostProcessorsWithVocabularyMap implements PostProcessor{
        
         private final static Logger _logger = LoggerFactory.getLogger(PostProcessorsWithVocabularyMap.class);
         
         private List<VocabularyEntry> map = null;
                 
        
         /*
          * This method is used for normalization of facet values based on normalization maps.
          * In case that value is not in the map, the input value is returned.
          * 
          * @param value - original value from record
          * @return normalized value if there is a match otherwise original value
          * 
          */
         public String normalize(String value){
                 return normalize(value, value);
         }
         
         
         /*
          * This method is used for normalization of facet values based on normalization maps.
          * With second parameter user can specify what to return in case when value is not in normalization map (special case for NationalProject facet).
          *  
          * @param value - original value from record
          * @param fallBackValue - value to be returned in case of no match
          * @return normalized value if there is a match otherwise returns what is specified with 2nd parameter
          * 
          */
         public String normalize(String value, String fallBackValue){
                 //init
                 if(map == null)
                         createMap();
                 
                 int ind = map.indexOf(value);
                 return (ind != -1)? map.get(ind).getNormalizedValue() : fallBackValue;
         }
         
         public  Map<String, String> getCrossMappings(String value){
                 
                 //init
                 if(map == null)
                         createMap();
                 
                 int ind = map.indexOf(value);
                 return (ind != -1)? map.get(ind).getCrossMap() : null; 
         }
         
         public abstract String getNormalizationMapURL();
         
         private void createMap(){
                 VariantsMap varinatsRawMap = getMappingFromFile(getNormalizationMapURL());
                 map = varinatsRawMap.getMap();
         }
         
         protected VariantsMap getMappingFromFile(String mapUrl){
                 try {
                        
                        _logger.info("Reading vocabulary file from: {}", mapUrl);
                    // load records from file
                        // in the future this should be loaded from CLAVAS directly and the file only used as fallback
                        
                        //InputStream is = PostProcessorsWithVocabularyMap.class.getClassLoader().getResourceAsStream(mapUrl);
                        InputStream is = new FileInputStream(new File(mapUrl));

                        
                        return VariantsMapMarshaller.unmarshal(is);                     
             } catch (Exception e) {
            throw new RuntimeException("Cannot instantiate postProcessor:", e);
         }
         }
         
         
         // for debug
         public void printMap(){
                 _logger.info("map contains {} entries", map.size());
                 for(VocabularyEntry entry: map)
                         _logger.info(entry.toString());
                
         }
}