org.databene.commons.mutator.AnyMutator Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of databene-commons Show documentation
'databene commons' is an open source Java library by Volker Bergmann. It provides extensions to the Java core library by utility classes, abstract concepts and concrete implementations.
The newest version!
/*
 * Copyright (C) 2004-2015 Volker Bergmann ([email protected]).
 * All rights reserved.
 *
 * 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.databene.commons.mutator;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Map;

import org.databene.commons.Assert;
import org.databene.commons.BeanUtil;
import org.databene.commons.Composite;
import org.databene.commons.ConfigurationError;
import org.databene.commons.Context;
import org.databene.commons.ConversionException;
import org.databene.commons.Escalator;
import org.databene.commons.LoggerEscalator;
import org.databene.commons.UpdateFailedException;
import org.databene.commons.accessor.FeatureAccessor;
import org.databene.commons.converter.AnyConverter;

/**
 * Mutator implementation for graphs of any object types.
 * Created: 31.01.2008 20:15:11
 * @since 0.3.0
 * @author Volker Bergmann
 */
public class AnyMutator implements NamedMutator {
    
    private static Escalator escalator = new LoggerEscalator();
    
    private String path;
    private boolean required;
    private boolean autoConvert;
    
    public AnyMutator(String path) {
        this(path, true, false);
    }

    public AnyMutator(String path, boolean required, boolean autoConvert) {
        this.path = Assert.notNull(path, "path");
        this.required = required;
        this.autoConvert = autoConvert;
    }

	@Override
	public String getName() {
		return path;
	}
    
    @Override
	public void setValue(Object target, Object value) throws UpdateFailedException {
        setValue(target, path, value, required, autoConvert);
    }
    
    public static  void setValue(C target, String path, V value) {
        setValue(target, path, value, true, false);
    }
    
    public static  void setValue(C target, String path, V value, boolean required, boolean autoConvert) {
        int sep = path.indexOf('.');
        if (sep < 0)
        	// it is a local property
            setLocal(target, path, value, required, autoConvert);
        else {
        	// a recursive feature path needs to be resolved
            String localName = path.substring(0, sep);
            Object subTarget = FeatureAccessor.getValue(target, localName, true);
            if (subTarget == null) {
                // feature exists but is null, so create an object and assign it to the feature
            	subTarget = setFeatureDefault(target, localName);
            }
            String remainingName = path.substring(sep + 1);
            setValue(subTarget, remainingName, value, required, autoConvert);
        }
    }

    public static Object setFeatureDefault(Object target, String featureName) {
    	// try JavaBean property
        PropertyDescriptor propertyDescriptor = BeanUtil.getPropertyDescriptor(target.getClass(), featureName);
        if (propertyDescriptor != null) {
            try {
            	Object value = BeanUtil.newInstance(propertyDescriptor.getPropertyType());
                Method writeMethod = propertyDescriptor.getWriteMethod();
                writeMethod.invoke(target, value);
				return value;
            } catch (Exception e) {
                throw new ConfigurationError("Unable to write feature '" + featureName + "'", e);
            }
        } else {
        	// try attribute
        	Class type = ((target instanceof Class) ? (Class) target : target.getClass());
        	Field field = BeanUtil.getField(type, featureName);
        	if (field != null) {
            	Object value = BeanUtil.newInstance(field.getType());
        		BeanUtil.setAttributeValue(target, field, value);
        		return value;
        	} else {
                throw new ConfigurationError("Feature '" + featureName + "' not found in class " + type.getName());
        	}
        }
    }

    @SuppressWarnings({ "unchecked", "rawtypes" })
    private static  void setLocal(C target, String featureName, V value, boolean required, boolean autoConvert) {
    	if (BeanUtil.hasWriteableProperty(target.getClass(), featureName))
            BeanUtil.setPropertyValue(target, featureName, value, required, autoConvert);
    	else if (target instanceof Context)
            ((Context) target).set(featureName, value);
        else if (target instanceof Map)
            ((Map) target).put(featureName, value);
        else if (target instanceof Composite)
            ((Composite) target).setComponent(featureName, value);
        else {
        	// try generic set(String, Object) method
        	Method genericSetMethod = BeanUtil.findMethod(target.getClass(), "set", String.class, Object.class);
        	if (genericSetMethod != null) {
        		BeanUtil.invoke(target, genericSetMethod, true, new Object[] { featureName, value });
        		return;
        	}
        	// try JavaBean property
        	try {
				Field field = target.getClass().getField(featureName);
		        if (autoConvert && value != null) {
		            Class sourceType = value.getClass();
		            Class targetType = field.getType();
		            try {
		                if (!targetType.isAssignableFrom(sourceType))
		                    value = (V) AnyConverter.convert(value, targetType);
		            } catch (ConversionException e) {
		                throw new ConfigurationError(e);
		            }
		        }
		        field.set(target, value);

			} catch (NoSuchFieldException e) {
	            String message = "No feature '" + featureName + "' found in " + target;
	            if (required)
	                throw new UnsupportedOperationException(message);
	            else
	                escalator.escalate(message, AnyMutator.class, null);
			} catch (IllegalAccessException e) {
				throw new UnsupportedOperationException("Error accessing attribute '" + 
						featureName + "' of class " + target.getClass().getName(), e);
			}
        }
    }

}