import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Uri("")
@Produces
@Typed(MockEndpoint.class)
// Qualifiers are dynamically added in CdiCamelExtension
private static MockEndpoint mockEndpointFromUri(InjectionPoint ip, @Any Instance<CamelContext> instance, CdiCamelExtension extension) {
    Uri uri = getQualifierByType(ip, Uri.class).get();
    try {
        CamelContext context = uri.context().isEmpty()
            ? selectContext(ip, instance, extension)
            : selectContext(uri.context(), instance);
        return context.getEndpoint(uri.value(), MockEndpoint.class);
    } catch (Exception cause) {
        throw new InjectionException("Error injecting mock endpoint annotated with " + uri
            + " into " + ip, cause);
    }
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Produces
@Dependent
@Property
public Boolean produceBooleanProperty(InjectionPoint injectionPoint) {
    try {
        final String value = getProperty(injectionPoint);

        if (value != null) {
            return Boolean.valueOf(value);
        }

        final Type type = injectionPoint.getType();
        return type.equals(boolean.class) ? Boolean.FALSE : null;
    } catch (Exception e) {
        throw new InjectionException(e);
    }
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Produces
@Dependent
@Property
public Integer produceIntegerProperty(InjectionPoint injectionPoint) {
    try {
        final String value = getProperty(injectionPoint);

        if (value != null) {
            return Integer.valueOf(value);
        }

        final Type type = injectionPoint.getType();
        return type.equals(int.class) ? Integer.valueOf(0) : null;
    } catch (Exception e) {
        throw new InjectionException(e);
    }
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Produces
@Dependent
@Property
public Long produceLongProperty(InjectionPoint injectionPoint) {
    try {
        final String value = getProperty(injectionPoint);

        if (value != null) {
            return Long.valueOf(value);
        }

        final Type type = injectionPoint.getType();
        return type.equals(long.class) ? Long.valueOf(0L) : null;
    } catch (Exception e) {
        throw new InjectionException(e);
    }
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Produces
@Dependent
@Property
public Float produceFloatProperty(InjectionPoint injectionPoint) {
    try {
        final String value = getProperty(injectionPoint);

        if (value != null) {
            return Float.valueOf(value);
        }

        final Type type = injectionPoint.getType();
        return type.equals(float.class) ? Float.valueOf(0f) : null;
    } catch (Exception e) {
        throw new InjectionException(e);
    }
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Produces
@Dependent
@Property
public Double produceDoubleProperty(InjectionPoint injectionPoint) {
    try {
        final String value = getProperty(injectionPoint);

        if (value != null) {
            return Double.valueOf(value);
        }

        final Type type = injectionPoint.getType();
        return type.equals(double.class) ? Double.valueOf(0d) : null;
    } catch (Exception e) {
        throw new InjectionException(e);
    }
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Produces
@Dependent
@Property
public BigInteger produceBigIntegerProperty(InjectionPoint injectionPoint) {
    try {
        final BigDecimal value = produceBigDecimalProperty(injectionPoint);

        if (value != null) {
            return value.toBigInteger();
        }
    } catch (Exception e) {
        throw new InjectionException(e);
    }

    return null;
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Produces
@Dependent
@Property
public Date produceDateProperty(InjectionPoint injectionPoint) {
    try {
        final String value = getProperty(injectionPoint);
        final Date date;

        if (value != null) {
            final Property annotation = injectionPoint.getAnnotated().getAnnotation(Property.class);
            final String pattern = annotation.pattern();
            DateFormat format = new SimpleDateFormat(pattern.isEmpty() ? "yyyy-MM-dd'T'HH:mm:ss.SSSZ" : pattern);
            date = format.parse(value);
        } else {
            date = null;
        }
        return date;
    } catch (Exception e) {
        throw new InjectionException(e);
    }
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Override
public T produce(CreationalContext<T> ctx) {
    T context = super.produce(ctx);

    // Register the context in the OSGi registry
    BundleContext bundle = BundleContextUtils.getBundleContext(getClass());
    context.getManagementStrategy().addEventNotifier(new OsgiCamelContextPublisher(bundle));

    if (!(context instanceof DefaultCamelContext)) {
        // Fail fast for the time being to avoid side effects by some methods get declared on the CamelContext interface
        throw new InjectionException("Camel CDI requires Camel context [" + context.getName() + "] to be a subtype of DefaultCamelContext");
    }

    DefaultCamelContext adapted = context.adapt(DefaultCamelContext.class);
    adapted.setRegistry(OsgiCamelContextHelper.wrapRegistry(context, context.getRegistry(), bundle));
    CamelContextNameStrategy strategy = context.getNameStrategy();
    OsgiCamelContextHelper.osgiUpdate(adapted, bundle);
    // FIXME: the above call should not override explicit strategies provided by the end user or should decorate them instead of overriding them completely
    if (!(strategy instanceof DefaultCamelContextNameStrategy)) {
        context.setNameStrategy(strategy);
    }

    return context;
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
private boolean addRouteToContext(Bean<?> routeBean, Bean<?> contextBean, BeanManager manager, AfterDeploymentValidation adv) {
    try {
        CamelContext context = getReference(manager, CamelContext.class, contextBean);
        try {
            Object route = getReference(manager, Object.class, routeBean);
            if (route instanceof RoutesBuilder) {
                context.addRoutes((RoutesBuilder) route);
            } else if (route instanceof RouteContainer) {
                context.addRouteDefinitions(((RouteContainer) route).getRoutes());
            } else {
                throw new IllegalArgumentException(
                    "Invalid routes type [" + routeBean.getBeanClass().getName() + "], "
                        + "must be either of type RoutesBuilder or RouteContainer!");
            }
            return true;
        } catch (Exception cause) {
            adv.addDeploymentProblem(
                new InjectionException(
                    "Error adding routes of type [" + routeBean.getBeanClass().getName() + "] "
                        + "to Camel context [" + context.getName() + "]", cause));
        }
    } catch (Exception exception) {
        adv.addDeploymentProblem(exception);
    }
    return false;
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
private void setFieldValueOrAddDefinitionError(T instance, Field field, Object value, ValueConverter acceptingConverter) {
	if (acceptingConverter == null) {
		pit.addDefinitionError(new InjectionException(String.format(MESSAGE_NO_CONVERTER_FOUND, field.getName(), field.getType(), pit.getAnnotatedType().getJavaClass().getName())));
	} else if (value == null) {
		pit.addDefinitionError(new InjectionException(String.format(MESSAGE_NO_VALUE_FOUND, field.getName(), field.getType(), pit.getAnnotatedType().getJavaClass().getName())));
	} else {
		try {
			Object convert = acceptingConverter.convert(value);
			boolean accessible = field.isAccessible();
			field.setAccessible(true);
			field.set(instance, convert);
			field.setAccessible(accessible);
		} catch (IllegalAccessException e) {
			pit.addDefinitionError(e);
		}
	}
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Override
public void inject(X instance, CreationalContext<X> ctx) {
    wrapped.inject(instance, ctx);

    final Class<? extends Creature> klass = instance.getClass();
    for (Field field : klass.getDeclaredFields()) {
        field.setAccessible(true);
        final String fieldValueFromXml = xmlBacking.getAttribute(field.getName());
        try {
            if (field.getType().isAssignableFrom(Integer.TYPE)) {
                field.set(instance, Integer.parseInt(fieldValueFromXml));
            } else if (field.getType().isAssignableFrom(String.class)) {
                field.set(instance, fieldValueFromXml);
            } else {
                // TODO: left up for the reader
                throw new InjectionException("Cannot convert to type " + field.getType());
            }
        } catch (IllegalAccessException e) {
            throw new InjectionException("Cannot access field " + field);
        }
    }
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
private Neo4jUplink resolve(String connection) {
    if (uplinks.isUnsatisfied()) {
        throw new InjectionException(
                "no neo4j uplinks found. please provide implementation for connection: "
                + connection);
    } else if (uplinks.isAmbiguous()) {
        if ("".equals(connection) || "default"
                .equals(connection)) {
            return uplinks.select(new DefaultLiteral()).get();
        } else {
            for (Neo4jUplink uplink : uplinks) {
                System.out.println("found: " + uplink.getClass().getName());
            }
            return uplinks.select(new NamedLiteral(connection)).get();
        }
    } else if ("".equals(connection) || "default".equals(connection)) {
        return uplinks.get();
    } else {
        throw new InjectionException(
                "cannot find a neo4j-uplink for connection: " + connection);
    }
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Produces
@Dependent
@PropertyResource
public Properties produceProperties(InjectionPoint point) {
    final Annotated annotated = point.getAnnotated();

    if (point.getType() != Properties.class) {
        throw new InjectionException(Properties.class + " can not be injected to type " + point.getType());
    }

    final Class<?> beanType = point.getBean().getBeanClass();
    final ClassLoader loader = beanType.getClassLoader();
    final PropertyResource annotation = annotated.getAnnotation(PropertyResource.class);
    final PropertyResourceFormat format = annotation.format();

    String locator = annotation.url();

    if (locator.isEmpty()) {
        locator = beanType.getName().replace('.', '/') + ".properties";
    }

    try {
        return factory.getProperties(loader, locator, format);
    } catch (Exception e) {
        throw new InjectionException(e);
    }
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Produces
@Dependent
@Property
public String produceProperty(InjectionPoint injectionPoint) {
    try {
        return getProperty(injectionPoint);
    } catch (Exception e) {
        throw new InjectionException(e);
    }
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Produces
@Dependent
@Property
public BigDecimal produceBigDecimalProperty(InjectionPoint injectionPoint) {
    try {
        final String value = getProperty(injectionPoint);
        final BigDecimal number;

        if (value != null) {
            final Property annotation = injectionPoint.getAnnotated().getAnnotation(Property.class);
            final String pattern = annotation.pattern();

            if (pattern.isEmpty()) {
                number = new BigDecimal(value);
            } else {
                if (logger.isLoggable(Level.FINER)) {
                    logger.log(Level.FINER, "Parsing number with using pattern [" + pattern + ']');
                }

                DecimalFormat format = new DecimalFormat(pattern);
                format.setParseBigDecimal(true);
                number = (BigDecimal) format.parse(value);
            }
        } else {
            number = null;
        }
        return number;
    } catch (Exception e) {
        throw new InjectionException(e);
    }
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Produces
@Dependent
@Property
public JsonArray produceJsonArrayProperty(InjectionPoint injectionPoint) {
    try {
        final String value = getProperty(injectionPoint);
        return value != null ? Json.createReader(new StringReader(value)).readArray() : null;
    } catch (Exception e) {
        throw new InjectionException(e);
    }
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Produces
@Dependent
@Property
public JsonObject produceJsonObjectProperty(InjectionPoint injectionPoint) {
    try {
        final String value = getProperty(injectionPoint);
        return value != null ? Json.createReader(new StringReader(value)).readObject() : null;
    } catch (Exception e) {
        throw new InjectionException(e);
    }
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Test(expected = InjectionException.class)
public void testProducePropertyStringInvalid() {
    Property property = this.mockProperty("testProducePropertyStringInvalid",
                                          "io/xlate/inject/Invalid.properties",
                                          PropertyResourceFormat.PROPERTIES,
                                          "",
                                          Property.DEFAULT_NULL);
    InjectionPoint point = this.mockInjectionPoint(property, Member.class, "testProducePropertyStringInvalid", -1);
    bean.produceProperty(point);
}
 

import javax.enterprise.inject.InjectionException; //导入依赖的package包/类
@Test(expected = InjectionException.class)
public void testProducePropertyBooleanInvalid() {
    Property property = this.mockProperty("testProducePropertyBooleanInvalid",
                                          "io/xlate/inject/Invalid.properties",
                                          PropertyResourceFormat.PROPERTIES,
                                          "",
                                          Property.DEFAULT_NULL);
    InjectionPoint point = this.mockInjectionPoint(property, Member.class, "testProducePropertyBooleanInvalid", -1);
    bean.produceBooleanProperty(point);
}