org.eclipse.osbp.abstractstatemachine/src/org/eclipse/osbp/abstractstatemachine/AbstractStateMachineParticipant.java - osbp/org.eclipse.osbp.abstractstatemachine - Git at Google

 /*
  *
  *  Copyright (c) 2011 - 2016 - Loetz GmbH & Co KG, 69115 Heidelberg, Germany
  *
  *  All rights reserved. This program and the accompanying materials
  *  are made available under the terms of the Eclipse Public License 2.0
  *  which accompanies this distribution, and is available at
  *  https://www.eclipse.org/legal/epl-2.0/
  *
  *  SPDX-License-Identifier: EPL-2.0
  *
  *  Initial contribution:
  *     Loetz GmbH & Co. KG
  *
  */
  package org.eclipse.osbp.abstractstatemachine;

 import java.beans.BeanInfo;
 import java.beans.IntrospectionException;
 import java.beans.Introspector;
 import java.beans.MethodDescriptor;
 import java.beans.PropertyChangeListener;
 import java.beans.PropertyChangeSupport;
 import java.beans.PropertyDescriptor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.Date;
 import java.util.Locale;

 import org.apache.commons.lang3.ClassUtils;
 import org.eclipse.osbp.dsl.common.datatypes.IDto;
 import org.eclipse.osbp.ui.api.statemachine.IStateMachine;
 import org.eclipse.osbp.ui.api.statemachine.IStateMachineParticipant;
 import org.joda.time.DateTime;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 public abstract class AbstractStateMachineParticipant implements
 		IStateMachineParticipant {
 	private static final long serialVersionUID = -7670617914357429160L;
 	/** The LOGGER. */
 	protected static final Logger LOGGER = LoggerFactory
 			.getLogger(AbstractStateMachineParticipant.class);
 	protected PropertyChangeSupport pcs = new PropertyChangeSupport(this);
 	protected transient IStateMachine statemachine;
 	protected Locale locale;

 	@Override
 	public boolean equals(Object obj) {
 		return super.equals(obj);
 	}

 	@Override
 	public int hashCode() {
 		return super.hashCode();
 	}

 	void addPropertyChangeListener(PropertyChangeListener listener) {
 		pcs.addPropertyChangeListener(listener);
 	}

 	public void addPropertyChangeListener(String propertyName,
 			PropertyChangeListener listener) {
 		pcs.addPropertyChangeListener(propertyName, listener);
 	}

 	public void removePropertyChangeListener(PropertyChangeListener listener) {
 		pcs.removePropertyChangeListener(listener);
 	}

 	public void removePropertyChangeListener(String propertyName,
 			PropertyChangeListener listener) {
 		pcs.removePropertyChangeListener(propertyName, listener);
 	}

 	@Override
 	public IStateMachine getStatemachine() {
 		return statemachine;
 	}

 	@Override
 	public void setStatemachine(IStateMachine statemachine) {
 		this.statemachine = statemachine;
 	}

 	@Override
 	public void setLocale(Locale locale) {
 		this.locale = locale;
 	}

 	@Override
 	public Method getter(Object listener, String id) {
 		if (id == null) {
 			return null;
 		}
 		Class<?> clz = listener.getClass();
 		try {
 			BeanInfo info = Introspector.getBeanInfo(clz);
 			for (PropertyDescriptor desc : info.getPropertyDescriptors()) {
 				if (desc.getName().equalsIgnoreCase(id)) {
 					return desc.getReadMethod();
 				}
 			}
 		} catch (IntrospectionException e) {
 			LOGGER.error("{}", e);
 		}
 		return null;
 	}

 	@Override
 	public Method setter(Object listener, String id, Class<?> parameter, int contentIndex) {
 		if (id == null) {
 			return null;
 		}
 		Class<?> clz = listener.getClass();
 		try {
 			BeanInfo info = Introspector.getBeanInfo(clz);
 			for (MethodDescriptor desc : info.getMethodDescriptors()) {
 				if (desc.getName().equalsIgnoreCase("set"+id)) {
 					Method method = desc.getMethod();
 					Class<?>[] paras = method.getParameterTypes();
 					if(paras.length > contentIndex && (ClassUtils.isAssignable(paras[contentIndex], parameter, true) || ClassUtils.isAssignable(parameter, paras[contentIndex], true))) {
 						return desc.getMethod();
 					}
 				}
 			}
 		} catch (IntrospectionException e) {
 			LOGGER.error("{}", e);
 		}
 		return null;
 	}

 	@Override
 	public Method setter(Object listener, String id, Class<?> parameter) {
 		return setter(listener, id, parameter, 0);
 	}
 	@Override
 	public Method setter(Object listener, String id, Object content, int contentIndex) {
 		if(content != null) {
 			return setter(listener, id, content.getClass(), contentIndex);
 		} else {
 			return setter(listener, id, null, contentIndex);
 		}
 	}

 	@Override
 	public Class<?> getReturnType(Object obj, String id) {
 		if (id == null) {
 			return null;
 		}
 		Class<?> clz = obj.getClass();

 		try {
 			BeanInfo info = Introspector.getBeanInfo(clz);
 			for (PropertyDescriptor desc : info.getPropertyDescriptors()) {
 				if (desc.getName().equalsIgnoreCase(id)) {
 					Method method = desc.getReadMethod();
 					return method.getReturnType();
 				}
 			}
 		} catch (IntrospectionException e) {
 			LOGGER.error("{}", e);
 		}
 		return null;
 	}

 	@Override
 	public void toggle(Object obj, String id) {
 		Object result = get(obj, id);
 		if(result != null) {
 			if(result.getClass().isAssignableFrom(Boolean.class)) {
 				if((Boolean)result) {
 					set(obj, id, false);
 				} else {
 					set(obj, id, true);
 				}
 			}
 			if(result.getClass().isAssignableFrom(boolean.class)) {
 				if((boolean)result) {
 					set(obj, id, false);
 				} else {
 					set(obj, id, true);
 				}
 			}
 		} else {
 			set(obj, id, true);
 		}
 	}

 	@Override
 	public void set(Object obj, String id, Object content) {
 		try {
 			Method method = setter(obj, id, content, 0);
 			if (method != null) {
 				method.invoke(obj, content);
 			}
 		} catch (IllegalAccessException | IllegalArgumentException
 				| InvocationTargetException e) {
 			LOGGER.error("{}", e);
 		}
 	}

 	@Override
 	public void set(Object obj, String id, String device, Object content) {
 		try {
 			Method method = setter(obj, id, content, 1);
 			if (method != null) {
 				method.invoke(obj, device, content);
 			}
 		} catch (IllegalAccessException | IllegalArgumentException
 				| InvocationTargetException e) {
 			LOGGER.error("{}", e);
 		}
 	}

 	@Override
 	public Object get(Object obj, String id) {
 		Method method = getter(obj, id);
 		if (method == null) {
 			return null;
 		}
 		try {
 			return method.invoke(obj);
 		} catch (IllegalAccessException | IllegalArgumentException
 				| InvocationTargetException e) {
 			LOGGER.error("{}", e);
 			return null;
 		}
 	}

 	@Override
 	public void clear(Object obj, String id) {
 		Method method = setter(obj, id, "", 0);
 		if (method != null) {
 			try {
 				method.invoke(obj, "");
 				return;
 			} catch (IllegalAccessException | IllegalArgumentException
 					| InvocationTargetException e) {
 				LOGGER.error("{}", e);
 			}
 		}
 		method = setter(obj, id, 0.0, 0);
 		if (method != null) {
 			try {
 				method.invoke(obj, 0.0);
 				return;
 			} catch (IllegalAccessException | IllegalArgumentException
 					| InvocationTargetException e) {
 				LOGGER.error("{}", e);
 			}
 		}
 		method = setter(obj, id, 0, 0);
 		if (method != null) {
 			try {
 				method.invoke(obj, 0);
 				return;
 			} catch (IllegalAccessException | IllegalArgumentException
 					| InvocationTargetException e) {
 				LOGGER.error("{}", e);
 			}
 		}
 		method = setter(obj, id, 0L, 0);
 		if (method != null) {
 			try {
 				method.invoke(obj, 0L);
 				return;
 			} catch (IllegalAccessException | IllegalArgumentException
 					| InvocationTargetException e) {
 				LOGGER.error("{}", e);
 			}
 		}
 		method = setter(obj, id, IDto.class, 0);
 		if (method != null) {
 			try {
 				method.invoke(obj, (Object[])null);
 				return;
 			} catch (IllegalAccessException | IllegalArgumentException
 					| InvocationTargetException e) {
 				LOGGER.error("{}", e);
 			}
 		}
 		method = setter(obj, id, Date.class, 0);
 		if (method != null) {
 			try {
 				method.invoke(obj, (Date)null);
 				return;
 			} catch (IllegalAccessException | IllegalArgumentException
 					| InvocationTargetException e) {
 				LOGGER.error("{}", e);
 			}
 		}
 		method = setter(obj, id, DateTime.class, 0);
 		if (method != null) {
 			try {
 				method.invoke(obj, (DateTime)null);
 				return;
 			} catch (IllegalAccessException | IllegalArgumentException
 					| InvocationTargetException e) {
 				LOGGER.error("{}", e);
 			}
 		}
 	}
 }
	/*
	*
	* Copyright (c) 2011 - 2016 - Loetz GmbH & Co KG, 69115 Heidelberg, Germany
	*
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Initial contribution:
	* Loetz GmbH & Co. KG
	*
	*/
	package org.eclipse.osbp.abstractstatemachine;

	import java.beans.BeanInfo;
	import java.beans.IntrospectionException;
	import java.beans.Introspector;
	import java.beans.MethodDescriptor;
	import java.beans.PropertyChangeListener;
	import java.beans.PropertyChangeSupport;
	import java.beans.PropertyDescriptor;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.util.Date;
	import java.util.Locale;

	import org.apache.commons.lang3.ClassUtils;
	import org.eclipse.osbp.dsl.common.datatypes.IDto;
	import org.eclipse.osbp.ui.api.statemachine.IStateMachine;
	import org.eclipse.osbp.ui.api.statemachine.IStateMachineParticipant;
	import org.joda.time.DateTime;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	public abstract class AbstractStateMachineParticipant implements
	IStateMachineParticipant {
	private static final long serialVersionUID = -7670617914357429160L;
	/** The LOGGER. */
	protected static final Logger LOGGER = LoggerFactory
	.getLogger(AbstractStateMachineParticipant.class);
	protected PropertyChangeSupport pcs = new PropertyChangeSupport(this);
	protected transient IStateMachine statemachine;
	protected Locale locale;

	@Override
	public boolean equals(Object obj) {
	return super.equals(obj);
	}

	@Override
	public int hashCode() {
	return super.hashCode();
	}

	void addPropertyChangeListener(PropertyChangeListener listener) {
	pcs.addPropertyChangeListener(listener);
	}

	public void addPropertyChangeListener(String propertyName,
	PropertyChangeListener listener) {
	pcs.addPropertyChangeListener(propertyName, listener);
	}

	public void removePropertyChangeListener(PropertyChangeListener listener) {
	pcs.removePropertyChangeListener(listener);
	}

	public void removePropertyChangeListener(String propertyName,
	PropertyChangeListener listener) {
	pcs.removePropertyChangeListener(propertyName, listener);
	}

	@Override
	public IStateMachine getStatemachine() {
	return statemachine;
	}

	@Override
	public void setStatemachine(IStateMachine statemachine) {
	this.statemachine = statemachine;
	}

	@Override
	public void setLocale(Locale locale) {
	this.locale = locale;
	}

	@Override
	public Method getter(Object listener, String id) {
	if (id == null) {
	return null;
	}
	Class<?> clz = listener.getClass();
	try {
	BeanInfo info = Introspector.getBeanInfo(clz);
	for (PropertyDescriptor desc : info.getPropertyDescriptors()) {
	if (desc.getName().equalsIgnoreCase(id)) {
	return desc.getReadMethod();
	}
	}
	} catch (IntrospectionException e) {
	LOGGER.error("{}", e);
	}
	return null;
	}

	@Override
	public Method setter(Object listener, String id, Class<?> parameter, int contentIndex) {
	if (id == null) {
	return null;
	}
	Class<?> clz = listener.getClass();
	try {
	BeanInfo info = Introspector.getBeanInfo(clz);
	for (MethodDescriptor desc : info.getMethodDescriptors()) {
	if (desc.getName().equalsIgnoreCase("set"+id)) {
	Method method = desc.getMethod();
	Class<?>[] paras = method.getParameterTypes();
	if(paras.length > contentIndex && (ClassUtils.isAssignable(paras[contentIndex], parameter, true) \|\| ClassUtils.isAssignable(parameter, paras[contentIndex], true))) {
	return desc.getMethod();
	}
	}
	}
	} catch (IntrospectionException e) {
	LOGGER.error("{}", e);
	}
	return null;
	}

	@Override
	public Method setter(Object listener, String id, Class<?> parameter) {
	return setter(listener, id, parameter, 0);
	}
	@Override
	public Method setter(Object listener, String id, Object content, int contentIndex) {
	if(content != null) {
	return setter(listener, id, content.getClass(), contentIndex);
	} else {
	return setter(listener, id, null, contentIndex);
	}
	}

	@Override
	public Class<?> getReturnType(Object obj, String id) {
	if (id == null) {
	return null;
	}
	Class<?> clz = obj.getClass();

	try {
	BeanInfo info = Introspector.getBeanInfo(clz);
	for (PropertyDescriptor desc : info.getPropertyDescriptors()) {
	if (desc.getName().equalsIgnoreCase(id)) {
	Method method = desc.getReadMethod();
	return method.getReturnType();
	}
	}
	} catch (IntrospectionException e) {
	LOGGER.error("{}", e);
	}
	return null;
	}

	@Override
	public void toggle(Object obj, String id) {
	Object result = get(obj, id);
	if(result != null) {
	if(result.getClass().isAssignableFrom(Boolean.class)) {
	if((Boolean)result) {
	set(obj, id, false);
	} else {
	set(obj, id, true);
	}
	}
	if(result.getClass().isAssignableFrom(boolean.class)) {
	if((boolean)result) {
	set(obj, id, false);
	} else {
	set(obj, id, true);
	}
	}
	} else {
	set(obj, id, true);
	}
	}

	@Override
	public void set(Object obj, String id, Object content) {
	try {
	Method method = setter(obj, id, content, 0);
	if (method != null) {
	method.invoke(obj, content);
	}
	} catch (IllegalAccessException \| IllegalArgumentException
	\| InvocationTargetException e) {
	LOGGER.error("{}", e);
	}
	}

	@Override
	public void set(Object obj, String id, String device, Object content) {
	try {
	Method method = setter(obj, id, content, 1);
	if (method != null) {
	method.invoke(obj, device, content);
	}
	} catch (IllegalAccessException \| IllegalArgumentException
	\| InvocationTargetException e) {
	LOGGER.error("{}", e);
	}
	}

	@Override
	public Object get(Object obj, String id) {
	Method method = getter(obj, id);
	if (method == null) {
	return null;
	}
	try {
	return method.invoke(obj);
	} catch (IllegalAccessException \| IllegalArgumentException
	\| InvocationTargetException e) {
	LOGGER.error("{}", e);
	return null;
	}
	}

	@Override
	public void clear(Object obj, String id) {
	Method method = setter(obj, id, "", 0);
	if (method != null) {
	try {
	method.invoke(obj, "");
	return;
	} catch (IllegalAccessException \| IllegalArgumentException
	\| InvocationTargetException e) {
	LOGGER.error("{}", e);
	}
	}
	method = setter(obj, id, 0.0, 0);
	if (method != null) {
	try {
	method.invoke(obj, 0.0);
	return;
	} catch (IllegalAccessException \| IllegalArgumentException
	\| InvocationTargetException e) {
	LOGGER.error("{}", e);
	}
	}
	method = setter(obj, id, 0, 0);
	if (method != null) {
	try {
	method.invoke(obj, 0);
	return;
	} catch (IllegalAccessException \| IllegalArgumentException
	\| InvocationTargetException e) {
	LOGGER.error("{}", e);
	}
	}
	method = setter(obj, id, 0L, 0);
	if (method != null) {
	try {
	method.invoke(obj, 0L);
	return;
	} catch (IllegalAccessException \| IllegalArgumentException
	\| InvocationTargetException e) {
	LOGGER.error("{}", e);
	}
	}
	method = setter(obj, id, IDto.class, 0);
	if (method != null) {
	try {
	method.invoke(obj, (Object[])null);
	return;
	} catch (IllegalAccessException \| IllegalArgumentException
	\| InvocationTargetException e) {
	LOGGER.error("{}", e);
	}
	}
	method = setter(obj, id, Date.class, 0);
	if (method != null) {
	try {
	method.invoke(obj, (Date)null);
	return;
	} catch (IllegalAccessException \| IllegalArgumentException
	\| InvocationTargetException e) {
	LOGGER.error("{}", e);
	}
	}
	method = setter(obj, id, DateTime.class, 0);
	if (method != null) {
	try {
	method.invoke(obj, (DateTime)null);
	return;
	} catch (IllegalAccessException \| IllegalArgumentException
	\| InvocationTargetException e) {
	LOGGER.error("{}", e);
	}
	}
	}
	}