/*

  * Licensed to the Apache Software Foundation (ASF) under one or more

  * contributor license agreements.  See the NOTICE file distributed with

  * this work for additional information regarding copyright ownership.

  * The ASF licenses this file to You 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 org.apache.commons.configuration.interpol;

 import java.lang.reflect.Field;

 import java.util.HashMap;

 import java.util.Map;

 import org.apache.commons.lang.ClassUtils;

 import org.apache.commons.lang.text.StrLookup;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 /**

  * <p>

  * A specialized lookup implementation that allows access to constant fields of

  * classes.

  * </p>

  * <p>

  * Sometimes it is necessary in a configuration file to refer to a constant

  * defined in a class. This can be done with this lookup implementation.

  * Variable names passed in must be of the form

  * <code>mypackage.MyClass.FIELD</code>. The <code>lookup()</code> method

  * will split the passed in string at the last dot, separating the fully

  * qualified class name and the name of the constant (i.e. <strong>static final</strong>)

  * member field. Then the class is loaded and the field's value is obtained

  * using reflection.

  * </p>

  * <p>

  * Once retrieved values are cached for fast access. This class is thread-safe.

  * It can be used as a standard (i.e. global) lookup object and serve multiple

  * clients concurrently.

  * </p>

  *

  * @version $Id: ConstantLookup.java 588329 2007-10-25 20:01:31Z oheger $

  * @since 1.4

  * @author <a

  * href="http://commons.apache.org/configuration/team-list.html">Commons

  * Configuration team</a>

  */

 public class ConstantLookup extends StrLookup

 {

     /** Constant for the field separator. */

     private static final char FIELD_SEPRATOR = '.';

     /** An internally used cache for already retrieved values. */

     private static Map constantCache = new HashMap();

     /** The logger. */

     private Log log = LogFactory.getLog(getClass());

     /**

      * Tries to resolve the specified variable. The passed in variable name is

      * interpreted as the name of a <b>static final</b> member field of a

      * class. If the value has already been obtained, it can be retrieved from

      * an internal cache. Otherwise this method will invoke the

      * <code>resolveField()</code> method and pass in the name of the class

      * and the field.

      *

      * @param var the name of the variable to be resolved

      * @return the value of this variable or <b>null</b> if it cannot be

      * resolved

      */

     public String lookup(String var)

     {

         if (var == null)

         {

             return null;

         }

         String result;

         synchronized (constantCache)

         {

             result = (String) constantCache.get(var);

         }

         if (result != null)

         {

             return result;

         }

         int fieldPos = var.lastIndexOf(FIELD_SEPRATOR);

         if (fieldPos < 0)

         {

             return null;

         }

         try

         {

             Object value = resolveField(var.substring(0, fieldPos), var

                     .substring(fieldPos + 1));

             if (value != null)

             {

                 synchronized (constantCache)

                 {

                     // In worst case, the value will be fetched multiple times

                     // because of this lax synchronisation, but for constant

                     // values this shouldn't be a problem.

                     constantCache.put(var, String.valueOf(value));

                 }

                 result = value.toString();

             }

         }

         catch (Exception ex)

         {

             log.warn("Could not obtain value for variable " + var, ex);

         }

         return result;

     }

     /**

      * Clears the shared cache with the so far resolved constants.

      */

     public static void clear()

     {

         synchronized (constantCache)

         {

             constantCache.clear();

         }

     }

     /**

      * Determines the value of the specified constant member field of a class.

      * This implementation will call <code>fetchClass()</code> to obtain the

      * <code>java.lang.Class</code> object for the target class. Then it will

      * use reflection to obtain the field's value. For this to work the field

      * must be accessable.

      *

      * @param className the name of the class

      * @param fieldName the name of the member field of that class to read

      * @return the field's value

      * @throws Exception if an error occurs

      */

     protected Object resolveField(String className, String fieldName)

             throws Exception

     {

         Class clazz = fetchClass(className);

         Field field = clazz.getField(fieldName);

         return field.get(null);

     }

     /**

      * Loads the class with the specified name. If an application has special

      * needs regarding the class loaders to be used, it can hook in here. This

      * implementation delegates to the <code>getClass()</code> method of

      * Commons Lang's

      * <code><a href="http://commons.apache.org/lang/api-release/org/apache/commons/lang/ClassUtils.html">

      * ClassUtils</a></code>.

      *

      * @param className the name of the class to be loaded

      * @return the corresponding class object

      * @throws ClassNotFoundException if the class cannot be loaded

      */

     protected Class fetchClass(String className) throws ClassNotFoundException

     {

         return ClassUtils.getClass(className);

     }

 }