Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2014-2015 the original author or authors.
   *
   * Licensed 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.lastaflute.di.helper.beans.impl;
 
 import java.sql.Time;
 import java.util.Map;
 

Author(s):
modified by jflute (originated in Seasar)
 
 public class PropertyDescImpl implements PropertyDesc {
 
     private static final Object[] EMPTY_ARGS = new Object[0];
 
     private String propertyName;
     private Class<?> propertyType;
     private Method readMethod;
     private Method writeMethod;
     private Field field;
     private BeanDesc beanDesc;
     private Constructor<?> stringConstructor;
     private Method valueOfMethod;
     private boolean readable = false;
     private boolean writable = false;
 
     public PropertyDescImpl(String propertyNameClass<?> propertyTypeMethod readMethodMethod writeMethodBeanDesc beanDesc) {
         this(propertyNamepropertyTypereadMethodwriteMethodnullbeanDesc);
     }
 
     public PropertyDescImpl(String propertyNameClass<?> propertyTypeMethod readMethodMethod writeMethodField field,
             BeanDesc beanDesc) {
         if (propertyName == null) {
             throw new EmptyRuntimeException("propertyName");
         }
         if (propertyType == null) {
             throw new EmptyRuntimeException("propertyType");
         }
         this. = propertyName;
         this. = propertyType;
         setReadMethod(readMethod);
         setWriteMethod(writeMethod);
         setField(field);
         this. = beanDesc;
         setupStringConstructor();
         setupValueOfMethod();
         setUpParameterizedClassDesc();
     }
 
     private void setupStringConstructor() {
         Constructor<?>[] cons = .getConstructors();
         for (int i = 0; i < cons.length; ++i) {
             Constructor<?> con = cons[i];
             if (con.getParameterTypes().length == 1 && con.getParameterTypes()[0].equals(String.class)) {
                  = con;
                 break;
             }
         }
     }
 
     private void setupValueOfMethod() {
         Method[] methods = .getMethods();
        for (int i = 0; i < methods.length; ++i) {
            Method method = methods[i];
            if (LdiMethodUtil.isBridgeMethod(method) || LdiMethodUtil.isSyntheticMethod(method)) {
                continue;
            }
            if (LdiModifierUtil.isStatic(method.getModifiers()) && method.getName().equals("valueOf")
                    && method.getParameterTypes().length == 1 && method.getParameterTypes()[0].equals(String.class)) {
                 = method;
                break;
            }
        }
    }
    private void setUpParameterizedClassDesc() {
        final Map<?, ?> typeVariables = ((BeanDescImpl).getTypeVariables();
        if ( != null) {
             = ParameterizedClassDescFactory.createParameterizedClassDesc(typeVariables);
        } else if ( != null) {
             = ParameterizedClassDescFactory.createParameterizedClassDesc(typeVariables);
        } else if ( != null) {
             = ParameterizedClassDescFactory.createParameterizedClassDesc(, 0, typeVariables);
        }
    }
    public final String getPropertyName() {
        return ;
    }
    public final Class<?> getPropertyType() {
        return ;
    }
    public final Method getReadMethod() {
        return ;
    }
    public final void setReadMethod(Method readMethod) {
        this. = readMethod;
        if (readMethod != null) {
             = true;
            readMethod.setAccessible(true);
        }
    }
    public final boolean hasReadMethod() {
        return  != null;
    }
    public final Method getWriteMethod() {
        return ;
    }
    public final void setWriteMethod(Method writeMethod) {
        this. = writeMethod;
        if (writeMethod != null) {
             = true;
            writeMethod.setAccessible(true);
        }
    }
    public final boolean hasWriteMethod() {
        return  != null;
    }
    public Field getField() {
        return ;
    }
    public void setField(Field field) {
        this. = field;
        if (field != null && LdiModifierUtil.isPublic(field)) {
             = true;
             = !LdiModifierUtil.isFinal(field);
        }
    }
    public boolean isReadable() {
        return ;
    }
    public boolean isWritable() {
        return ;
    }
    public final Object getValue(Object target) {
        try {
            if (!) {
                throw new IllegalStateException( + " is not readable.");
            } else if (hasReadMethod()) {
                return LdiMethodUtil.invoke(target);
            } else {
                return LdiFieldUtil.get(target);
            }
        } catch (Throwable t) {
            throw new IllegalPropertyRuntimeException(.getBeanClass(), t);
        }
    }
    public final void setValue(Object targetObject value) {
        try {
            value = convertIfNeed(value);
            if (!) {
                throw new IllegalStateException( + " is not writable.");
            } else if (hasWriteMethod()) {
                try {
                    LdiMethodUtil.invoke(targetnew Object[] { value });
                } catch (Throwable t) {
                    Class<?> clazz = .getDeclaringClass();
                    Class<?> valueClass = value == null ? null : value.getClass();
                    Class<?> targetClass = target == null ? null : target.getClass();
                    throw new SIllegalArgumentException("ESSR0098"new Object[] { clazz.getName(), clazz.getClassLoader(),
                            .getName(), .getClassLoader(), ,
                            valueClass == null ? null : valueClass.getName(), valueClass == null ? null : valueClass.getClassLoader(),
                            valuetargetClass == null ? null : targetClass.getName(),
                            targetClass == null ? null : targetClass.getClassLoader() }).initCause(t);
                }
            } else {
                LdiFieldUtil.set(targetvalue);
            }
        } catch (Throwable t) {
            // TODO jflute lastaflute: [E] DI :: property desc exception message from DBFlute
            throw new IllegalPropertyRuntimeException(.getBeanClass(), t);
        }
    }
    public BeanDesc getBeanDesc() {
        return ;
    }
    @Override
    public final String toString() {
        StringBuffer buf = new StringBuffer();
        buf.append("propertyName=");
        buf.append();
        buf.append(",propertyType=");
        buf.append(.getName());
        buf.append(",readMethod=");
        buf.append( != null ? .getName() : "null");
        buf.append(",writeMethod=");
        buf.append( != null ? .getName() : "null");
        return buf.toString();
    }
    public Object convertIfNeed(Object arg) {
        // TODO jflute lastaflute: [E] DI :: convert to local date
        if (.isPrimitive()) {
            return convertPrimitiveWrapper(arg);
        } else if (Number.class.isAssignableFrom()) {
            return convertNumber(arg);
        } else if (java.util.Date.class.isAssignableFrom()) {
            return convertDate(arg);
        } else if (Boolean.class.isAssignableFrom()) {
            return LdiBooleanConversionUtil.toBoolean(arg);
        } else if (arg != null && arg.getClass() != String.class && String.class == ) {
            return arg.toString();
        } else if (arg instanceof String && !String.class.equals()) {
            return convertWithString(arg);
        } else if (java.util.Calendar.class.isAssignableFrom()) {
            return LdiCalendarConversionUtil.toCalendar(arg);
        }
        return arg;
    }
    private Object convertPrimitiveWrapper(Object arg) {
        return LdiNumberConversionUtil.convertPrimitiveWrapper(arg);
    }
    private Object convertNumber(Object arg) {
        return LdiNumberConversionUtil.convertNumber(arg);
    }
    private Object convertDate(Object arg) {
        if ( == java.util.Date.class) {
            return LdiDateConversionUtil.toDate(arg);
        } else if ( == Timestamp.class) {
            return LdiTimestampConversionUtil.toTimestamp(arg);
        } else if ( == java.sql.Date.class) {
            return LdiSqlDateConversionUtil.toDate(arg);
        } else if ( == Time.class) {
            return LdiTimeConversionUtil.toTime(arg);
        }
        return arg;
    }
    private Object convertWithString(Object arg) {
        if ( != null) {
            return LdiConstructorUtil.newInstance(new Object[] { arg });
        }
        if ( != null) {
            return LdiMethodUtil.invoke(nullnew Object[] { arg });
        }
        return arg;
    }
    public boolean isParameterized() {
    }
        return ;
    }
    public Class<?> getElementClassOfCollection() {
        if (!Collection.class.isAssignableFrom() || !isParameterized()) {
            return null;
        }
        final ParameterizedClassDesc pcd = .getArguments()[0];
        if (pcd == null) {
            return null;
        }
        return pcd.getRawClass();
    }
    public Class<?> getKeyClassOfMap() {
        if (!Map.class.isAssignableFrom() || !isParameterized()) {
            return null;
        }
        final ParameterizedClassDesc pcd = .getArguments()[0];
        if (pcd == null) {
            return null;
        }
        return pcd.getRawClass();
    }
    public Class<?> getValueClassOfMap() {
        if (!Map.class.isAssignableFrom() || !isParameterized()) {
            return null;
        }
        final ParameterizedClassDesc pcd = .getArguments()[1];
        if (pcd == null) {
            return null;
        }
        return pcd.getRawClass();
    }
New to GrepCode? Check out our FAQ X