@SuppressWarnings({"unchecked"}) private DataType getEventType(EventStream stream) { return new JavaType(stream.getEventType()); }
public static List<DataType> createTypes(PhysicalOperation physicalOperation) throws Fabric3Exception { List<DataType> dataTypes = new ArrayList<>(); if (!physicalOperation.getSourceParameterTypes().isEmpty()) { List<Class<?>> types = physicalOperation.getSourceParameterTypes(); dataTypes.addAll(types.stream().map(type -> new JavaType((type))).collect(Collectors.toList())); } return dataTypes; }
@SuppressWarnings({"unchecked"}) private List<DataType> createTypes(PhysicalOperation physicalOperation) throws Fabric3Exception { List<DataType> dataTypes = new ArrayList<>(); if (physicalOperation.getSourceParameterTypes().isEmpty()) { // no params dataTypes.add(EMPTY_TYPE); } else { List<Class<?>> types = physicalOperation.getSourceParameterTypes(); dataTypes.addAll(types.stream().map(type -> new JavaType((type))).collect(Collectors.toList())); } return dataTypes; }
@SuppressWarnings({"unchecked"}) public Supplier<?> createSupplier(String name, DataType dataType, Document value, ClassLoader classLoader) { Class componentType = dataType.getType().getComponentType(); Class<?> type = componentType; if (type.isPrimitive()) { type = ParamTypes.PRIMITIVE_TO_OBJECT.get(type); } List<Class<?>> types = new ArrayList<>(); types.add(type); Transformer<Node, ?> transformer = getTransformer(name, PROPERTY_TYPE, new JavaType(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 () -> array; }
@SuppressWarnings({"unchecked"}) public Supplier<?> createSupplier(String name, DataType dataType, Document value, ClassLoader classLoader) { Class componentType = dataType.getType().getComponentType(); Class<?> type = componentType; if (type.isPrimitive()) { type = ParamTypes.PRIMITIVE_TO_OBJECT.get(type); } List<Class<?>> types = new ArrayList<>(); types.add(type); Transformer<Node, ?> transformer = getTransformer(name, PROPERTY_TYPE, new JavaType(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 () -> array; }
@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 JavaType(nonGenericType); } else { // a generic JavaTypeInfo info = helper.createTypeInfo(type, typeMapping); 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 JavaType(nonGenericType); } else { // a generic JavaTypeInfo info = helper.createTypeInfo(type, typeMapping); return new JavaGenericType(info); } }
@SuppressWarnings({"unchecked"}) public <T> Supplier<Collection<T>> createSupplier(Collection<T> collection, String name, JavaGenericType dataType, Document value, ClassLoader classLoader) { List<JavaTypeInfo> typeInfos = dataType.getTypeInfo().getParameterTypesInfos(); if (typeInfos.size() < 1) { // programming error throw new Fabric3Exception("Collection properties must have a value type"); } Class<?> type = typeInfos.get(0).getRawType(); List<Class<?>> types = new ArrayList<>(); types.add(type); Transformer<Node, ?> transformer = getTransformer(name, PROPERTY_TYPE, new JavaType(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 () -> collection; }
/** * 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 JavaType((Class) actualKeyType); } else { return new JavaGenericType(createTypeInfo(actualKeyType, typeMapping)); } } else if (actualType instanceof Map) { // the map is not parameterized return new JavaType(Object.class); } else { throw new IllegalArgumentException("Type not a Map: " + type); } }
/** * Returns a data type from a logical and physical type pairing. * * @param rawType the raw type * @param actualType 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<?> rawType, Type actualType, TypeMapping mapping) { if (actualType instanceof Class) { // not a generic return new JavaType(rawType); } else { JavaTypeInfo info = helper.createTypeInfo(actualType, mapping); return new JavaGenericType(info); } }
@SuppressWarnings({"unchecked"}) public <T> Supplier<Collection<T>> createSupplier(Collection<T> collection, String name, JavaGenericType dataType, Document value, ClassLoader classLoader) { List<JavaTypeInfo> typeInfos = dataType.getTypeInfo().getParameterTypesInfos(); if (typeInfos.size() < 1) { // programming error throw new Fabric3Exception("Collection properties must have a value type"); } Class<?> type = typeInfos.get(0).getRawType(); List<Class<?>> types = new ArrayList<>(); types.add(type); Transformer<Node, ?> transformer = getTransformer(name, PROPERTY_TYPE, new JavaType(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 () -> collection; }
@SuppressWarnings({"unchecked"}) private DataType createDataType(Class<?> physicalType, Type type, TypeMapping mapping) { JavaType dataType; if (type instanceof Class) { // not a generic dataType = new JavaType(physicalType); } else { JavaTypeInfo info = helper.createTypeInfo(type, mapping); dataType = new JavaGenericType(info); } for (TypeIntrospector introspector : typeIntrospectors) { introspector.introspect(dataType); } return dataType; }
private <T> LogicalConsumer createConsumer(Class<T> type, URI channelUri) { JavaServiceContract contract = introspector.introspect(type); LogicalCompositeComponent domain = lcm.getDomainComposite(); String root = domain.getUri().toString(); LogicalComponent<NonManagedImplementation> logicalComponent = createComponent(Object.class, domain, root); DataType dataType = new JavaType(type); Consumer consumer = new Consumer("consumer", dataType, true); int pos = counter.getAndIncrement(); LogicalConsumer logicalConsumer = new LogicalConsumer(URI.create(root + "/F3Synthetic#consumer" + pos), consumer, logicalComponent); logicalConsumer.setServiceContract(contract); logicalConsumer.addSource(channelUri); return logicalConsumer; }
private <T> LogicalConsumer createConsumer(Class<T> type, URI channelUri) { JavaServiceContract contract = introspector.introspect(type); LogicalCompositeComponent domain = lcm.getDomainComposite(); String root = domain.getUri().toString(); LogicalComponent<NonManagedImplementation> logicalComponent = createComponent(Object.class, domain, root); DataType dataType = new JavaType(type); Consumer consumer = new Consumer("consumer", dataType, true); int pos = counter.getAndIncrement(); LogicalConsumer logicalConsumer = new LogicalConsumer(URI.create(root + "/F3Synthetic#consumer" + pos), consumer, logicalComponent); logicalConsumer.setServiceContract(contract); logicalConsumer.addSource(channelUri); return logicalConsumer; }
/** * Returns a key for a map-style reference or null if there is no key associated with the reference. * * @param source the source metadata * @param target the target metadata * @return the key * @throws Fabric3Exception if there is an error instantiating the key */ @SuppressWarnings("unchecked") protected Object getKey(PojoWireSource source, PhysicalWireTarget target) throws Fabric3Exception { if (!source.isKeyed()) { return null; } String key = source.getKey(); // The target classloader must be used since the key class may not be visible to the source classloader, for example, when subclasses are used as keys ClassLoader targetClassLoader = target.getClassLoader(); Class<?> keyType = ClassLoading.loadClass(targetClassLoader, source.getKeyClassName()); if (String.class.equals(keyType)) { // short-circuit the transformation and return the string return key; } else if (Enum.class.isAssignableFrom(keyType)) { // enum, instantiate it directly Class<Enum> enumClass = (Class<Enum>) keyType; return Enum.valueOf(enumClass, key); } JavaType targetType = new JavaType(keyType); return createKey(targetType, key, targetClassLoader); }
/** * Returns a key for a map-style reference or null if there is no key associated with the reference. * * @param source the source metadata * @param target the target metadata * @return the key * @throws Fabric3Exception if there is an error instantiating the key */ @SuppressWarnings("unchecked") protected Object getKey(PojoWireSource source, PhysicalWireTarget target) throws Fabric3Exception { if (!source.isKeyed()) { return null; } String key = source.getKey(); // The target classloader must be used since the key class may not be visible to the source classloader, for example, when subclasses are used as keys ClassLoader targetClassLoader = target.getClassLoader(); Class<?> keyType = ClassLoading.loadClass(targetClassLoader, source.getKeyClassName()); if (String.class.equals(keyType)) { // short-circuit the transformation and return the string return key; } else if (Enum.class.isAssignableFrom(keyType)) { // enum, instantiate it directly Class<Enum> enumClass = (Class<Enum>) keyType; return Enum.valueOf(enumClass, key); } JavaType targetType = new JavaType(keyType); return createKey(targetType, key, targetClassLoader); }
return false; JavaType dataType = new JavaType(consumerType); String target = reader.getAttributeValue(null, "target"); if (target == null) {
return false; JavaType dataType = new JavaType(consumerType); String target = reader.getAttributeValue(null, "target"); if (target == null) {