Subversion Repositories openrisc

/* Translator.java -- Performs MXBean data type translation.
   Copyright (C) 2007 Free Software Foundation, Inc.
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath 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 for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.javax.management;
 
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
 
import javax.management.JMX;
import javax.management.MBeanServerInvocationHandler;
 
import javax.management.openmbean.ArrayType;
import javax.management.openmbean.CompositeData;
import javax.management.openmbean.CompositeDataSupport;
import javax.management.openmbean.CompositeType;
import javax.management.openmbean.OpenDataException;
import javax.management.openmbean.OpenMBeanParameterInfo;
import javax.management.openmbean.OpenMBeanParameterInfoSupport;
import javax.management.openmbean.OpenType;
import javax.management.openmbean.SimpleType;
import javax.management.openmbean.TabularData;
import javax.management.openmbean.TabularDataSupport;
import javax.management.openmbean.TabularType;
 
/**
 * Translates Java data types to their equivalent
 * open data type, and vice versa, according to the
 * {@link javax.management.MXBean} rules.
 *
 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
 */
public final class Translator
{
 
  /**
   * Translates the input Java data types to the equivalent
   * open data types.
   *
   * @param jtypes the Java types supplied as parameters.
   * @param method the method that was called.
   * @return the equivalent open types required by the {@link MXBean}.
   * @throws Throwable if an exception is thrown in performing the
   *                   conversion.
   */
  public static final Object[] fromJava(Object[] jtypes, Method method)
    throws Throwable
  {
    Type[] gtypes = method.getGenericParameterTypes();
    Object[] otypes = new Object[jtypes.length];
    for (int a = 0; a < jtypes.length; ++a)
      otypes[a] = fromJava(jtypes[a], gtypes[a]);
    return otypes;
  }
 
  /**
   * Translates the input Java data type to the equivalent
   * open data type.
   *
   * @param jtype the Java type supplied as a parameter.
   * @param type the type of the parameter.
   * @return the equivalent open type required by the {@link MXBean}.
   * @throws Throwable if an exception is thrown in performing the
   *                   conversion.
   */
  public static final Object fromJava(Object jtype, Type type)
    throws Throwable
  {
    if (jtype == null)
      return null;
    Class<?> jclass = jtype.getClass();
    if (OpenType.ALLOWED_CLASSNAMES_LIST.contains(jclass.getName()))
      return jtype;
    if (jclass.isArray())
      {
        Class<?> ctype = jclass.getComponentType();
        if (ctype.isPrimitive())
          return jtype;
        if (OpenType.ALLOWED_CLASSNAMES_LIST.contains(ctype.getName()))
          return jtype;
        Object[] elems = (Object[]) jtype;
        Object[] celems = new Object[elems.length];
        for (int a = 0; a < elems.length; ++a)
          celems[a] = fromJava(elems[a], elems[a].getClass());
        return makeArraySpecific(celems);
      }
    String tName = getTypeName(type);
    if (jtype instanceof List || jtype instanceof Set ||
        jtype instanceof SortedSet)
      {
        if (jtype instanceof SortedSet)
          {
            ParameterizedType ptype = (ParameterizedType) type;
            Class<?> elemClass = (Class<?>) ptype.getActualTypeArguments()[0];
            if (!Comparable.class.isAssignableFrom(elemClass))
              throw new IllegalArgumentException(jtype + " has a " +
                                                 "non-comparable element " +
                                                 "type, " + elemClass);
            if (((SortedSet<?>) jtype).comparator() != null)
              throw new IllegalArgumentException(jtype + " does not " +
                                                 "use natural ordering.");
          }
        Collection<?> elems = (Collection<?>) jtype;
        int numElems = elems.size();
        Object[] celems = new Object[numElems];
        Iterator<?> i = elems.iterator();
        for (int a = 0; a < numElems; ++a)
          {
            Object elem = i.next();
            celems[a] = fromJava(elem, elem.getClass());
          }
        return makeArraySpecific(celems);
      }
    if (jtype instanceof Enum)
      return ((Enum<?>) jtype).name();
    if (jtype instanceof Map || jtype instanceof SortedMap)
      {
        int lparam = tName.indexOf("<");
        int comma = tName.indexOf(",", lparam);
        int rparam = tName.indexOf(">", comma);
        String key = tName.substring(lparam + 1, comma).trim();
        String value = tName.substring(comma + 1, rparam).trim();
        String typeName = null;
        if (jtype instanceof Map)
          typeName = "java.util.Map" + tName.substring(lparam);
        else
          {
            Class<?> keyClass = Class.forName(key);
            if (!Comparable.class.isAssignableFrom(keyClass))
              throw new IllegalArgumentException(jtype + " has a " +
                                                 "non-comparable element " +
                                                 "type, " + keyClass);
            if (((SortedMap<?,?>) jtype).comparator() != null)
              throw new IllegalArgumentException(jtype + " does not " +
                                                 "use natural ordering.");
            typeName = "java.util.SortedMap" + tName.substring(lparam);
          }
        OpenType<?> k = translate(key).getOpenType();
        OpenType<?> v = translate(value).getOpenType();
        CompositeType rowType = new CompositeType(typeName, typeName,
                                                  new String[] { "key", "value" },
                                                  new String[] { "Map key", "Map value"},
                                                  new OpenType[] {k,v});
        TabularType tabType = new TabularType(typeName, typeName, rowType,
                                              new String[]{"key"});
        TabularData data = new TabularDataSupport(tabType);
        for (Map.Entry<?,?> entry : ((Map<?,?>) jtype).entrySet())
          {
            try
              {
                data.put(new CompositeDataSupport(rowType,
                                                  new String[] {
                                                    "key",
                                                    "value"
                                                  },
                                                  new Object[] {
                                                    entry.getKey(),
                                                    entry.getValue()
                                                  }));
              }
            catch (OpenDataException e)
              {
                throw (InternalError) (new InternalError("A problem occurred " +
                                                         "converting the map " +
                                                         "to a composite data " +
                                                         "structure.").initCause(e));
              }
          }
        return data;
      }
    if (JMX.isMXBeanInterface(jclass))
      {
        try
          {
            MBeanServerInvocationHandler ih = (MBeanServerInvocationHandler)
              Proxy.getInvocationHandler(jtype);
            return ih.getObjectName();
          }
        catch (IllegalArgumentException e)
          {
            throw new IllegalArgumentException("For a MXBean to be translated " +
                                               "to an open type, it must be a " +
                                               "proxy.", e);
          }
        catch (ClassCastException e)
          {
            throw new IllegalArgumentException("For a MXBean to be translated " +
                                               "to an open type, it must have a " +
                                               "MBeanServerInvocationHandler.", e);
          }
      }
    /* FIXME: Handle other types */
    throw new IllegalArgumentException("The type, " + jtype +
                                       ", is not convertible.");
  }
 
  /**
   * Translates the returned open data type to the value
   * required by the interface.
   *
   * @param otype the open type returned by the method call.
   * @param method the method that was called.
   * @return the equivalent return type required by the interface.
   * @throws Throwable if an exception is thrown in performing the
   *                   conversion.
   */
  public static final Object toJava(Object otype, Method method)
    throws Throwable
  {
    Class<?> returnType = method.getReturnType();
    if (returnType.isEnum())
      {
        String ename = (String) otype;
        Enum<?>[] constants = (Enum[]) returnType.getEnumConstants();
        for (Enum<?> c : constants)
          if (c.name().equals(ename))
            return c;
      }
    if (List.class.isAssignableFrom(returnType))
      {
        Object[] elems = (Object[]) otype;
        List<Object> l = new ArrayList<Object>(elems.length);
        for (Object elem : elems)
          l.add(elem);
        return l;
      }
    if (Map.class.isAssignableFrom(returnType))
      {
        TabularData data = (TabularData) otype;
        Map<Object,Object> m = new HashMap<Object,Object>(data.size());
        for (Object val : data.values())
          {
            CompositeData vals = (CompositeData) val;
            m.put(vals.get("key"), vals.get("value"));
          }
        return m;
      }
    try
      {
        Method m = returnType.getMethod("from",
                                        new Class[]
          { CompositeData.class });
        return m.invoke(null, (CompositeData) otype);
      }
    catch (NoSuchMethodException e)
      {
        /* Ignored; we expect this if this
           isn't a from(CompositeData) class */
      }
    return otype;
  }
 
  /**
   * Creates a new array which has the specific type
   * used by the elements of the original {@link Object}
   * array supplied.
   *
   * @param arr a series of elements in an {@link Object}
   *            array.
   * @return the same elements in a new array of the specific
   *         type.
   */
  private static final Object[] makeArraySpecific(Object[] arr)
  {
    Object[] rcelems = (Object[]) Array.newInstance(arr[0].getClass(),
                                                    arr.length);
    System.arraycopy(arr, 0, rcelems, 0, arr.length);
    return rcelems;
  }
 
  /**
   * Translates the name of a type into an equivalent
   * {@link javax.management.openmbean.OpenMBeanParameterInfo}
   * that describes it.
   *
   * @param type the type to describe.
   * @return an instance of
   * {@link javax.management.openmbean.OpenMBeanParameterInfo},
   * describing the translated type and limits of the given type.
   * @throws OpenDataException if a type is not open.
   */
  public static final OpenMBeanParameterInfo translate(String type)
    throws OpenDataException
  {
    if (type.equals("boolean") || type.equals(Boolean.class.getName()))
      return new OpenMBeanParameterInfoSupport("TransParam",
                                               "Translated parameter",
                                               SimpleType.BOOLEAN,
                                               null,
                                               new Boolean[] {
                                                 Boolean.TRUE,
                                                 Boolean.FALSE
                                               });
    if (type.equals("byte") || type.equals(Byte.class.getName()))
      return new OpenMBeanParameterInfoSupport("TransParam",
                                               "Translated parameter",
                                               SimpleType.BYTE,
                                               null,
                                               Byte.valueOf(Byte.MIN_VALUE),
                                               Byte.valueOf(Byte.MAX_VALUE));
    if (type.equals("char") || type.equals(Character.class.getName()))
      return new OpenMBeanParameterInfoSupport("TransParam",
                                               "Translated parameter",
                                               SimpleType.CHARACTER,
                                               null,
                                               Character.valueOf(Character.MIN_VALUE),
                                               Character.valueOf(Character.MAX_VALUE));
    if (type.equals("double") || type.equals(Double.class.getName()))
      return new OpenMBeanParameterInfoSupport("TransParam",
                                               "Translated parameter",
                                               SimpleType.DOUBLE,
                                               null,
                                               Double.valueOf(Double.MIN_VALUE),
                                               Double.valueOf(Double.MAX_VALUE));
    if (type.equals("float") || type.equals(Float.class.getName()))
      return new OpenMBeanParameterInfoSupport("TransParam",
                                               "Translated parameter",
                                               SimpleType.FLOAT,
                                               null,
                                               Float.valueOf(Float.MIN_VALUE),
                                               Float.valueOf(Float.MAX_VALUE));
    if (type.equals("int") || type.equals(Integer.class.getName()))
      return new OpenMBeanParameterInfoSupport("TransParam",
                                               "Translated parameter",
                                               SimpleType.INTEGER,
                                               null,
                                               Integer.valueOf(Integer.MIN_VALUE),
                                               Integer.valueOf(Integer.MAX_VALUE));
    if (type.equals("long") || type.equals(Long.class.getName()))
      return new OpenMBeanParameterInfoSupport("TransParam",
                                               "Translated parameter",
                                               SimpleType.LONG,
                                               null,
                                               Long.valueOf(Long.MIN_VALUE),
                                               Long.valueOf(Long.MAX_VALUE));
    if (type.equals("short") || type.equals(Short.class.getName()))
      return new OpenMBeanParameterInfoSupport("TransParam",
                                               "Translated parameter",
                                               SimpleType.SHORT,
                                               null,
                                               Short.valueOf(Short.MIN_VALUE),
                                               Short.valueOf(Short.MAX_VALUE));
    if (type.equals(String.class.getName()))
      return new OpenMBeanParameterInfoSupport("TransParam",
                                               "Translated parameter",
                                               SimpleType.STRING);
    if (type.equals("void"))
      return new OpenMBeanParameterInfoSupport("TransParam",
                                               "Translated parameter",
                                               SimpleType.VOID);
    if (type.startsWith("java.util.Map"))
      {
        int lparam = type.indexOf("<");
        int comma = type.indexOf(",", lparam);
        int rparam = type.indexOf(">", comma);
        String key = type.substring(lparam + 1, comma).trim();
        OpenType<?> k = translate(key).getOpenType();
        OpenType<?> v = translate(type.substring(comma + 1, rparam).trim()).getOpenType();
        CompositeType ctype = new CompositeType(Map.class.getName(), Map.class.getName(),
                                                new String[] { "key", "value" },
                                                new String[] { "Map key", "Map value"},
                                                new OpenType[] { k, v});
        TabularType ttype = new TabularType(key, key, ctype,
                                            new String[] { "key" });
        return new OpenMBeanParameterInfoSupport("TransParam",
                                                 "Translated parameter",
                                                 ttype);
      }
    if (type.startsWith("java.util.List"))
      {
        int lparam = type.indexOf("<");
        int rparam = type.indexOf(">");
        OpenType<?> e = translate(type.substring(lparam + 1, rparam).trim()).getOpenType();
        return new OpenMBeanParameterInfoSupport("TransParam",
                                                 "Translated parameter",
                                                 new ArrayType<OpenType<?>>(1, e)
                                                 );
      }
    Class<?> c;
    try
      {
        c = Class.forName(type);
      }
    catch (ClassNotFoundException e)
      {
        throw (InternalError)
          (new InternalError("The class for a type used in a management bean " +
                             "could not be loaded.").initCause(e));
      }
    if (c.isEnum())
      {
        Object[] values = c.getEnumConstants();
        String[] names = new String[values.length];
        for (int a = 0; a < values.length; ++a)
          names[a] = values[a].toString();
        return new OpenMBeanParameterInfoSupport("TransParam",
                                                 "Translated parameter",
                                                 SimpleType.STRING,
                                                 null, names);
      }
    if (c.isArray())
      {
        int depth;
        for (depth = 0; c.getName().charAt(depth) == '['; ++depth)
          ;
        OpenType<?> ot = getTypeFromClass(c.getComponentType());
        return new OpenMBeanParameterInfoSupport("TransParam",
                                                 "Translated parameter",
                                                 new ArrayType<OpenType<?>>(depth, ot)
                                                 );
      }
    Method[] methods = c.getDeclaredMethods();
    List<String> names = new ArrayList<String>();
    List<OpenType<?>> types = new ArrayList<OpenType<?>>();
    for (int a = 0; a < methods.length; ++a)
      {
        String name = methods[a].getName();
        if (Modifier.isPublic(methods[a].getModifiers()))
          {
            if (name.startsWith("get"))
              {
                names.add(name.substring(3));
                types.add(getTypeFromClass(methods[a].getReturnType()));
              }
            else if (name.startsWith("is"))
              {
                names.add(name.substring(2));
                types.add(getTypeFromClass(methods[a].getReturnType()));
              }
          }
      }
    if (names.isEmpty())
      throw new OpenDataException("The type used does not have an open type translation.");
    String[] fields = names.toArray(new String[names.size()]);
    CompositeType ctype = new CompositeType(c.getName(), c.getName(),
                                            fields, fields,
                                            types.toArray(new OpenType[types.size()]));
    return new OpenMBeanParameterInfoSupport("TransParam",
                                             "Translated parameter",
                                             ctype);
  }
 
  /**
   * Obtains the {@link javax.management.openmbean.OpenType}
   * for a particular class.
   *
   * @param c the class to obtain the type for.
   * @return the appropriate instance.
   * @throws OpenDataException if the type is not open.
   */
  private static final OpenType<?> getTypeFromClass(Class<?> c)
    throws OpenDataException
  {
    return Translator.translate(c.getName()).getOpenType();
  }
 
  /**
   * <p>
   * Returns the type name according to the rules described
   * in {@link javax.management.MXBean}.  Namely, for a type,
   * {@code T}, {@code typename(T)} is computed as follows:
   * </p>
   * <ul>
   * <li>If T is non-generic and not an array, then the value
   * of {@link java.lang.Class#getName()} is returned.</li>
   * <li>If T is an array type, {@code{E[]}, then the type name
   * is {@code typename(E)} followed by an occurrence
   * of {@code '[]'} for each dimension.</li>
   * <li>If T is a generic or parameterized type, the type name
   * is composed of {@code typename(P)}, where {@code P} is the
   * parameterized type name, followed by {@code '<'}, the resulting
   * list of type names of the parameters after applying {@code typename}
   * to each, separated by commas, and {@code '>'}.</li>
   * </ul>
   *
   * @param type the type to return the type name of.
   * @return the type name computed according to the rules above.
   */
  private static final String getTypeName(Type type)
  {
    if (type instanceof Class)
      {
        Class<?> c = (Class<?>) type;
        if (c.isArray())
          {
            StringBuilder b =
              new StringBuilder(c.getComponentType().getName());
            String normName = c.getName();
            for (int a = 0; a < normName.length(); ++a)
              {
                if (normName.charAt(a) == '[')
                  b.append("[]");
                else
                  break;
              }
            return b.toString();
          }
        return c.getName();
      }
    return type.toString();
  }
 
}