static OpenDataException openDataException(String msg, Throwable cause) { return new OpenDataException(msg); }
static void mustBeComparable(Class collection, Type element) throws OpenDataException { if (!(element instanceof Class) || !Comparable.class.isAssignableFrom((Class<?>) element)) { final String msg = "Parameter class " + element + " of " + collection.getName() + " does not implement " + Comparable.class.getName(); throw new OpenDataException(msg); } }
public static CompositeData convert(Object message) throws OpenDataException { OpenTypeFactory f = getFactory(message.getClass()); if (f == null) { throw new OpenDataException("Cannot create a CompositeData for type: " + message.getClass().getName()); } CompositeType ct = f.getCompositeType(); Map<String, Object> fields = f.getFields(message); return new CompositeDataSupport(ct, fields); }
final String msg = "Class " + c.getName() + " has method name clash: " + old.getName() + ", " + method.getName(); throw new OpenDataException(msg); throw new OpenDataException("Can't map " + c.getName() + " to an open data type");
throw new OpenDataException("Cannot convert type: " + objType);
/** * @return the converter for the given Java type, creating it if necessary */ public static synchronized OpenTypeConverter toConverter(Type objType) throws OpenDataException { if (inProgress.containsKey(objType)) { throw new OpenDataException("Recursive data structure, including " + typeName(objType)); } OpenTypeConverter conv; conv = getConverter(objType); if (conv != null) return conv; inProgress.put(objType, objType); try { conv = makeConverter(objType); } catch (OpenDataException e) { throw openDataException("Cannot convert type: " + objType, e); } finally { inProgress.remove(objType); } putConverter(objType, conv); return conv; }
@Override Object toNonNullOpenValue(Object value) throws OpenDataException { final Map<Object, Object> valueMap = (Map<Object, Object>) value; if (valueMap instanceof SortedMap) { Comparator comparator = ((SortedMap) valueMap).comparator(); if (comparator != null) { final String msg = "Cannot convert SortedMap with non-null comparator: " + comparator; IllegalArgumentException iae = new IllegalArgumentException(msg); OpenDataException ode = new OpenDataException(msg); ode.initCause(iae); throw ode; } } final TabularType tabularType = (TabularType) getOpenType(); final TabularData table = new TabularDataSupport(tabularType); final CompositeType rowType = tabularType.getRowType(); for (Map.Entry entry : valueMap.entrySet()) { final Object openKey = keyConverter.toOpenValue(entry.getKey()); final Object openValue = valueConverter.toOpenValue(entry.getValue()); final CompositeData row; row = new CompositeDataSupport(rowType, keyValueArray, new Object[] {openKey, openValue}); table.put(row); } return table; }
/** * @return the open type converter for a given type */ private static OpenTypeConverter makeConverter(Type objType) throws OpenDataException { if (objType instanceof GenericArrayType) { Type componentType = ((GenericArrayType) objType).getGenericComponentType(); return makeArrayOrCollectionConverter(objType, componentType); } else if (objType instanceof Class) { Class objClass = (Class<?>) objType; if (objClass.isEnum()) { return makeEnumConverter(objClass); } else if (objClass.isArray()) { Type componentType = objClass.getComponentType(); return makeArrayOrCollectionConverter(objClass, componentType); } else if (JMX.isMXBeanInterface(objClass)) { throw openDataException("Cannot obtain array class", new ManagementException(" MXBean as an Return Type is not supported")); } else { return makeCompositeConverter(objClass); } } else if (objType instanceof ParameterizedType) { return makeParameterizedConverter((ParameterizedType) objType); } else throw new OpenDataException("Cannot map type: " + objType); }
static OpenDataException openDataException(String msg, Throwable cause) { return new OpenDataException(msg); }
static OpenType<?> getType(final Map item) throws OpenDataException { final Object result = item.get(ITEM_TYPE); if (result instanceof OpenType<?>) return (OpenType<?>) result; else throw new OpenDataException("Item type is not declared"); }
static void mustBeComparable(Class collection, Type element) throws OpenDataException { if (!(element instanceof Class) || !Comparable.class.isAssignableFrom((Class<?>) element)) { final String msg = "Parameter class " + element + " of " + collection.getName() + " does not implement " + Comparable.class.getName(); throw new OpenDataException(msg); } }
public static CompositeData convert(Object message) throws OpenDataException { OpenTypeFactory f = getFactory(message.getClass()); if (f == null) { throw new OpenDataException("Cannot create a CompositeData for type: " + message.getClass().getName()); } CompositeType ct = f.getCompositeType(); Map<String, Object> fields = f.getFields(message); return new CompositeDataSupport(ct, fields); }
public static CompositeData convert(Object message) throws OpenDataException { OpenTypeFactory f = getFactory(message.getClass()); if (f == null) { throw new OpenDataException("Cannot create a CompositeData for type: " + message.getClass().getName()); } CompositeType ct = f.getCompositeType(); Map<String, Object> fields = f.getFields(message); return new CompositeDataSupport(ct, fields); }
public static CompositeData convert(Object message) throws OpenDataException { OpenTypeFactory f = getFactory(message.getClass()); if (f == null) { throw new OpenDataException("Cannot create a CompositeData for type: " + message.getClass().getName()); } CompositeType ct = f.getCompositeType(); Map<String, Object> fields = f.getFields(message); return new CompositeDataSupport(ct, fields); }
public static CompositeData convert(Object message) throws OpenDataException { OpenTypeFactory f = getFactory(message.getClass()); if (f == null) { throw new OpenDataException("Cannot create a CompositeData for type: " + message.getClass().getName()); } CompositeType ct = f.getCompositeType(); Map<String, Object> fields = f.getFields(message); return new CompositeDataSupport(ct, fields); }
@Override public Object get() throws OpenDataException { try { if (converter != null) { return converter.toOpenValue(getMethod.invoke(object)); } else { return getMethod.invoke(object); } } catch (IllegalAccessException | InvocationTargetException ex) { OpenDataException thr = new OpenDataException("Cannot get " + getMethod); thr.addSuppressed(ex); throw thr; } }
public static CompositeData convert(Object message) throws OpenDataException { OpenTypeFactory f = getFactory(message.getClass()); if (f == null) { throw new OpenDataException("Cannot create a CompositeData for type: " + message.getClass().getName()); } CompositeType ct = f.getCompositeType(); Map fields = f.getFields(message); return new CompositeDataSupport(ct, fields); }
public static Object toJSON(Object value) throws OpenDataException { Object result = value; try { ObjectToJsonConverter converter = converters.getToJsonConverter(); result = converter.convertToJson(value, null, JsonConvertOptions.DEFAULT); } catch (RuntimeException rte) { throw rte; } catch (Exception ex) { OpenDataException odex = new OpenDataException("Cannot convert value: " + value.getClass().getName()); odex.initCause(ex); throw odex; } return result; }
@Override public Object toOpenValue(final Object javaValue) throws OpenDataException { Map.Entry entry = (Map.Entry) javaValue; try { return new CompositeDataSupport((CompositeType) getOpenType(), NAMES, new Object[]{typeMapper.get(actualTypeArguments[0]).toOpenValue(entry.getKey()), typeMapper.get(actualTypeArguments[1]).toOpenValue(entry.getValue())}); } catch (NotSerializableException ex) { OpenDataException iex = new OpenDataException("Not serializable " + javaValue); iex.initCause(ex); throw iex; } }
@Override public MXBeanMapping mappingForType(final Type t, final MXBeanMappingFactory f) throws OpenDataException { try { return MXBeanMappings.convert(appenderMap.get(t).get(t)); } catch (NotSerializableException ex) { OpenDataException tex = new OpenDataException(t + " is not serializable"); tex.initCause(ex); throw tex; } } });