Subversion Repositories SmartDukaan

/*
 *      Copyright 2005 stat4j.org
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *      You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */

 package net.sourceforge.stat4j.filter;

import java.text.DecimalFormat;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import net.sourceforge.stat4j.util.Util;

/**
 * Name:                RegExpScraper.java
 * Date:                Sep 4, 2004
 * Description:
 * 
 * Class that implements basic scraping logic given a scap pattern 
 * conforming to standard regular expressions.
 * 
 * For example:         
 *      
 * pattern:             
 * text:
 * value:
 * 
 * @author Lara D'Abreo
 */

public class RegExpScraper  {

        protected String decimalFormat = null;
        // A Cache of precompiled scrap patterns, this is
        // loaded on demand
        protected Map patterns;
        // As Formatters are not threadsafe we use ThreadLocal
        // to guaranttee one (and only on instance per Thread).
        protected ThreadLocal format = new ThreadLocal() {
                protected synchronized Object initialValue() {
                        if (decimalFormat == null)
                                return new DecimalFormat();
                        else
                                return new DecimalFormat(decimalFormat);
                }
        };


        public RegExpScraper() {
                patterns = new HashMap();
                decimalFormat = Util.getValue("decimalformat");
        }
        
        
        public Double scrapUserDefinedValue(String text, String pattern) {
                        System.out.println(text);
                        System.out.println(pattern);
                // if the text is empty or null just return no reading
                if ((text == null)
                        || (text.length() == 0)
                        || (pattern == null)
                        || (pattern.length() == 0)) {
                        return null;
                }
                // get pre-compiled pattern, compile one if it isnt available
                Pattern p  = getPattern(pattern);
                
                // Create a matcher
                Matcher m = p.matcher(text);
                
                try {
                        if (!m.matches())
                                return null;
                                
                        // Get first match group
                        String str = m.group(1);
                        System.out.println(str);
                        // Use the formater to parse out the value . The formatter will
                        // take account of the country specific formatting of the number
                        // whereas Double.parse will not.
                        // Any extraneous text after the number (if it is present) will be ignored
                        // by the formatter. This means we can be lazy with what the str ends with
                        DecimalFormat df = (DecimalFormat) format.get();
                        Number value = df.parse(str);
                        return new Double(value.doubleValue());
                } catch (Exception ex) {
                        return null;
                }

        }

        public final Pattern getPattern(String regexp) {

                Pattern pattern = (Pattern) patterns.get(regexp);
                if (pattern == null) {
                        pattern = Pattern.compile(regexp);
                        patterns.put(regexp, pattern);
                }
                return pattern;

        }

        public void dispose() {
                patterns.clear();
                format = null;
        }
        
        
        public static void main(String[] args) {
                try {
                        RegExpScraper scraper = new RegExpScraper();
                        
                        String pattern = ".*post=([0-9].*)+";
                        String log = "Time to process post=1.0";
                        
                        Double value = scraper.scrapUserDefinedValue(log,pattern);
                        
                        System.out.println("Scrape Value=" + value);
                }catch (Exception e) {
                        e.printStackTrace();
                }
                
        }

        

}