/*
    * 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.shiro.config;
  
  import org.apache.commons.beanutils.BeanUtils;
  import org.apache.commons.beanutils.PropertyUtils;
  import org.apache.shiro.codec.Base64;
  import org.apache.shiro.codec.Hex;
  import org.apache.shiro.config.event.BeanEvent;
  import org.apache.shiro.config.event.ConfiguredBeanEvent;
  import org.apache.shiro.config.event.DestroyedBeanEvent;
  import org.apache.shiro.config.event.InitializedBeanEvent;
  import org.apache.shiro.config.event.InstantiatedBeanEvent;
  import org.apache.shiro.event.EventBus;
  import org.apache.shiro.event.EventBusAware;
  import org.apache.shiro.event.Subscribe;
  import org.apache.shiro.event.support.DefaultEventBus;
  import org.apache.shiro.util.Assert;
  import org.apache.shiro.util.ByteSource;
  import org.apache.shiro.util.ClassUtils;
  import org.apache.shiro.util.Factory;
  import org.apache.shiro.util.LifecycleUtils;
  import org.apache.shiro.util.Nameable;
  import org.apache.shiro.util.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.beans.PropertyDescriptor;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.LinkedHashMap;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  
  /**
   * Object builder that uses reflection and Apache Commons BeanUtils to build objects given a
   * map of "property values".  Typically these come from the Shiro INI configuration and are used
   * to construct or modify the SecurityManager, its dependencies, and web-based security filters.
   * <p/>
   * Recognizes {@link Factory} implementations and will call
   * {@link org.apache.shiro.util.Factory#getInstance() getInstance} to satisfy any reference to this bean.
   *
   * @since 0.9
   */
  public class ReflectionBuilder {
  
      //TODO - complete JavaDoc
  
      private static final Logger log = LoggerFactory.getLogger(ReflectionBuilder.class);
  
      private static final String OBJECT_REFERENCE_BEGIN_TOKEN = "$";
      private static final String ESCAPED_OBJECT_REFERENCE_BEGIN_TOKEN = "\\$";
      private static final String GLOBAL_PROPERTY_PREFIX = "shiro";
      private static final char MAP_KEY_VALUE_DELIMITER = ':';
      private static final String HEX_BEGIN_TOKEN = "0x";
      private static final String NULL_VALUE_TOKEN = "null";
      private static final String EMPTY_STRING_VALUE_TOKEN = "\"\"";
      private static final char STRING_VALUE_DELIMETER = '"';
      private static final char MAP_PROPERTY_BEGIN_TOKEN = '[';
      private static final char MAP_PROPERTY_END_TOKEN = ']';
  
      private static final String EVENT_BUS_NAME = "eventBus";
  
      private final Map<String, Object> objects;
  
      /**
       * Interpolation allows for ${key} substitution of values.
       * @since 1.4
       */
      private Interpolator interpolator;
  
      /**
       * @since 1.3
       */
      private EventBus eventBus;
      /**
       * Keeps track of event subscribers that were automatically registered by this ReflectionBuilder during
       * object construction.  This is used in case a new EventBus is discovered during object graph
      * construction:  upon discovery of the new EventBus, the existing subscribers will be unregistered from the
      * old EventBus and then re-registered with the new EventBus.
      *
      * @since 1.3
      */
     private final Map<String,Object> registeredEventSubscribers;
 
     //@since 1.3
     private Map<String,Object> createDefaultObjectMap() {
         Map<String,Object> map = new LinkedHashMap<String, Object>();
         map.put(EVENT_BUS_NAME, new DefaultEventBus());
         return map;
     }
 
     public ReflectionBuilder() {
         this(null);
     }
 
     public ReflectionBuilder(Map<String, ?> defaults) {
 
         this.interpolator = createInterpolator();
 
         this.objects = createDefaultObjectMap();
         this.registeredEventSubscribers = new LinkedHashMap<String,Object>();
         apply(defaults);
     }
 
     private void apply(Map<String, ?> objects) {
         if(!isEmpty(objects)) {
             this.objects.putAll(objects);
         }
         EventBus found = findEventBus(this.objects);
         Assert.notNull(found, "An " + EventBus.class.getName() + " instance must be present in the object defaults");
         enableEvents(found);
     }
 
     public Map<String, ?> getObjects() {
         return objects;
     }
 
     /**
      * @param objects
      */
     public void setObjects(Map<String, ?> objects) {
         this.objects.clear();
         this.objects.putAll(createDefaultObjectMap());
         apply(objects);
     }
 
     //@since 1.3
     private void enableEvents(EventBus eventBus) {
         Assert.notNull(eventBus, "EventBus argument cannot be null.");
         //clean up old auto-registered subscribers:
         for (Object subscriber : this.registeredEventSubscribers.values()) {
             this.eventBus.unregister(subscriber);
         }
         this.registeredEventSubscribers.clear();
 
         this.eventBus = eventBus;
 
         for(Map.Entry<String,Object> entry : this.objects.entrySet()) {
             enableEventsIfNecessary(entry.getValue(), entry.getKey());
         }
     }
 
     //@since 1.3
     private void enableEventsIfNecessary(Object bean, String name) {
         boolean applied = applyEventBusIfNecessary(bean);
         if (!applied) {
             //if the event bus is applied, and the bean wishes to be a subscriber as well (not just a publisher),
             // we assume that the implementation registers itself with the event bus, i.e. eventBus.register(this);
 
             //if the event bus isn't applied, only then do we need to check to see if the bean is an event subscriber,
             // and if so, register it on the event bus automatically since it has no ability to do so itself:
             if (isEventSubscriber(bean, name)) {
                 //found an event subscriber, so register them with the EventBus:
                 this.eventBus.register(bean);
                 this.registeredEventSubscribers.put(name, bean);
             }
         }
     }
 
     //@since 1.3
     private boolean isEventSubscriber(Object bean, String name) {
         List annotatedMethods = ClassUtils.getAnnotatedMethods(bean.getClass(), Subscribe.class);
         return !isEmpty(annotatedMethods);
     }
 
     //@since 1.3
     protected EventBus findEventBus(Map<String,?> objects) {
 
         if (isEmpty(objects)) {
             return null;
         }
 
         //prefer a named object first:
         Object value = objects.get(EVENT_BUS_NAME);
         if (value != null && value instanceof EventBus) {
             return (EventBus)value;
         }
 
         //couldn't find a named 'eventBus' EventBus object.  Try to find the first typed value we can:
         for( Object v : objects.values()) {
             if (v instanceof EventBus) {
                 return (EventBus)v;
             }
         }
 
         return null;
     }
 
     private boolean applyEventBusIfNecessary(Object value) {
         if (value instanceof EventBusAware) {
             ((EventBusAware)value).setEventBus(this.eventBus);
             return true;
         }
         return false;
     }
 
     public Object getBean(String id) {
         return objects.get(id);
     }
 
     @SuppressWarnings({"unchecked"})
     public <T> T getBean(String id, Class<T> requiredType) {
         if (requiredType == null) {
             throw new NullPointerException("requiredType argument cannot be null.");
         }
         Object bean = getBean(id);
         if (bean == null) {
             return null;
         }
         Assert.state(requiredType.isAssignableFrom(bean.getClass()),
                 "Bean with id [" + id + "] is not of the required type [" + requiredType.getName() + "].");
         return (T) bean;
     }
 
     private String parseBeanId(String lhs) {
         Assert.notNull(lhs);
         if (lhs.indexOf('.') < 0) {
             return lhs;
         }
         String classSuffix = ".class";
         int index = lhs.indexOf(classSuffix);
         if (index >= 0) {
             return lhs.substring(0, index);
         }
         return null;
     }
 
     @SuppressWarnings({"unchecked"})
     public Map<String, ?> buildObjects(Map<String, String> kvPairs) {
 
         if (kvPairs != null && !kvPairs.isEmpty()) {
 
             BeanConfigurationProcessor processor = new BeanConfigurationProcessor();
 
             for (Map.Entry<String, String> entry : kvPairs.entrySet()) {
                 String lhs = entry.getKey();
                 String rhs = interpolator.interpolate(entry.getValue());
 
                 String beanId = parseBeanId(lhs);
                 if (beanId != null) { //a beanId could be parsed, so the line is a bean instance definition
                     processor.add(new InstantiationStatement(beanId, rhs));
                 } else { //the line must be a property configuration
                     processor.add(new AssignmentStatement(lhs, rhs));
                 }
             }
 
             processor.execute();
         }
 
         //SHIRO-413: init method must be called for constructed objects that are Initializable
         LifecycleUtils.init(objects.values());
 
         return objects;
     }
 
     public void destroy() {
         final Map<String, Object> immutableObjects = Collections.unmodifiableMap(objects);
 
         //destroy objects in the opposite order they were initialized:
         List<Map.Entry<String,?>> entries = new ArrayList<Map.Entry<String,?>>(objects.entrySet());
         Collections.reverse(entries);
 
         for(Map.Entry<String, ?> entry: entries) {
             String id = entry.getKey();
             Object bean = entry.getValue();
 
             //don't destroy the eventbus until the end - we need it to still be 'alive' while publishing destroy events:
             if (bean != this.eventBus) { //memory equality check (not .equals) on purpose
                 LifecycleUtils.destroy(bean);
                 BeanEvent event = new DestroyedBeanEvent(id, bean, immutableObjects);
                 eventBus.publish(event);
                 this.eventBus.unregister(bean); //bean is now destroyed - it should not receive any other events
             }
         }
         //only now destroy the event bus:
         LifecycleUtils.destroy(this.eventBus);
     }
 
     protected void createNewInstance(Map<String, Object> objects, String name, String value) {
 
         Object currentInstance = objects.get(name);
         if (currentInstance != null) {
             log.info("An instance with name '{}' already exists.  " +
                     "Redefining this object as a new instance of type {}", name, value);
         }
 
         Object instance;//name with no property, assume right hand side of equals sign is the class name:
         try {
             instance = ClassUtils.newInstance(value);
             if (instance instanceof Nameable) {
                 ((Nameable) instance).setName(name);
             }
         } catch (Exception e) {
             String msg = "Unable to instantiate class [" + value + "] for object named '" + name + "'.  " +
                     "Please ensure you've specified the fully qualified class name correctly.";
             throw new ConfigurationException(msg, e);
         }
         objects.put(name, instance);
     }
 
     protected void applyProperty(String key, String value, Map objects) {
 
         int index = key.indexOf('.');
 
         if (index >= 0) {
             String name = key.substring(0, index);
             String property = key.substring(index + 1, key.length());
 
             if (GLOBAL_PROPERTY_PREFIX.equalsIgnoreCase(name)) {
                 applyGlobalProperty(objects, property, value);
             } else {
                 applySingleProperty(objects, name, property, value);
             }
 
         } else {
             throw new IllegalArgumentException("All property keys must contain a '.' character. " +
                     "(e.g. myBean.property = value)  These should already be separated out by buildObjects().");
         }
     }
 
     protected void applyGlobalProperty(Map objects, String property, String value) {
         for (Object instance : objects.values()) {
             try {
                 PropertyDescriptor pd = PropertyUtils.getPropertyDescriptor(instance, property);
                 if (pd != null) {
                     applyProperty(instance, property, value);
                 }
             } catch (Exception e) {
                 String msg = "Error retrieving property descriptor for instance " +
                         "of type [" + instance.getClass().getName() + "] " +
                         "while setting property [" + property + "]";
                 throw new ConfigurationException(msg, e);
             }
         }
     }
 
     protected void applySingleProperty(Map objects, String name, String property, String value) {
         Object instance = objects.get(name);
         if (property.equals("class")) {
             throw new IllegalArgumentException("Property keys should not contain 'class' properties since these " +
                     "should already be separated out by buildObjects().");
 
         } else if (instance == null) {
             String msg = "Configuration error.  Specified object [" + name + "] with property [" +
                     property + "] without first defining that object's class.  Please first " +
                     "specify the class property first, e.g. myObject = fully_qualified_class_name " +
                     "and then define additional properties.";
             throw new IllegalArgumentException(msg);
 
         } else {
             applyProperty(instance, property, value);
         }
     }
 
     protected boolean isReference(String value) {
         return value != null && value.startsWith(OBJECT_REFERENCE_BEGIN_TOKEN);
     }
 
     protected String getId(String referenceToken) {
         return referenceToken.substring(OBJECT_REFERENCE_BEGIN_TOKEN.length());
     }
 
     protected Object getReferencedObject(String id) {
         Object o = objects != null && !objects.isEmpty() ? objects.get(id) : null;
         if (o == null) {
             String msg = "The object with id [" + id + "] has not yet been defined and therefore cannot be " +
                     "referenced.  Please ensure objects are defined in the order in which they should be " +
                     "created and made available for future reference.";
             throw new UnresolveableReferenceException(msg);
         }
         return o;
     }
 
     protected String unescapeIfNecessary(String value) {
         if (value != null && value.startsWith(ESCAPED_OBJECT_REFERENCE_BEGIN_TOKEN)) {
             return value.substring(ESCAPED_OBJECT_REFERENCE_BEGIN_TOKEN.length() - 1);
         }
         return value;
     }
 
     protected Object resolveReference(String reference) {
         String id = getId(reference);
         log.debug("Encountered object reference '{}'.  Looking up object with id '{}'", reference, id);
         final Object referencedObject = getReferencedObject(id);
         if (referencedObject instanceof Factory) {
             return ((Factory) referencedObject).getInstance();
         }
         return referencedObject;
     }
 
     protected boolean isTypedProperty(Object object, String propertyName, Class clazz) {
         if (clazz == null) {
             throw new NullPointerException("type (class) argument cannot be null.");
         }
         try {
             PropertyDescriptor descriptor = PropertyUtils.getPropertyDescriptor(object, propertyName);
             if (descriptor == null) {
                 String msg = "Property '" + propertyName + "' does not exist for object of " +
                         "type " + object.getClass().getName() + ".";
                 throw new ConfigurationException(msg);
             }
             Class propertyClazz = descriptor.getPropertyType();
             return clazz.isAssignableFrom(propertyClazz);
         } catch (ConfigurationException ce) {
             //let it propagate:
             throw ce;
         } catch (Exception e) {
             String msg = "Unable to determine if property [" + propertyName + "] represents a " + clazz.getName();
             throw new ConfigurationException(msg, e);
         }
     }
 
     protected Set<?> toSet(String sValue) {
         String[] tokens = StringUtils.split(sValue);
         if (tokens == null || tokens.length <= 0) {
             return null;
         }
 
         //SHIRO-423: check to see if the value is a referenced Set already, and if so, return it immediately:
         if (tokens.length == 1 && isReference(tokens[0])) {
             Object reference = resolveReference(tokens[0]);
             if (reference instanceof Set) {
                 return (Set)reference;
             }
         }
 
         Set<String> setTokens = new LinkedHashSet<String>(Arrays.asList(tokens));
 
         //now convert into correct values and/or references:
         Set<Object> values = new LinkedHashSet<Object>(setTokens.size());
         for (String token : setTokens) {
             Object value = resolveValue(token);
             values.add(value);
         }
         return values;
     }
 
     protected Map<?, ?> toMap(String sValue) {
         String[] tokens = StringUtils.split(sValue, StringUtils.DEFAULT_DELIMITER_CHAR,
                 StringUtils.DEFAULT_QUOTE_CHAR, StringUtils.DEFAULT_QUOTE_CHAR, true, true);
         if (tokens == null || tokens.length <= 0) {
             return null;
         }
 
         //SHIRO-423: check to see if the value is a referenced Map already, and if so, return it immediately:
         if (tokens.length == 1 && isReference(tokens[0])) {
             Object reference = resolveReference(tokens[0]);
             if (reference instanceof Map) {
                 return (Map)reference;
             }
         }
 
         Map<String, String> mapTokens = new LinkedHashMap<String, String>(tokens.length);
         for (String token : tokens) {
             String[] kvPair = StringUtils.split(token, MAP_KEY_VALUE_DELIMITER);
             if (kvPair == null || kvPair.length != 2) {
                 String msg = "Map property value [" + sValue + "] contained key-value pair token [" +
                         token + "] that does not properly split to a single key and pair.  This must be the " +
                         "case for all map entries.";
                 throw new ConfigurationException(msg);
             }
             mapTokens.put(kvPair[0], kvPair[1]);
         }
 
         //now convert into correct values and/or references:
         Map<Object, Object> map = new LinkedHashMap<Object, Object>(mapTokens.size());
         for (Map.Entry<String, String> entry : mapTokens.entrySet()) {
             Object key = resolveValue(entry.getKey());
             Object value = resolveValue(entry.getValue());
             map.put(key, value);
         }
         return map;
     }
 
     // @since 1.2.2
     protected Collection<?> toCollection(String sValue) {
 
         String[] tokens = StringUtils.split(sValue);
         if (tokens == null || tokens.length <= 0) {
             return null;
         }
 
         //SHIRO-423: check to see if the value is a referenced Collection already, and if so, return it immediately:
         if (tokens.length == 1 && isReference(tokens[0])) {
             Object reference = resolveReference(tokens[0]);
             if (reference instanceof Collection) {
                 return (Collection)reference;
             }
         }
 
         //now convert into correct values and/or references:
         List<Object> values = new ArrayList<Object>(tokens.length);
         for (String token : tokens) {
             Object value = resolveValue(token);
             values.add(value);
         }
         return values;
     }
 
     protected List<?> toList(String sValue) {
         String[] tokens = StringUtils.split(sValue);
         if (tokens == null || tokens.length <= 0) {
             return null;
         }
 
         //SHIRO-423: check to see if the value is a referenced List already, and if so, return it immediately:
         if (tokens.length == 1 && isReference(tokens[0])) {
             Object reference = resolveReference(tokens[0]);
             if (reference instanceof List) {
                 return (List)reference;
             }
         }
 
         //now convert into correct values and/or references:
         List<Object> values = new ArrayList<Object>(tokens.length);
         for (String token : tokens) {
             Object value = resolveValue(token);
             values.add(value);
         }
         return values;
     }
 
     protected byte[] toBytes(String sValue) {
         if (sValue == null) {
             return null;
         }
         byte[] bytes;
         if (sValue.startsWith(HEX_BEGIN_TOKEN)) {
             String hex = sValue.substring(HEX_BEGIN_TOKEN.length());
             bytes = Hex.decode(hex);
         } else {
             //assume base64 encoded:
             bytes = Base64.decode(sValue);
         }
         return bytes;
     }
 
     protected Object resolveValue(String stringValue) {
         Object value;
         if (isReference(stringValue)) {
             value = resolveReference(stringValue);
         } else {
             value = unescapeIfNecessary(stringValue);
         }
         return value;
     }
 
     protected String checkForNullOrEmptyLiteral(String stringValue) {
         if (stringValue == null) {
             return null;
         }
         //check if the value is the actual literal string 'null' (expected to be wrapped in quotes):
         if (stringValue.equals("\"null\"")) {
             return NULL_VALUE_TOKEN;
         }
         //or the actual literal string of two quotes '""' (expected to be wrapped in quotes):
         else if (stringValue.equals("\"\"\"\"")) {
             return EMPTY_STRING_VALUE_TOKEN;
         } else {
             return stringValue;
         }
     }
     
     protected void applyProperty(Object object, String propertyPath, Object value) {
 
         int mapBegin = propertyPath.indexOf(MAP_PROPERTY_BEGIN_TOKEN);
         int mapEnd = -1;
         String mapPropertyPath = null;
         String keyString = null;
 
         String remaining = null;
         
         if (mapBegin >= 0) {
             //a map is being referenced in the overall property path.  Find just the map's path:
             mapPropertyPath = propertyPath.substring(0, mapBegin);
             //find the end of the map reference:
             mapEnd = propertyPath.indexOf(MAP_PROPERTY_END_TOKEN, mapBegin);
             //find the token in between the [ and the ] (the map/array key or index):
             keyString = propertyPath.substring(mapBegin+1, mapEnd);
 
             //find out if there is more path reference to follow.  If not, we're at a terminal of the OGNL expression
             if (propertyPath.length() > (mapEnd+1)) {
                 remaining = propertyPath.substring(mapEnd+1);
                 if (remaining.startsWith(".")) {
                     remaining = StringUtils.clean(remaining.substring(1));
                 }
             }
         }
         
         if (remaining == null) {
             //we've terminated the OGNL expression.  Check to see if we're assigning a property or a map entry:
             if (keyString == null) {
                 //not a map or array value assignment - assign the property directly:
                 setProperty(object, propertyPath, value);
             } else {
                 //we're assigning a map or array entry.  Check to see which we should call:
                 if (isTypedProperty(object, mapPropertyPath, Map.class)) {
                     Map map = (Map)getProperty(object, mapPropertyPath);
                     Object mapKey = resolveValue(keyString);
                     //noinspection unchecked
                     map.put(mapKey, value);
                 } else {
                     //must be an array property.  Convert the key string to an index:
                     int index = Integer.valueOf(keyString);
                     setIndexedProperty(object, mapPropertyPath, index, value);
                 }
             }
         } else {
             //property is being referenced as part of a nested path.  Find the referenced map/array entry and
             //recursively call this method with the remaining property path
             Object referencedValue = null;
             if (isTypedProperty(object, mapPropertyPath, Map.class)) {
                 Map map = (Map)getProperty(object, mapPropertyPath);
                 Object mapKey = resolveValue(keyString);
                 referencedValue = map.get(mapKey);
             } else {
                 //must be an array property:
                 int index = Integer.valueOf(keyString);
                 referencedValue = getIndexedProperty(object, mapPropertyPath, index);
             }
 
             if (referencedValue == null) {
                 throw new ConfigurationException("Referenced map/array value '" + mapPropertyPath + "[" +
                 keyString + "]' does not exist.");
             }
 
             applyProperty(referencedValue, remaining, value);
         }
     }
     
     private void setProperty(Object object, String propertyPath, Object value) {
         try {
             if (log.isTraceEnabled()) {
                 log.trace("Applying property [{}] value [{}] on object of type [{}]",
                         new Object[]{propertyPath, value, object.getClass().getName()});
             }
             BeanUtils.setProperty(object, propertyPath, value);
         } catch (Exception e) {
             String msg = "Unable to set property '" + propertyPath + "' with value [" + value + "] on object " +
                     "of type " + (object != null ? object.getClass().getName() : null) + ".  If " +
                     "'" + value + "' is a reference to another (previously defined) object, prefix it with " +
                     "'" + OBJECT_REFERENCE_BEGIN_TOKEN + "' to indicate that the referenced " +
                     "object should be used as the actual value.  " +
                     "For example, " + OBJECT_REFERENCE_BEGIN_TOKEN + value;
             throw new ConfigurationException(msg, e);
         }
     }
     
     private Object getProperty(Object object, String propertyPath) {
         try {
             return PropertyUtils.getProperty(object, propertyPath);
         } catch (Exception e) {
             throw new ConfigurationException("Unable to access property '" + propertyPath + "'", e);
         }
     }
     
     private void setIndexedProperty(Object object, String propertyPath, int index, Object value) {
         try {
             PropertyUtils.setIndexedProperty(object, propertyPath, index, value);
         } catch (Exception e) {
             throw new ConfigurationException("Unable to set array property '" + propertyPath + "'", e);
         }
     }
     
     private Object getIndexedProperty(Object object, String propertyPath, int index) {
         try {
             return PropertyUtils.getIndexedProperty(object, propertyPath, index);
         } catch (Exception e) {
             throw new ConfigurationException("Unable to acquire array property '" + propertyPath + "'", e);
         }
     }
     
     protected boolean isIndexedPropertyAssignment(String propertyPath) {
         return propertyPath.endsWith("" + MAP_PROPERTY_END_TOKEN);
     }
 
     protected void applyProperty(Object object, String propertyName, String stringValue) {
 
         Object value;
 
         if (NULL_VALUE_TOKEN.equals(stringValue)) {
             value = null;
         } else if (EMPTY_STRING_VALUE_TOKEN.equals(stringValue)) {
             value = StringUtils.EMPTY_STRING;
         } else if (isIndexedPropertyAssignment(propertyName)) {
             String checked = checkForNullOrEmptyLiteral(stringValue);
             value = resolveValue(checked);
         } else if (isTypedProperty(object, propertyName, Set.class)) {
             value = toSet(stringValue);
         } else if (isTypedProperty(object, propertyName, Map.class)) {
             value = toMap(stringValue);
         } else if (isTypedProperty(object, propertyName, List.class)) {
             value = toList(stringValue);
         } else if (isTypedProperty(object, propertyName, Collection.class)) {
             value = toCollection(stringValue);
         } else if (isTypedProperty(object, propertyName, byte[].class)) {
             value = toBytes(stringValue);
         } else if (isTypedProperty(object, propertyName, ByteSource.class)) {
             byte[] bytes = toBytes(stringValue);
             value = ByteSource.Util.bytes(bytes);
         } else {
             String checked = checkForNullOrEmptyLiteral(stringValue);
             value = resolveValue(checked);
         }
 
         applyProperty(object, propertyName, value);
     }
 
     private Interpolator createInterpolator() {
 
         if (ClassUtils.isAvailable("org.apache.commons.configuration2.interpol.ConfigurationInterpolator")) {
             return new CommonsInterpolator();
         }
 
         return new DefaultInterpolator();
     }
 
     /**
      * Sets the {@link Interpolator} used when evaluating the right side of the expressions.
      * @since 1.4
      */
     public void setInterpolator(Interpolator interpolator) {
         this.interpolator = interpolator;
     }
 
     private class BeanConfigurationProcessor {
 
         private final List<Statement> statements = new ArrayList<Statement>();
         private final List<BeanConfiguration> beanConfigurations = new ArrayList<BeanConfiguration>();
 
         public void add(Statement statement) {
 
             statements.add(statement); //we execute bean configuration statements in the order they are declared.
 
             if (statement instanceof InstantiationStatement) {
                 InstantiationStatement is = (InstantiationStatement)statement;
                 beanConfigurations.add(new BeanConfiguration(is));
             } else {
                 AssignmentStatement as = (AssignmentStatement)statement;
                 //statements always apply to the most recently defined bean configuration with the same name, so we
                 //have to traverse the configuration list starting at the end (most recent elements are appended):
                 boolean addedToConfig = false;
                 String beanName = as.getRootBeanName();
                 for( int i = beanConfigurations.size()-1; i >= 0; i--) {
                     BeanConfiguration mostRecent = beanConfigurations.get(i);
                     String mostRecentBeanName = mostRecent.getBeanName();
                     if (beanName.equals(mostRecentBeanName)) {
                         mostRecent.add(as);
                         addedToConfig = true;
                         break;
                     }
                 }
 
                 if (!addedToConfig) {
                     // the AssignmentStatement must be for an existing bean that does not yet have a corresponding
                     // configuration object (this would happen if the bean is in the default objects map). Because
                     // BeanConfiguration instances don't exist for default (already instantiated) beans,
                     // we simulate a creation of one to satisfy this processors implementation:
                     beanConfigurations.add(new BeanConfiguration(as));
                 }
             }
         }
 
         public void execute() {
 
             for( Statement statement : statements) {
 
                 statement.execute();
 
                 BeanConfiguration bd = statement.getBeanConfiguration();
 
                 if (bd.isExecuted()) { //bean is fully configured, no more statements to execute for it:
 
                     //bean configured overrides the 'eventBus' bean - replace the existing eventBus with the one configured:
                     if (bd.getBeanName().equals(EVENT_BUS_NAME)) {
                         EventBus eventBus = (EventBus)bd.getBean();
                         enableEvents(eventBus);
                     }
 
                     //ignore global 'shiro.' shortcut mechanism:
                     if (!bd.isGlobalConfig()) {
                         BeanEvent event = new ConfiguredBeanEvent(bd.getBeanName(), bd.getBean(),
                                 Collections.unmodifiableMap(objects));
                         eventBus.publish(event);
                     }
 
                     //initialize the bean if necessary:
                     LifecycleUtils.init(bd.getBean());
 
                     //ignore global 'shiro.' shortcut mechanism:
                     if (!bd.isGlobalConfig()) {
                         BeanEvent event = new InitializedBeanEvent(bd.getBeanName(), bd.getBean(),
                                 Collections.unmodifiableMap(objects));
                         eventBus.publish(event);
                     }
                 }
             }
         }
     }
 
     private class BeanConfiguration {
 
         private final InstantiationStatement instantiationStatement;
         private final List<AssignmentStatement> assignments = new ArrayList<AssignmentStatement>();
         private final String beanName;
         private Object bean;
 
         private BeanConfiguration(InstantiationStatement statement) {
             statement.setBeanConfiguration(this);
             this.instantiationStatement = statement;
             this.beanName = statement.lhs;
         }
 
         private BeanConfiguration(AssignmentStatement as) {
             this.instantiationStatement = null;
             this.beanName = as.getRootBeanName();
             add(as);
         }
 
         public String getBeanName() {
             return this.beanName;
         }
 
         public boolean isGlobalConfig() { //BeanConfiguration instance representing the global 'shiro.' properties
             // (we should remove this concept).
             return GLOBAL_PROPERTY_PREFIX.equals(getBeanName());
         }
 
         public void add(AssignmentStatement as) {
             as.setBeanConfiguration(this);
             assignments.add(as);
         }
 
         /**
          * When this configuration is parsed sufficiently to create (or find) an actual bean instance, that instance
          * will be associated with its configuration by setting it via this method.
          *
          * @param bean the bean instantiated (or found) that corresponds to this BeanConfiguration instance.
          */
         public void setBean(Object bean) {
             this.bean = bean;
         }
 
         public Object getBean() {
             return this.bean;
         }
 
         /**
          * Returns true if all configuration statements have been executed.
          * @return true if all configuration statements have been executed.
          */
         public boolean isExecuted() {
             if (instantiationStatement != null && !instantiationStatement.isExecuted()) {
                 return false;
             }
             for (AssignmentStatement as : assignments) {
                 if (!as.isExecuted()) {
                     return false;
                 }
             }
             return true;
         }
     }
 
     private abstract class Statement {
 
         protected final String lhs;
         protected final String rhs;
         protected Object bean;
         private Object result;
         private boolean executed;
         private BeanConfiguration beanConfiguration;
 
         private Statement(String lhs, String rhs) {
             this.lhs = lhs;
             this.rhs = rhs;
             this.executed = false;
         }
 
         public void setBeanConfiguration(BeanConfiguration bd) {
             this.beanConfiguration = bd;
         }
 
         public BeanConfiguration getBeanConfiguration() {
             return this.beanConfiguration;
         }
 
         public Object execute() {
             if (!isExecuted()) {
                 this.result = doExecute();
                 this.executed = true;
             }
             if (!getBeanConfiguration().isGlobalConfig()) {
                 Assert.notNull(this.bean, "Implementation must set the root bean for which it executed.");
             }
             return this.result;
         }
 
         public Object getBean() {
             return this.bean;
         }
 
         protected void setBean(Object bean) {
             this.bean = bean;
             if (this.beanConfiguration.getBean() == null) {
                 this.beanConfiguration.setBean(bean);
             }
         }
 
         public Object getResult() {
             return result;
         }
 
         protected abstract Object doExecute();
 
         public boolean isExecuted() {
             return executed;
         }
     }
 
     private class InstantiationStatement extends Statement {
 
         private InstantiationStatement(String lhs, String rhs) {
             super(lhs, rhs);
         }
 
         @Override
         protected Object doExecute() {
             String beanName = this.lhs;
             createNewInstance(objects, beanName, this.rhs);
             Object instantiated = objects.get(beanName);
             setBean(instantiated);
 
             //also ensure the instantiated bean has access to the event bus or is subscribed to events if necessary:
             //Note: because events are being enabled on this bean here (before the instantiated event below is
             //triggered), beans can react to their own instantiation events.
             enableEventsIfNecessary(instantiated, beanName);
 
             BeanEvent event = new InstantiatedBeanEvent(beanName, instantiated, Collections.unmodifiableMap(objects));
             eventBus.publish(event);
 
             return instantiated;
         }
     }
 
     private class AssignmentStatement extends Statement {
 
         private final String rootBeanName;
 
         private AssignmentStatement(String lhs, String rhs) {
             super(lhs, rhs);
             int index = lhs.indexOf('.');
             this.rootBeanName = lhs.substring(0, index);
         }
 
         @Override
         protected Object doExecute() {
             applyProperty(lhs, rhs, objects);
             Object bean = objects.get(this.rootBeanName);
             setBean(bean);
             return null;
         }
 
         public String getRootBeanName() {
             return this.rootBeanName;
         }
     }
 
     //////////////////////////
     // From CollectionUtils //
     //////////////////////////
     // CollectionUtils cannot be removed from shiro-core until 2.0 as it has a dependency on PrincipalCollection
 
     private static boolean isEmpty(Map m) {
         return m == null || m.isEmpty();
     }
 
     private static boolean isEmpty(Collection c) {
         return c == null || c.isEmpty();
     }
 
 }