@SuppressWarnings({"unchecked"}) private DataType<?> createDataType(Class<?> physicalType, Type type, TypeMapping mapping) { if (type instanceof Class) { // not a generic return new JavaClass(physicalType); } else { JavaTypeInfo info = helper.createTypeInfo(type, mapping); return new JavaGenericType(info); } }
@SuppressWarnings({"unchecked"}) private DataType<?> getDataType(Type type, TypeMapping typeMapping) { if (type instanceof Class) { // non-generic type Class<?> nonGenericType = (Class<?>) type; if (nonGenericType.isPrimitive()) { // convert primitive representation to its object equivalent nonGenericType = ParamTypes.PRIMITIVE_TO_OBJECT.get(nonGenericType); } return new JavaClass(nonGenericType); } else { // a generic JavaTypeInfo info = helper.createTypeInfo(type, typeMapping); return new JavaGenericType(info); } }
@SuppressWarnings({"unchecked"}) private DataType<?> getEventType(EventStream stream, ClassLoader loader) throws ClassNotFoundException { Class<?> type; List<String> eventTypes = stream.getDefinition().getEventTypes(); if (eventTypes.isEmpty()) { // default to Object if there are no event types type = Object.class; } else { type = ParameterTypeHelper.loadClass(eventTypes.get(0), loader); } return new JavaClass(type); }
@SuppressWarnings({"unchecked"}) private List<DataType<?>> createTypes(PhysicalOperationDefinition physicalOperation, ClassLoader loader) throws BrokerException { try { List<DataType<?>> dataTypes = new ArrayList<DataType<?>>(); if (physicalOperation.getSourceParameterTypes().isEmpty()) { // no params dataTypes.add(EMPTY_TYPE); } else { List<Class<?>> types = ParameterTypeHelper.loadSourceInParameterTypes(physicalOperation, loader); for (Class<?> type : types) { dataTypes.add(new JavaClass((type))); } } return dataTypes; } catch (ClassNotFoundException e) { throw new BrokerException("Error transforming parameter", e); } }
@SuppressWarnings({"unchecked"}) public ObjectFactory<?> createFactory(String name, DataType dataType, Document value, ClassLoader classLoader) throws PropertyTransformException { try { Class componentType = dataType.getPhysical().getComponentType(); Class<?> type = componentType; if (type.isPrimitive()) { type = ParamTypes.PRIMITIVE_TO_OBJECT.get(type); } List<Class<?>> types = new ArrayList<Class<?>>(); types.add(type); Transformer<Node, ?> transformer = getTransformer(name, PROPERTY_TYPE, new JavaClass(type), types); Element root = value.getDocumentElement(); NodeList nodes = root.getChildNodes(); Object array = Array.newInstance(componentType, nodes.getLength()); for (int i = 0; i < nodes.getLength(); i++) { Node node = nodes.item(i).getFirstChild(); Object val = transformer.transform(node, classLoader); Array.set(array, i, val); } return new SingletonObjectFactory<Object>(array); } catch (TransformationException e) { throw new PropertyTransformException("Unable to transform property value: " + name, e); } }
/** * Returns a data type from a logical and physical type pairing. * * @param physicalType the physical type * @param type the type to construct the data type from * @param mapping the resolved generic type mappings * @return the data type */ @SuppressWarnings({"unchecked"}) private DataType<?> createDataType(Class<?> physicalType, Type type, TypeMapping mapping) { if (type instanceof Class) { // not a generic return new JavaClass(physicalType); } else { JavaTypeInfo info = helper.createTypeInfo(type, mapping); return new JavaGenericType(info); } }
/** * Returns the key type of the given Map type. * * @param type a type that is a Map * @param typeMapping the type mapping for resolved parameters * @return the key type */ @SuppressWarnings({"unchecked"}) private DataType<?> getKeyType(Type type, TypeMapping typeMapping) { Type actualType = typeMapping.getActualType(type); if (actualType instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) actualType; Type actualKeyType = typeMapping.getActualType(parameterizedType.getActualTypeArguments()[0]); if (actualKeyType instanceof Class) { return new JavaClass((Class) actualKeyType); } else { return new JavaGenericType(createTypeInfo(actualKeyType, typeMapping)); } } else if (actualType instanceof Map) { // the map is not parameterized return new JavaClass<Object>(Object.class); } else { throw new IllegalArgumentException("Type not a Map: " + type); } }
@SuppressWarnings({"unchecked"}) private DataType<?> getEventTypeForConnection(ChannelConnection connection, ClassLoader loader) throws BrokerException { PhysicalEventStreamDefinition eventStreamDefinition = connection.getEventStream().getDefinition(); if (!eventStreamDefinition.getEventTypes().isEmpty()) { try { String eventType = eventStreamDefinition.getEventTypes().get(0); Class<?> type = ParameterTypeHelper.loadClass(eventType, loader); return new JavaClass(type); } catch (ClassNotFoundException e) { throw new BrokerException(e); } } else { return new JavaClass<Object>(Object.class); } }
@SuppressWarnings({"unchecked"}) public <T> ObjectFactory<Collection<T>> createFactory(Collection<T> collection, String name, JavaGenericType dataType, Document value, ClassLoader classLoader) throws PropertyTransformException { try { List<JavaTypeInfo> typeInfos = dataType.getLogical().getParameterTypesInfos(); if (typeInfos.size() < 1) { // programming error throw new PropertyTransformException("Collection properties must have a value type"); } Class<?> type = typeInfos.get(0).getRawType(); List<Class<?>> types = new ArrayList<Class<?>>(); types.add(type); Transformer<Node, ?> transformer = getTransformer(name, PROPERTY_TYPE, new JavaClass(type), types); Element root = value.getDocumentElement(); NodeList nodes = root.getChildNodes(); for (int i = 0; i < nodes.getLength(); i++) { Node node = nodes.item(i).getFirstChild(); T val = (T) transformer.transform(node, classLoader); collection.add(val); } return new SingletonObjectFactory<Collection<T>>(collection); } catch (TransformationException e) { throw new PropertyTransformException("Unable to transform property value: " + name, e); } }
/** * Adds event transformers to convert an event from one format to another. * * @param streamDefinition the stream definition * @param stream the stream being created * @param loader the target classloader to use for the transformation * @throws BuilderException if there is an error adding a filter */ @SuppressWarnings({"unchecked"}) private void addTransformer(PhysicalEventStreamDefinition streamDefinition, EventStream stream, ClassLoader loader) throws BuilderException { if (transformerRegistry == null) { // no transformer registry configured (e.g. during bootstrap) so skip return; } List<String> eventTypes = streamDefinition.getEventTypes(); String stringifiedType = eventTypes.get(0); try { DataType<Object> type = new JavaClass(loader.loadClass(stringifiedType)); TransformerHandler handler = new TransformerHandler(type, transformerRegistry); stream.addHandler(handler); } catch (ClassNotFoundException e) { throw new BuilderException(e); } }
return Enum.valueOf(enumClass, key); DataType<?> targetType = new JavaClass(keyType); return createKey(targetType, key, targetClassLoader);
return false; JavaClass<T> dataType = new JavaClass<T>(consumerType); String target = reader.getAttributeValue(null, "target"); if (target == null) {