Back to index...

	/*
	* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package com.sun.jmx.mbeanserver;
	import java.io.InvalidObjectException;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.lang.reflect.Type;

	import javax.management.Descriptor;
	import javax.management.MBeanException;
	import javax.management.openmbean.OpenDataException;
	import javax.management.openmbean.OpenType;
	import sun.reflect.misc.MethodUtil;

	final class ConvertingMethod {
	static ConvertingMethod from(Method m) {
	try {
	return new ConvertingMethod(m);
	} catch (OpenDataException ode) {
	final String msg = "Method " + m.getDeclaringClass().getName() +
	"." + m.getName() + " has parameter or return type that " +
	"cannot be translated into an open type";
	throw new IllegalArgumentException(msg, ode);
	}
	}

	Method getMethod() {
	return method;
	}

	Descriptor getDescriptor() {
	return Introspector.descriptorForElement(method);
	}

	Type getGenericReturnType() {
	return method.getGenericReturnType();
	}

	Type[] getGenericParameterTypes() {
	return method.getGenericParameterTypes();
	}

	String getName() {
	return method.getName();
	}

	OpenType<?> getOpenReturnType() {
	return returnMapping.getOpenType();
	}

	OpenType<?>[] getOpenParameterTypes() {
	final OpenType<?>[] types = new OpenType<?>[paramMappings.length];
	for (int i = 0; i < paramMappings.length; i++)
	types[i] = paramMappings[i].getOpenType();
	return types;
	}

	/* Check that this method will be callable when we are going from
	* open types to Java types, for example when we are going from
	* an MXBean wrapper to the underlying resource.
	* The parameters will be converted to
	* Java types, so they must be "reconstructible". The return
	* value will be converted to an Open Type, so if it is convertible
	* at all there is no further check needed.
	*/
	void checkCallFromOpen() {
	try {
	for (MXBeanMapping paramConverter : paramMappings)
	paramConverter.checkReconstructible();
	} catch (InvalidObjectException e) {
	throw new IllegalArgumentException(e);
	}
	}

	/* Check that this method will be callable when we are going from
	* Java types to open types, for example when we are going from
	* an MXBean proxy to the open types that it will be mapped to.
	* The return type will be converted back to a Java type, so it
	* must be "reconstructible". The parameters will be converted to
	* open types, so if it is convertible at all there is no further
	* check needed.
	*/
	void checkCallToOpen() {
	try {
	returnMapping.checkReconstructible();
	} catch (InvalidObjectException e) {
	throw new IllegalArgumentException(e);
	}
	}

	String[] getOpenSignature() {
	if (paramMappings.length == 0)
	return noStrings;

	String[] sig = new String[paramMappings.length];
	for (int i = 0; i < paramMappings.length; i++)
	sig[i] = paramMappings[i].getOpenClass().getName();
	return sig;
	}

	final Object toOpenReturnValue(MXBeanLookup lookup, Object ret)
	throws OpenDataException {
	return returnMapping.toOpenValue(ret);
	}

	final Object fromOpenReturnValue(MXBeanLookup lookup, Object ret)
	throws InvalidObjectException {
	return returnMapping.fromOpenValue(ret);
	}

	final Object[] toOpenParameters(MXBeanLookup lookup, Object[] params)
	throws OpenDataException {
	if (paramConversionIsIdentity \|\| params == null)
	return params;
	final Object[] oparams = new Object[params.length];
	for (int i = 0; i < params.length; i++)
	oparams[i] = paramMappings[i].toOpenValue(params[i]);
	return oparams;
	}

	final Object[] fromOpenParameters(Object[] params)
	throws InvalidObjectException {
	if (paramConversionIsIdentity \|\| params == null)
	return params;
	final Object[] jparams = new Object[params.length];
	for (int i = 0; i < params.length; i++)
	jparams[i] = paramMappings[i].fromOpenValue(params[i]);
	return jparams;
	}

	final Object toOpenParameter(MXBeanLookup lookup,
	Object param,
	int paramNo)
	throws OpenDataException {
	return paramMappings[paramNo].toOpenValue(param);
	}

	final Object fromOpenParameter(MXBeanLookup lookup,
	Object param,
	int paramNo)
	throws InvalidObjectException {
	return paramMappings[paramNo].fromOpenValue(param);
	}

	Object invokeWithOpenReturn(MXBeanLookup lookup,
	Object obj, Object[] params)
	throws MBeanException, IllegalAccessException,
	InvocationTargetException {
	MXBeanLookup old = MXBeanLookup.getLookup();
	try {
	MXBeanLookup.setLookup(lookup);
	return invokeWithOpenReturn(obj, params);
	} finally {
	MXBeanLookup.setLookup(old);
	}
	}

	private Object invokeWithOpenReturn(Object obj, Object[] params)
	throws MBeanException, IllegalAccessException,
	InvocationTargetException {
	final Object[] javaParams;
	try {
	javaParams = fromOpenParameters(params);
	} catch (InvalidObjectException e) {
	// probably can't happen
	final String msg = methodName() + ": cannot convert parameters " +
	"from open values: " + e;
	throw new MBeanException(e, msg);
	}
	final Object javaReturn = MethodUtil.invoke(method, obj, javaParams);
	try {
	return returnMapping.toOpenValue(javaReturn);
	} catch (OpenDataException e) {
	// probably can't happen
	final String msg = methodName() + ": cannot convert return " +
	"value to open value: " + e;
	throw new MBeanException(e, msg);
	}
	}

	private String methodName() {
	return method.getDeclaringClass() + "." + method.getName();
	}

	private ConvertingMethod(Method m) throws OpenDataException {
	this.method = m;
	MXBeanMappingFactory mappingFactory = MXBeanMappingFactory.DEFAULT;
	returnMapping =
	mappingFactory.mappingForType(m.getGenericReturnType(), mappingFactory);
	Type[] params = m.getGenericParameterTypes();
	paramMappings = new MXBeanMapping[params.length];
	boolean identity = true;
	for (int i = 0; i < params.length; i++) {
	paramMappings[i] = mappingFactory.mappingForType(params[i], mappingFactory);
	identity &= DefaultMXBeanMappingFactory.isIdentity(paramMappings[i]);
	}
	paramConversionIsIdentity = identity;
	}

	private static final String[] noStrings = new String[0];

	private final Method method;
	private final MXBeanMapping returnMapping;
	private final MXBeanMapping[] paramMappings;
	private final boolean paramConversionIsIdentity;
	}

Back to index...