package org.apache.commons.beanutils2;
   
   /*
    * 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.
   */
  
  import static org.apache.commons.beanutils2.Assertions.checkNotNull;
  import static org.apache.commons.beanutils2.BeanUtils.on;
  
  import java.beans.PropertyDescriptor;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Map.Entry;
  
  final class DefaultBeanAccessor<B>
      implements BeanAccessor<B>
  {
  
      private final B bean;
  
      private final BeanProperties<B> properties;
  
      public DefaultBeanAccessor( B bean )
      {
          this.bean = bean;
          @SuppressWarnings( "unchecked" ) // we can be sure, that bean is of Class<B>
          Class<B> beanClass = (Class<B>) bean.getClass();
          properties = on( beanClass ).getProperties();
      }
  
      // get
  
      /**
       * {@inheritDoc}
       */
      public BeanAccessor<?> get( String propertyName )
      {
          checkNotNull( propertyName, "Parameter 'propertyName' must not be null!" );
          Method readMethod = properties.getReadPropertyMethod( propertyName );
  
          Object newBean;
          try
          {
              newBean = readMethod.invoke( bean );
          }
          catch ( IllegalAccessException e )
          {
              throw new PropertyGetterNotAccessibleException( propertyName, readMethod.getName(), bean.getClass(), e );
          }
          catch ( InvocationTargetException e )
          {
              throw new PropertyGetterInvocationException( propertyName, readMethod.getName(), bean.getClass(), e );
          }
          return new DefaultBeanAccessor<Object>( newBean );
      }
  
      /**
       * {@inheritDoc}
       */
      public IndexedPropertyGetterAccessor<B> getIndexed( String propertyName )
      {
          checkNotNull( propertyName, "Parameter 'propertyName' must not be null!" );
          Method indexedReadMethod;
          indexedReadMethod = properties.getIndexedReadMethod( propertyName );
          return new DefaultIndexedPropertyGetterAccessor<B>( bean, propertyName, indexedReadMethod );
      }
  
      /**
       * {@inheritDoc}
       */
      public MappedPropertyGetterAccessor getMapped( String propertyName )
      {
          checkNotNull( propertyName, "Parameter 'propertyName' must not be null!" );
          Method mappedReadMethod;
          mappedReadMethod = properties.getMappedReadMethod( propertyName );
          return new DefaultMappedPropertyGetterAccessor<B>( bean, propertyName, mappedReadMethod );
      }
  
      /**
       * {@inheritDoc}
       */
      public B get()
     {
         return bean;
     }
 
     /**
      * {@inheritDoc}
      */
     public <V> V cast()
     {
         @SuppressWarnings( "unchecked" )
         V returned = (V) bean;
         return returned;
     }
 
     // set
 
     /**
      * {@inheritDoc}
      */
     public BeanPropertySetter<B> set( String propertyName )
     {
         checkNotNull( propertyName, "Parameter 'propertyName' must not be null!" );
         Method writeMethod;
         writeMethod = properties.getWriteMethod( propertyName );
         return new DefaultBeanPropertySetter<B>( bean, writeMethod, propertyName );
     }
 
     /**
      * {@inheritDoc}
      */
     public IndexedPropertySetterAccessor<B> setIndexed( String propertyName )
     {
         checkNotNull( propertyName, "Parameter 'propertyName' must not be null!" );
         Method indexedWriteMethod;
         indexedWriteMethod = properties.getIndexedWriteMethod( propertyName );
         return new DefaultIndexedPropertySetterAccessor<B>( bean, propertyName, indexedWriteMethod );
     }
 
     /**
      * {@inheritDoc}
      */
     public MappedPropertySetterAccessor<B> setMapped( String propertyName )
     {
         checkNotNull( propertyName, "Parameter 'propertyName' must not be null!" );
         Method mappedWriteMethod;
         mappedWriteMethod = properties.getMappedWriteMethod( propertyName );
         return new DefaultMappedPropertySetterAccessor<B>( bean, propertyName, mappedWriteMethod );
     }
 
     /**
      * {@inheritDoc}
      */
     public B cloneBean()
     {
         BeanAccessor<B> cloneAccessor = on( getBeanClass() ).newInstance();
         cloneAccessor.populate( describe() );
         return cloneAccessor.get();
     }
 
     private Class<B> getBeanClass()
     {
         @SuppressWarnings( "unchecked" ) // we can be sure, that bean is of Class<B>
         Class<B> beanType = (Class<B>) bean.getClass();
         return beanType;
     }
 
     /**
      * {@inheritDoc}
      */
     public <T extends B> void copyPropertiesTo( T target )
     {
         checkNotNull( target, "Can not copy properties to null!" );
         on( target ).populate( describe() );
     }
 
     /**
      * {@inheritDoc}
      */
     public Map<String, Object> describe()
     {
         Map<String, PropertyDescriptor> propertiesIndex;
         propertiesIndex = properties.getPropertiesIndex();
         final Map<String, Object> result = new HashMap<String, Object>( propertiesIndex.size() );
 
         for ( Entry<String, PropertyDescriptor> key : propertiesIndex.entrySet() )
         {
             PropertyDescriptor propertyDescriptor = key.getValue();
             if ( propertyDescriptor.getReadMethod() != null )
             {
                 Object value = invoke( propertyDescriptor );
                 result.put( key.getKey(), value );
             }
         }
 
         return result;
     }
 
     private Object invoke( PropertyDescriptor propertyDescriptor )
     {
         Method readMethod = propertyDescriptor.getReadMethod();
         Object value;
         try
         {
             value = readMethod.invoke( bean );
         }
         catch ( IllegalAccessException e )
         {
             throw new PropertyGetterNotAccessibleException( propertyDescriptor.getName(), readMethod.getName(),
                                                             getBeanClass(), e );
         }
         catch ( InvocationTargetException e )
         {
             throw new PropertyGetterInvocationException( propertyDescriptor.getName(), readMethod.getName(),
                                                          getBeanClass(), e );
         }
         return value;
     }
 
     /**
      * {@inheritDoc}
      */
     public void populate( Map<String, Object> properties )
     {
         for ( Entry<String, Object> entry : properties.entrySet() )
         {
             if ( entry.getKey() != null )
             {
                 setIfWritable( entry.getKey(), entry.getValue() );
             }
         }
     }
 
     private void setIfWritable( String propertyName, Object propertyValue )
     {
         if ( properties.hasProperty( propertyName ) && properties.isWritable( propertyName ) )
         {
             set( propertyName ).with( propertyValue );
         }
     }
 
     /**
      * {@inheritDoc}
      */
     public ArgumentsAccessor invoke( String methodName )
     {
         Class<B> beanClass = getBeanClass();
         checkNotNull( methodName, "Impossible to execute null method in %s", beanClass.getName() );
         return new DefaultArgumentsAccessor( beanClass, false, methodName, bean );
     }
 
     /**
      * {@inheritDoc}
      */
     public ArgumentsAccessor invokeExact( String methodName )
     {
         Class<B> beanClass = getBeanClass();
         checkNotNull( methodName, "Impossible to execute null method in %s", beanClass.getName() );
         return new DefaultArgumentsAccessor( beanClass, true, methodName, bean );
     }
 
 }