How to use

DependencyGraphBuilder$ParamDependency

in

org.jboss.errai.ioc.rebind.ioc.graph.api

if (paramDep.getParameter().isAnnotationPresent(AutoBound.class)) {
 return DecorableType.PARAM.getAccessStatement(paramDep.getParameter(), decorable.getFactoryMetaClass());
} else {
 break;

private Statement[] generateProducerParams(final MetaMethod producingMember, final Collection<Dependency> paramDeps,
    final List<Statement> varDeclarationStmts, final List<Statement> depScopeRegistrationStmts) {
 // TODO validate params
 final Statement[] params = new Statement[producingMember.getParameters().length];
 for (final Dependency dep : paramDeps) {
  final ParamDependency paramDep = (ParamDependency) dep;
  final ContextualStatementBuilder producerParamCreationStmt = generateProducerParamCreationStmt(paramDep);
  final String paramVarName = getLocalVariableName(paramDep.getParameter());
  varDeclarationStmts.add(declareFinalVariable(paramVarName, paramDep.getParameter().getType(), producerParamCreationStmt));
  if (paramDep.getInjectable().getWiringElementTypes().contains(WiringElementType.DependentBean)) {
   depScopeRegistrationStmts.add(loadVariable("this").invoke("registerDependentScopedReference",
      loadVariable("instance"), loadVariable(paramVarName)));
  }
  params[paramDep.getParamIndex()] = loadVariable(paramVarName);
 }
 return params;
}

if (paramDep.getParameter().isAnnotationPresent(AutoBound.class)) {
 return DecorableType.PARAM.getAccessStatement(paramDep.getParameter(), decorable.getFactoryMetaClass());
} else {
 break;

private Statement[] getDisposerParams(final MetaMethod disposer, final Collection<Dependency> disposerParams, final BuildMetaClass factory) {
 final Statement[] params = new Statement[disposer.getParameters().length];
 for (final Dependency dep : disposerParams) {
  final ParamDependency paramDep = (ParamDependency) dep;
  final ContextualStatementBuilder paramInstance = castTo(paramDep.getInjectable().getInjectedType(),
      loadVariable("contextManager").invoke("getInstance", paramDep.getInjectable().getFactoryName()));
  final ContextualStatementBuilder paramExpression;
  if (paramDep.getInjectable().getWiringElementTypes().contains(WiringElementType.DependentBean)) {
   paramExpression = loadVariable("this").invoke("registerDependentScopedReference", loadVariable("instance"), paramInstance);
  } else {
   paramExpression = paramInstance;
  }
  params[paramDep.getParamIndex()] = paramExpression;
 }
 final MetaParameter disposesParam = disposer.getParametersAnnotatedWith(Disposes.class).get(0);
 params[disposesParam.getIndex()] = loadVariable("instance");
 return params;
}

 private ContextualStatementBuilder getInjectedValue(final Injectable depInjectable, final ParamDependency paramDep) {
  final ContextualStatementBuilder injectedValue;

  if (depInjectable.isContextual()) {
   final MetaClass[] typeArgsClasses = getTypeArguments(paramDep.getParameter().getType());
   final Annotation[] qualifiers = getQualifiers(paramDep.getParameter()).toArray(new Annotation[0]);

   injectedValue = castTo(depInjectable.getInjectedType(),
       loadVariable("contextManager").invoke("getContextualInstance",
           loadLiteral(depInjectable.getFactoryName()), typeArgsClasses, qualifiers));
  } else {
   injectedValue = castTo(depInjectable.getInjectedType(),
       loadVariable("contextManager").invoke("getInstance", loadLiteral(depInjectable.getFactoryName())));
  }

  return injectedValue;
 }
}

private MetaConstructor getAccessibleConstructor(final Injectable injectable) {
 final MetaClass type = injectable.getInjectedType();
 final MetaConstructor noArgConstr = getAccessibleNoArgConstructor(type);
 if (noArgConstr != null) {
  return noArgConstr;
 }
 for (final Dependency dep : injectable.getDependencies()) {
  if (dep.getDependencyType().equals(DependencyType.Constructor)) {
   final MetaConstructor injectableConstr = (MetaConstructor) ((ParamDependency) dep).getParameter().getDeclaringMember();
   return (injectableConstr.isPublic() || injectableConstr.isProtected()) ? injectableConstr : null;
  }
 }
 return null;
}

private ContextualStatementBuilder generateProducerParamCreationStmt(final ParamDependency paramDep) {
 ContextualStatementBuilder producerParamCreationStmt;
 if (paramDep.getInjectable().isContextual()) {
  final MetaParameter param = paramDep.getParameter();
  final MetaClass[] typeArgs = getTypeArguments(param.getType());
  final Annotation[] annotations = param.getAnnotations();
  producerParamCreationStmt = castTo(paramDep.getInjectable().getInjectedType(),
      loadVariable("contextManager").invoke("getContextualInstance", paramDep.getInjectable().getFactoryName(), typeArgs, annotations));
 }
 else {
  producerParamCreationStmt = castTo(paramDep.getInjectable().getInjectedType(),
      loadVariable("contextManager").invoke("getInstance", paramDep.getInjectable().getFactoryName()));
 }
 return producerParamCreationStmt;
}

private void processConstructorDependencyStatement(final List<Statement> createInstanceStatements, final Object[] constructorParameterStatements,
    final List<Statement> dependentScopedRegistrationStatements, final Dependency dep) {
 final Injectable depInjectable = dep.getInjectable();
 final ParamDependency paramDep = ParamDependency.class.cast(dep);
 final ContextualStatementBuilder injectedValue = getInjectedValue(depInjectable, paramDep);
 final String paramLocalVarName = getLocalVariableName(paramDep.getParameter());
 createInstanceStatements.add(declareFinalVariable(paramLocalVarName, paramDep.getParameter().getType(), injectedValue));
 if (dep.getInjectable().getWiringElementTypes().contains(WiringElementType.DependentBean)) {
  dependentScopedRegistrationStatements.add(loadVariable("this").invoke("registerDependentScopedReference",
      loadVariable("instance"), loadVariable(paramLocalVarName)));
 }
 constructorParameterStatements[paramDep.getParamIndex()] = loadVariable(paramLocalVarName);
}