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.checkArgument;
  import static org.apache.commons.beanutils2.Assertions.checkNotNull;
  
  import java.beans.IndexedPropertyDescriptor;
  import java.beans.IntrospectionException;
  import java.beans.PropertyDescriptor;
  import java.lang.reflect.Method;
  import java.util.Map;
  
  final class DefaultBeanProperties<B>
      implements BeanProperties<B>
  {
  
      private final PropertyDescriptorsRegistry registry = PropertyDescriptorsRegistry.getInstance();
  
      private final Class<B> beanClass;
  
      DefaultBeanProperties( Class<B> beanClass )
      {
          this.beanClass = beanClass;
      }
  
      // checks
  
      public boolean hasProperty( String propertyName )
      {
          checkNotNull( propertyName, "Parameter 'propertyName' must not be null!" );
          try
          {
              getPropertyDescriptor( propertyName );
          }
          catch ( NoSuchPropertyException e )
          {
              return false;
          }
          return true;
      }
  
      /**
       * {@inheritDoc}
       */
      public boolean isReadable( String propertyName )
      {
          checkNotNull( propertyName, "Parameter 'propertyName' must not be null!" );
          PropertyDescriptor propertyDescriptor = getPropertyDescriptor( propertyName );
  
          Method getter;
          if ( propertyDescriptor instanceof IndexedPropertyDescriptor )
          {
              IndexedPropertyDescriptor indexed = (IndexedPropertyDescriptor) propertyDescriptor;
              getter = indexed.getIndexedReadMethod();
          }
          else if ( propertyDescriptor instanceof MappedPropertyDescriptor )
          {
              MappedPropertyDescriptor mapped = (MappedPropertyDescriptor) propertyDescriptor;
              getter = mapped.getMappedReadMethod();
          }
          else
          {
              getter = propertyDescriptor.getReadMethod();
          }
  
          return getter != null ? true : false;
      }
  
      /**
       * {@inheritDoc}
       */
      public boolean isWritable( String propertyName )
      {
          checkNotNull( propertyName, "Parameter 'propertyName' must not be null!" );
          PropertyDescriptor propertyDescriptor = getPropertyDescriptor( propertyName );
  
          Method setter;
          if ( propertyDescriptor instanceof IndexedPropertyDescriptor )
          {
              IndexedPropertyDescriptor indexed = (IndexedPropertyDescriptor) propertyDescriptor;
              setter = indexed.getIndexedWriteMethod();
         }
         else if ( propertyDescriptor instanceof MappedPropertyDescriptor )
         {
             MappedPropertyDescriptor mapped = (MappedPropertyDescriptor) propertyDescriptor;
             setter = mapped.getMappedWriteMethod();
         }
         else
         {
             setter = propertyDescriptor.getWriteMethod();
         }
 
         return setter != null ? true : false;
     }
 
     /**
      * {@inheritDoc}
      */
     public PropertyDescriptor getPropertyDescriptor( String propertyName )
     {
         PropertyDescriptor propertyDescriptor = null;
         try
         {
             propertyDescriptor = registry.getPropertyDescriptor( beanClass, propertyName );
         }
         catch ( IntrospectionException ex )
         {
             throw new NoSuchPropertyException( propertyName, beanClass, ex );
         }
 
         if ( propertyDescriptor == null )
         {
             throw new NoSuchPropertyException( propertyName, beanClass, null );
         }
 
         return propertyDescriptor;
     }
 
     /**
      * {@inheritDoc}
      */
     public Method getReadPropertyMethod( String propertyName )
     {
         PropertyDescriptor propertyDescriptor = getPropertyDescriptor( propertyName );
 
         return checkGetterMethod( propertyDescriptor.getReadMethod(), propertyName );
     }
 
     /**
      * {@inheritDoc}
      */
     public Method getWriteMethod( String name )
     {
         PropertyDescriptor propertyDescriptor = getPropertyDescriptor( name );
 
         return checkSetterMethod( propertyDescriptor.getWriteMethod(), name );
     }
 
     /**
      * {@inheritDoc}
      */
     public IndexedPropertyDescriptor getIndexedPropertyDescriptor( String propertyName )
     {
         PropertyDescriptor propertyDescriptor = getPropertyDescriptor( propertyName );
         checkArgument( propertyDescriptor instanceof IndexedPropertyDescriptor,
                        "Property '%s' in bean of type %s is not an indexed property", propertyName, beanClass.getName() );
         return (IndexedPropertyDescriptor) propertyDescriptor;
     }
 
     /**
      * {@inheritDoc}
      */
     public Method getIndexedReadMethod( String propertyName )
     {
         IndexedPropertyDescriptor indexedPropertyDescriptor = getIndexedPropertyDescriptor( propertyName );
 
         return checkGetterMethod( indexedPropertyDescriptor.getIndexedReadMethod(), propertyName );
     }
 
     /**
      * {@inheritDoc}
      */
     public Method getIndexedWriteMethod( String propertyName )
     {
         IndexedPropertyDescriptor indexedPropertyDescriptor = getIndexedPropertyDescriptor( propertyName );
 
         return checkSetterMethod( indexedPropertyDescriptor.getIndexedWriteMethod(), propertyName );
     }
 
     private Method checkSetterMethod( Method method, String propertyName )
     {
         if ( method == null )
         {
             throw new PropertyNotWritableException( propertyName, beanClass, null );
         }
 
         return method;
     }
 
     private Method checkGetterMethod( Method method, String propertyName )
     {
         if ( method == null )
         {
             throw new PropertyNotReadableException( propertyName, beanClass, null );
         }
 
         return method;
     }
 
     /**
      * {@inheritDoc}
      */
     public MappedPropertyDescriptor getMappedPropertyDescriptor( String propertyName )
     {
         PropertyDescriptor propertyDescriptor = getPropertyDescriptor( propertyName );
         checkArgument( propertyDescriptor instanceof MappedPropertyDescriptor,
                        "Property '%s' in bean of type %s is not a mapped property", propertyName, beanClass.getName() );
         return (MappedPropertyDescriptor) propertyDescriptor;
     }
 
     /**
      * {@inheritDoc}
      */
     public Method getMappedReadMethod( String propertyName )
     {
         MappedPropertyDescriptor mappedPropertyDescriptor = getMappedPropertyDescriptor( propertyName );
 
         return checkGetterMethod( mappedPropertyDescriptor.getMappedReadMethod(), propertyName );
     }
 
     /**
      * {@inheritDoc}
      */
     public Map<String, PropertyDescriptor> getPropertiesIndex()
     {
         try
         {
             return registry.getPropertiesIndex( beanClass );
         }
         catch ( IntrospectionException e )
         {
             throw new BeanReflectionException( e, beanClass );
         }
     }
 
     public Method getMappedWriteMethod( String propertyName )
     {
         MappedPropertyDescriptor mappedPropertyDescriptor = getMappedPropertyDescriptor( propertyName );
 
         return checkSetterMethod( mappedPropertyDescriptor.getMappedWriteMethod(), propertyName );
     }
 
 }