Quadcap Embeddable Database

com/quadcap/util/Config.java

Go to the documentation of this file.

package com.quadcap.util;

/* Copyright 1999 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.File;
import java.io.FileInputStream;

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Properties;

/**
 * Central repository for configuration information. 
 *
 * @author Stan Bailes
 */
public class Config {
    private static final Hashtable      vars = new Hashtable();
    private static final Properties     vals = 
        new Properties(System.getProperties());
    private static final Object         lock = new Object();

    static {
        try {
            String filename = System.getProperty("config.props", 
                                                 "config.props");
            File f = new File(filename);
            if (f.canRead()) {
                FileInputStream fis = new FileInputStream(f);
                vals.load(fis);
                fis.close();
            }
        } catch (Throwable e) {
            Debug.print(e);
        }
    }

    public static void reset() {
        vars.clear();
        vals.clear();
    }
    
    public static final ConfigVar find(Class c, String name, String dflt) {
        synchronized (lock) {
            ConfigVar var = (ConfigVar)vars.get(name);
            if (var == null) {
                String val = vals.getProperty(name);
                if (val == null) val = dflt;

                try {
                    var = (ConfigVar)c.newInstance();
                    var.init(name, val);
                } catch (Exception e) {
                    Debug.print(e);
                    var = null;
                }
                if (var != null) vars.put(name, var);
            }
            return var;
        }
    }

    public static final ConfigVar find(String name) {
        synchronized (lock) {
            return (ConfigVar)vars.get(name);
        }
    }

    public static final String getProperty(String name) {
        ConfigVar f = find(name);
        if (f == null) {
            f = ConfigString.find(name, null);
        }
        return (f == null) ? null : f.getValue();
    }

    public static final String getProperty(String name, String dflt) {
        ConfigVar f = find(name);
        if (f == null) {
            f = ConfigString.find(name, dflt);
        }
        return (f == null) ? dflt : f.getValue();
    }

    public static Enumeration getMatchingProps(String pattern) {
        return getMatchingProps(vals, pattern);
    }
    
    /**
     * Assuming that <code>str</code> matches pattern <code>pat</code>,
     * with a wildcard character in the pattern, return the portion of the
     * string matching the wildcard.
     *
     * @param str the matched string
     * @param pat the pattern
     * @return the wildcard portion of the match.
     */
    public static String getMatch(String s, String p) {
        int pre = p.indexOf('*');
        int post = (p.length() - pre) - 1;
        s = s.substring(pre);
        s = s.substring(0, s.length() - post);
        return s;
    }

    public static Properties getPropSubset(Properties props,
                                           String pattern) {
        Properties np = new Properties();
        OctetString pat = new OctetString(pattern);
        final OctetComparator cmp = OctetComparator.cmp;

        Enumeration e = props.keys();
        while (e.hasMoreElements()) {
            String name = e.nextElement().toString();
            OctetString s = new OctetString(name);
            if (cmp.patternMatch(s, pat)) {
                np.put(getMatch(name, pattern), props.get(name));
            }
        }
        return np;
    }

    public static Properties getPropSubset(String pattern) {
        return getPropSubset(vals, pattern);
    }

    /**
     * Return an enumeration of property names which match a glob-style
     * pattern.  This is useful when properties are used to specify a
     * set, e.g., servlet.*.class=<i>name</i> or class.*.preload=true.
     *
     * @param props the property set to search
     * @param pattern the glob style pattern used by
     *     OctetComparator.patternMatch().
     * @return an Enumeration of the glob-matching part of each of the
     *     names matching the pattern
     */
    public static Enumeration getMatchingProps(Properties props,
                                               final String pattern) {
        final Enumeration e = props.keys();
        final OctetString p = new OctetString(pattern);
        final OctetComparator cmp = OctetComparator.cmp;
            
        return new Enumeration() {
            String                      next    = null;
            public boolean hasMoreElements() {
                while (next == null && e.hasMoreElements()) {
                    String s = e.nextElement().toString();
                    OctetString os = new OctetString(s);
                    if (cmp.patternMatch(os, p)) {
                        next = getMatch(s, pattern);
                    }
                }
                return next != null;
            }

            public Object nextElement() {
                Object ret = next;
                next = null;
                hasMoreElements();
                return ret;
            }
        };
    }

    public static Properties getProperties() {
        return vals;
    }
}