2009/05/20 - Apache Shale has been retired.

 /*

  * 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.shale.test.mock;

 import java.beans.BeanInfo;

 import java.beans.IntrospectionException;

 import java.beans.Introspector;

 import java.beans.PropertyDescriptor;

 import java.lang.reflect.InvocationTargetException;

 import java.util.Map;

 import javax.faces.el.EvaluationException;

 import javax.faces.el.PropertyNotFoundException;

 import javax.faces.el.PropertyResolver;

 /**

  * <p>Mock implementation of <code>PropertyResolver</code>.</p>

  *

  * $Id$

  */

 public class MockPropertyResolver extends PropertyResolver {

     // ------------------------------------------------------------ Constructors

     /**

      * <p>Construct a default instance.</p>

      */

     public MockPropertyResolver() {

     }

     // ----------------------------------------------------- Mock Object Methods

     // ------------------------------------------------------ Instance Variables

     // ------------------------------------------------ PropertyResolver Methods

     /** {@inheritDoc} */

     public Object getValue(Object base, Object property)

         throws EvaluationException, PropertyNotFoundException {

         if (base == null) {

             throw new NullPointerException();

         }

         if (base instanceof Map) {

             return ((Map) base).get(property);

         }

         String name = property.toString();

         PropertyDescriptor descriptor = descriptor(base.getClass(), name);

         try {

             return descriptor.getReadMethod().invoke(base, (Object[]) null);

         } catch (IllegalAccessException e) {

             throw new EvaluationException(e);

         } catch (InvocationTargetException e) {

             throw new EvaluationException(e.getTargetException());

         }

     }

     /** {@inheritDoc} */

     public Object getValue(Object base, int index)

         throws PropertyNotFoundException {

         return getValue(base, "" + index);

     }

     /** {@inheritDoc} */

     public void setValue(Object base, Object property, Object value)

         throws PropertyNotFoundException {

         if (base == null) {

             throw new NullPointerException();

         }

         if (base instanceof Map) {

             ((Map) base).put(property, value);

             return;

         }

         String name = property.toString();

         PropertyDescriptor descriptor = descriptor(base.getClass(), name);

         try {

             descriptor.getWriteMethod().invoke(base, new Object[] { value });

         } catch (IllegalAccessException e) {

             throw new EvaluationException(e);

         } catch (InvocationTargetException e) {

             throw new EvaluationException(e.getTargetException());

         }

     }

     /** {@inheritDoc} */

     public void setValue(Object base, int index, Object value)

         throws PropertyNotFoundException {

         setValue(base, "" + index, value);

     }

     /** {@inheritDoc} */

     public boolean isReadOnly(Object base, Object property)

         throws PropertyNotFoundException {

         if (base == null) {

             throw new NullPointerException();

         }

         if (base instanceof Map) {

             return false; // We have no way to know anything more specific

         }

         String name = property.toString();

         PropertyDescriptor descriptor = descriptor(base.getClass(), name);

         return (descriptor.getWriteMethod() == null);

     }

     /** {@inheritDoc} */

     public boolean isReadOnly(Object base, int index)

         throws PropertyNotFoundException {

         return isReadOnly(base, "" + index);

     }

     /** {@inheritDoc} */

     public Class getType(Object base, Object property)

         throws PropertyNotFoundException {

         if (base == null) {

             throw new NullPointerException();

         }

         if (base instanceof Map) {

             Object value = ((Map) base).get(property);

             if (value != null) {

                 return value.getClass();

             } else {

                 return Object.class;

             }

         }

         String name = property.toString();

         PropertyDescriptor descriptor = descriptor(base.getClass(), name);

         return descriptor.getPropertyType();

     }

     /** {@inheritDoc} */

     public Class getType(Object base, int index)

         throws PropertyNotFoundException {

         return getType(base, "" + index);

     }

     // --------------------------------------------------------- Private Methods

     /**

      * <p>Return the <code>PropertyDescriptor</code> for the specified

      * property of the specified class.</p>

      *

      * @param clazz Class from which to extract a property descriptor

      * @param name Name of the desired property

      *

      * @exception EvaluationException if we cannot access the introspecition

      *  information for this class

      * @exception PropertyNotFoundException if the specified property does

      *  not exist on the specified class

      */

     private PropertyDescriptor descriptor(Class clazz, String name) {

         System.err.println("descriptor(class=" + clazz.getName() + ", name=" + name);

         BeanInfo info = null;

         try {

             info = Introspector.getBeanInfo(clazz);

             System.err.println("  Found BeanInfo " + info);

         } catch (IntrospectionException e) {

             throw new EvaluationException(e);

         }

         PropertyDescriptor[] descriptors = info.getPropertyDescriptors();

         for (int i = 0; i < descriptors.length; i++) {

             if (name.equals(descriptors[i].getName())) {

                 System.err.print("  Found PropertyDescriptor " + descriptors[i]);

                 return descriptors[i];

             }

         }

         System.err.print("  No property descriptor for property " + name);

         throw new PropertyNotFoundException(name);

     }

 }