Package com.clarkparsia.empire.config.io.impl

Source Code of com.clarkparsia.empire.config.io.impl.PropertiesConfigReader

/*
* Copyright (c) 2009-2010 Clark & Parsia, LLC. <http://www.clarkparsia.com>
*
* 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 com.clarkparsia.empire.config.io.impl;

import com.clarkparsia.empire.config.EmpireConfiguration;
import com.clarkparsia.empire.config.ConfigKeys;
import com.clarkparsia.empire.config.io.ConfigReader;
import com.clarkparsia.empire.util.EmpireAnnotationProvider;
import com.clarkparsia.empire.util.BeanReflectUtil;
import com.complexible.common.util.EnhancedProperties;
import com.google.common.collect.Collections2;
import com.google.common.base.Predicate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Properties;
import java.util.Map;
import java.util.HashMap;
import java.io.IOException;
import java.io.Reader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
* <p>Implementation of a {@link ConfigReader} for reading an Empire configuration from a standard properties file.</p>
*
* @author  Michael Grove
* @since   0.6.2
* @version 0.7
* @see EmpireConfiguration
*/
public class PropertiesConfigReader implements ConfigReader, ConfigKeys {

  /**
   * The logger
   */
  private static final Logger LOGGER = LoggerFactory.getLogger(ConfigReader.class.getName());

  public static final String KEY_NAME = ConfigKeys.NAME;
  public static final String KEY_ANNOTATION_PROVIDER = "annotation.provider";

  /**
   * @inheritDoc
   */
  public EmpireConfiguration read(InputStream theStream) throws IOException {
    return read(new InputStreamReader(theStream));
  }

  /**
   * @inheritDoc
   */
  public EmpireConfiguration read(Reader theReader) throws IOException {
    Properties aProps = new EnhancedProperties();

    try {
      aProps.load(theReader);
    }
    catch (Exception e) {
      throw new IOException(e);
    }

    int aIndex = 0;

    Map<String, String> aGeneralConfig = new HashMap<String, String>();
    Map<String, Map<String, String>> aUnitConfig = new HashMap<String, Map<String, String>>();

    while (aProps.containsKey(aIndex+"."+KEY_NAME)) {
      String aPrefix = aIndex+".";
      Map<String, String> aUnit = new HashMap<String, String>();
     
      for (Object aOrigKey : Collections2.filter(aProps.keySet(), new PrefixPredicate(aPrefix))) {
        String aKey = aOrigKey.toString();

        aKey = aKey.substring(aPrefix.length());

        aUnit.put(aKey, aProps.getProperty(aOrigKey.toString()));
      }

      aUnitConfig.put(aProps.getProperty(aIndex+"."+KEY_NAME), aUnit);

      aIndex++;
    }

    for (Object aOrigKey : Collections2.filter(aProps.keySet(), new UnitFilterPredicate())) {
      aGeneralConfig.put(aOrigKey.toString(), aProps.getProperty(aOrigKey.toString()));
    }

    EmpireConfiguration aConfig = new EmpireConfiguration(aGeneralConfig, aUnitConfig);

    if (aGeneralConfig.containsKey(KEY_ANNOTATION_PROVIDER)) {
      try {
        @SuppressWarnings("unchecked")
        Class<EmpireAnnotationProvider> aClass = (Class<EmpireAnnotationProvider>) BeanReflectUtil.loadClass(aGeneralConfig.get(KEY_ANNOTATION_PROVIDER));

        aConfig.setAnnotationProvider(aClass);
      }
      catch (ClassNotFoundException e) {
        LOGGER.warn("Annotation provider implementation '{}' cannot be found, please check your classpath.", aGeneralConfig.get(KEY_ANNOTATION_PROVIDER));
      }
      catch (ClassCastException e) {
        LOGGER.warn("Specified annotation provider implementation '{}' is not a valid EmpireAnnotationProvider.", aGeneralConfig.get(KEY_ANNOTATION_PROVIDER));
      }
    }

    return aConfig;
  }

  /**
   * Filter for returning only non-unit property keys
   */
  private static class UnitFilterPredicate implements Predicate<Object> {

    /**
     * @inheritDoc
     */
    public boolean apply(final Object theValue) {
      String aStr = theValue.toString();

      // the standard format for unit properties in the file is <index>.<property_name>
      // all these properties have been put into the appropriate unit config map.
      // so we want to get rid of them and only include the properties which do not
      // fit this format in the general config.  if they don't have a period, they are
      // fine, and if they do have a period, but the stuff before the period is not a
      // number, that's good too.  otherwise, it's a unit property or something that
      // *looks* like a unit property, so we'll filter that out

      if (aStr.indexOf(".") == -1) {
        return true;
      }
      else {
        String aPrefix = aStr.substring(0, aStr.indexOf("."));
        try {
          Integer.parseInt(aPrefix);
          return false;
        }
        catch (NumberFormatException e) {
          return true;
        }
      }
    }
  }

  /**
   * Filter for only returning values whose toString() starts with the specified prefix.  Used to filter out
   * property keys not in the current unit.
   */
  private static class PrefixPredicate implements Predicate<Object> {
    private String mPrefix;

    private PrefixPredicate(final String thePrefix) {
      mPrefix = thePrefix;
    }

    /**
     * @inheritDoc
     */
    public boolean apply(final Object theValue) {
      return theValue.toString().startsWith(mPrefix);
    }
  }

  public static void main(String[] args) throws Exception {
    String aConfig = "annotation.provider = com.clarkparsia.empire.util.PropertiesAnnotationProvider\n" +
             "0.name = context1\n" +
             "0.factory = com.clarkparsia.empire.sesame.RepositoryDataSourceFactory\n" +
             "0.url = http://localhost:8080/openrdf-sesame\n" +
             "0.repo = mem-rdf-db\n" +
             "\n" +
             "1.name = context2\n" +
             "1.factory = com.clarkparsia.empire.jena.JenaTestDataSourceFactory\n";

    new PropertiesConfigReader().read(new java.io.StringReader(aConfig));
  }
}
TOP

Related Classes of com.clarkparsia.empire.config.io.impl.PropertiesConfigReader

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.