com.sun.jmx.mbeanserver.MXBeanMapping Java Examples

public Object[] convertParamsToOpenTypes(Object[] params)
    throws OpenDataException {
  final MXBeanMapping[] paramConverters = this.paramConverters;
  if (paramConverters != null && params != null && params.length > 0) {
    final Object[] openTypeParams = new Object[params.length];
    for (int i = 0; i < params.length; i++) {
      openTypeParams[i] = paramConverters[i].toOpenValue(params[i]);
    }
    return openTypeParams;
  } else {
    return params;
  }
}
 

public OpenMethod(Method m) {
  try {
    final MXBeanMappingFactory mapping = MXBeanMappingFactory.DEFAULT;
    final Type[] params = m.getGenericParameterTypes();
    final MXBeanMapping[] paramConverters = new MXBeanMapping[params.length];
    boolean skipParamsConversion = true;
    // using reflection since isIdentity method is package protected
    final Method identityCheck = DefaultMXBeanMappingFactory.class
        .getDeclaredMethod("isIdentity", MXBeanMapping.class);
    identityCheck.setAccessible(true);
    for (int i = 0; i < params.length; i++) {
      paramConverters[i] = mapping.mappingForType(params[i], mapping);
      if (skipParamsConversion) {
        skipParamsConversion = (Boolean)identityCheck.invoke(null,
            paramConverters[i]);
      }
    }
    // null converters denotes no conversion required for the case when
    // all parameter conversions are identity converters
    this.paramConverters = skipParamsConversion ? null : paramConverters;
    this.returnValConverter = mapping.mappingForType(
        m.getGenericReturnType(), mapping);
  } catch (OpenDataException ode) {
    throw new IllegalArgumentException("Failed getting converter of " +
        "parameter or return value to open type for given method: " + m, ode);
  } catch (Exception e) {
    throw new IllegalStateException("Exception getting converter of " +
        "parameter or return value to open type of given method: " + m, e);
  }
}
 

public Object[] convertParamsToOpenTypes(Object[] params)
    throws OpenDataException {
  final MXBeanMapping[] paramConverters = this.paramConverters;
  if (paramConverters != null && params != null && params.length > 0) {
    final Object[] openTypeParams = new Object[params.length];
    for (int i = 0; i < params.length; i++) {
      openTypeParams[i] = paramConverters[i].toOpenValue(params[i]);
    }
    return openTypeParams;
  } else {
    return params;
  }
}
 

public OpenMethod(Method m) {
  try {
    final MXBeanMappingFactory mapping = MXBeanMappingFactory.DEFAULT;
    final Type[] params = m.getGenericParameterTypes();
    final MXBeanMapping[] paramConverters = new MXBeanMapping[params.length];
    boolean skipParamsConversion = true;
    // using reflection since isIdentity method is package protected
    final Method identityCheck = DefaultMXBeanMappingFactory.class
        .getDeclaredMethod("isIdentity", MXBeanMapping.class);
    identityCheck.setAccessible(true);
    for (int i = 0; i < params.length; i++) {
      paramConverters[i] = mapping.mappingForType(params[i], mapping);
      if (skipParamsConversion) {
        skipParamsConversion = (Boolean)identityCheck.invoke(null,
            paramConverters[i]);
      }
    }
    // null converters denotes no conversion required for the case when
    // all parameter conversions are identity converters
    this.paramConverters = skipParamsConversion ? null : paramConverters;
    this.returnValConverter = mapping.mappingForType(
        m.getGenericReturnType(), mapping);
  } catch (OpenDataException ode) {
    throw new IllegalArgumentException("Failed getting converter of " +
        "parameter or return value to open type for given method: " + m, ode);
  } catch (Exception e) {
    throw new IllegalStateException("Exception getting converter of " +
        "parameter or return value to open type of given method: " + m, e);
  }
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
        if (methodName.equals("toString") && args == null)
            return "Proxy[" + compositeData + "]";
        else if (methodName.equals("hashCode") && args == null)
            return compositeData.hashCode() + 0x43444948;
        else if (methodName.equals("equals") && args.length == 1
            && method.getParameterTypes()[0] == Object.class)
            return equals(proxy, args[0]);
        else {
            /* Either someone is calling invoke by hand, or
               it is a non-final method from Object overriden
               by the generated Proxy.  At the time of writing,
               the only non-final methods in Object that are not
               handled above are finalize and clone, and these
               are not overridden in generated proxies.  */
            // this plain Method.invoke is called only if the declaring class
            // is Object and so it's safe.
            return method.invoke(this, args);
        }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
        throw new IllegalArgumentException("Method is not getter: " +
                                           method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName))
        openValue = compositeData.get(propertyName);
    else {
        String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
        if (compositeData.containsKey(decap))
            openValue = compositeData.get(decap);
        else {
            final String msg =
                "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
            throw new IllegalArgumentException(msg);
        }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
                               MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
}
 

/**
 * <p>Return the mapping for the given Java type.  Typically, a
 * mapping factory will return mappings for types it handles, and
 * forward other types to another mapping factory, most often
 * the {@linkplain #DEFAULT default one}.</p>
 * @param t the Java type to be mapped.
 * @param f the original mapping factory that was consulted to do
 * the mapping.  A mapping factory should pass this parameter intact
 * if it forwards a type to another mapping factory.  In the example,
 * this is how {@code MyLinkedListMappingFactory} works for types
 * like {@code MyLinkedList[]} and {@code List<MyLinkedList>}.
 * @return the mapping for the given type.
 * @throws OpenDataException if this type cannot be mapped.  This
 * exception is appropriate if the factory is supposed to handle
 * all types of this sort (for example, all linked lists), but
 * cannot handle this particular type.
 */
public abstract MXBeanMapping mappingForType(Type t, MXBeanMappingFactory f)
throws OpenDataException;
 

/**
 * <p>Return the mapping for the given Java type.  Typically, a
 * mapping factory will return mappings for types it handles, and
 * forward other types to another mapping factory, most often
 * the {@linkplain #DEFAULT default one}.</p>
 * @param t the Java type to be mapped.
 * @param f the original mapping factory that was consulted to do
 * the mapping.  A mapping factory should pass this parameter intact
 * if it forwards a type to another mapping factory.  In the example,
 * this is how {@code MyLinkedListMappingFactory} works for types
 * like {@code MyLinkedList[]} and {@code List<MyLinkedList>}.
 * @return the mapping for the given type.
 * @throws OpenDataException if this type cannot be mapped.  This
 * exception is appropriate if the factory is supposed to handle
 * all types of this sort (for example, all linked lists), but
 * cannot handle this particular type.
 */
public abstract MXBeanMapping mappingForType(Type t, MXBeanMappingFactory f)
throws OpenDataException;
 

/**
 * <p>Return the mapping for the given Java type.  Typically, a
 * mapping factory will return mappings for types it handles, and
 * forward other types to another mapping factory, most often
 * the {@linkplain #DEFAULT default one}.</p>
 * @param t the Java type to be mapped.
 * @param f the original mapping factory that was consulted to do
 * the mapping.  A mapping factory should pass this parameter intact
 * if it forwards a type to another mapping factory.  In the example,
 * this is how {@code MyLinkedListMappingFactory} works for types
 * like {@code MyLinkedList[]} and {@code List<MyLinkedList>}.
 * @return the mapping for the given type.
 * @throws OpenDataException if this type cannot be mapped.  This
 * exception is appropriate if the factory is supposed to handle
 * all types of this sort (for example, all linked lists), but
 * cannot handle this particular type.
 */
public abstract MXBeanMapping mappingForType(Type t, MXBeanMappingFactory f)
throws OpenDataException;
 

/**
 * <p>Return the mapping for the given Java type.  Typically, a
 * mapping factory will return mappings for types it handles, and
 * forward other types to another mapping factory, most often
 * the {@linkplain #DEFAULT default one}.</p>
 * @param t the Java type to be mapped.
 * @param f the original mapping factory that was consulted to do
 * the mapping.  A mapping factory should pass this parameter intact
 * if it forwards a type to another mapping factory.  In the example,
 * this is how {@code MyLinkedListMappingFactory} works for types
 * like {@code MyLinkedList[]} and {@code List<MyLinkedList>}.
 * @return the mapping for the given type.
 * @throws OpenDataException if this type cannot be mapped.  This
 * exception is appropriate if the factory is supposed to handle
 * all types of this sort (for example, all linked lists), but
 * cannot handle this particular type.
 */
public abstract MXBeanMapping mappingForType(Type t, MXBeanMappingFactory f)
throws OpenDataException;
 

/**
 * <p>Return the mapping for the given Java type.  Typically, a
 * mapping factory will return mappings for types it handles, and
 * forward other types to another mapping factory, most often
 * the {@linkplain #DEFAULT default one}.</p>
 * @param t the Java type to be mapped.
 * @param f the original mapping factory that was consulted to do
 * the mapping.  A mapping factory should pass this parameter intact
 * if it forwards a type to another mapping factory.  In the example,
 * this is how {@code MyLinkedListMappingFactory} works for types
 * like {@code MyLinkedList[]} and {@code List<MyLinkedList>}.
 * @return the mapping for the given type.
 * @throws OpenDataException if this type cannot be mapped.  This
 * exception is appropriate if the factory is supposed to handle
 * all types of this sort (for example, all linked lists), but
 * cannot handle this particular type.
 */
public abstract MXBeanMapping mappingForType(Type t, MXBeanMappingFactory f)
throws OpenDataException;
 

/**
 * <p>Return the mapping for the given Java type.  Typically, a
 * mapping factory will return mappings for types it handles, and
 * forward other types to another mapping factory, most often
 * the {@linkplain #DEFAULT default one}.</p>
 * @param t the Java type to be mapped.
 * @param f the original mapping factory that was consulted to do
 * the mapping.  A mapping factory should pass this parameter intact
 * if it forwards a type to another mapping factory.  In the example,
 * this is how {@code MyLinkedListMappingFactory} works for types
 * like {@code MyLinkedList[]} and {@code List<MyLinkedList>}.
 * @return the mapping for the given type.
 * @throws OpenDataException if this type cannot be mapped.  This
 * exception is appropriate if the factory is supposed to handle
 * all types of this sort (for example, all linked lists), but
 * cannot handle this particular type.
 */
public abstract MXBeanMapping mappingForType(Type t, MXBeanMappingFactory f)
throws OpenDataException;
 

/**
 * <p>Return the mapping for the given Java type.  Typically, a
 * mapping factory will return mappings for types it handles, and
 * forward other types to another mapping factory, most often
 * the {@linkplain #DEFAULT default one}.</p>
 * @param t the Java type to be mapped.
 * @param f the original mapping factory that was consulted to do
 * the mapping.  A mapping factory should pass this parameter intact
 * if it forwards a type to another mapping factory.  In the example,
 * this is how {@code MyLinkedListMappingFactory} works for types
 * like {@code MyLinkedList[]} and {@code List<MyLinkedList>}.
 * @return the mapping for the given type.
 * @throws OpenDataException if this type cannot be mapped.  This
 * exception is appropriate if the factory is supposed to handle
 * all types of this sort (for example, all linked lists), but
 * cannot handle this particular type.
 */
public abstract MXBeanMapping mappingForType(Type t, MXBeanMappingFactory f)
throws OpenDataException;
 

/**
 * <p>Return the mapping for the given Java type.  Typically, a
 * mapping factory will return mappings for types it handles, and
 * forward other types to another mapping factory, most often
 * the {@linkplain #DEFAULT default one}.</p>
 * @param t the Java type to be mapped.
 * @param f the original mapping factory that was consulted to do
 * the mapping.  A mapping factory should pass this parameter intact
 * if it forwards a type to another mapping factory.  In the example,
 * this is how {@code MyLinkedListMappingFactory} works for types
 * like {@code MyLinkedList[]} and {@code List<MyLinkedList>}.
 * @return the mapping for the given type.
 * @throws OpenDataException if this type cannot be mapped.  This
 * exception is appropriate if the factory is supposed to handle
 * all types of this sort (for example, all linked lists), but
 * cannot handle this particular type.
 */
public abstract MXBeanMapping mappingForType(Type t, MXBeanMappingFactory f)
throws OpenDataException;
 

/**
 * <p>Return the mapping for the given Java type.  Typically, a
 * mapping factory will return mappings for types it handles, and
 * forward other types to another mapping factory, most often
 * the {@linkplain #DEFAULT default one}.</p>
 * @param t the Java type to be mapped.
 * @param f the original mapping factory that was consulted to do
 * the mapping.  A mapping factory should pass this parameter intact
 * if it forwards a type to another mapping factory.  In the example,
 * this is how {@code MyLinkedListMappingFactory} works for types
 * like {@code MyLinkedList[]} and {@code List<MyLinkedList>}.
 * @return the mapping for the given type.
 * @throws OpenDataException if this type cannot be mapped.  This
 * exception is appropriate if the factory is supposed to handle
 * all types of this sort (for example, all linked lists), but
 * cannot handle this particular type.
 */
public abstract MXBeanMapping mappingForType(Type t, MXBeanMappingFactory f)
throws OpenDataException;
 

/**
 * <p>Return the mapping for the given Java type.  Typically, a
 * mapping factory will return mappings for types it handles, and
 * forward other types to another mapping factory, most often
 * the {@linkplain #DEFAULT default one}.</p>
 * @param t the Java type to be mapped.
 * @param f the original mapping factory that was consulted to do
 * the mapping.  A mapping factory should pass this parameter intact
 * if it forwards a type to another mapping factory.  In the example,
 * this is how {@code MyLinkedListMappingFactory} works for types
 * like {@code MyLinkedList[]} and {@code List<MyLinkedList>}.
 * @return the mapping for the given type.
 * @throws OpenDataException if this type cannot be mapped.  This
 * exception is appropriate if the factory is supposed to handle
 * all types of this sort (for example, all linked lists), but
 * cannot handle this particular type.
 */
public abstract MXBeanMapping mappingForType(Type t, MXBeanMappingFactory f)
throws OpenDataException;