How to use org.jboss.errai.ioc.rebind.ioc.graph.api

 @Override
 public boolean matches(final Injectable injectable) {
  return InjectableType.Disabled.equals(injectable.getInjectableType());
 }
};

private static boolean qualifiersMatch(final InjectableReference injectableReference, final HasInjectableHandle candidate) {
 return injectableReference.qualifier.isSatisfiedBy(candidate.getQualifier());
}

@Override
public boolean canValidate(final Injectable injectable) {
 return !injectable.loadAsync();
}

private void addProviderInjectable(final Injectable providerImplInjectable, final DependencyGraphBuilder builder,
    final boolean enabled) {
 final MetaClass providerImpl = providerImplInjectable.getInjectedType();
 final MetaMethod providerMethod = providerImpl.getMethod("get", new Class[0]);
 final MetaClass providedType = getMethodReturnType(providerMethod);
 final InjectableType injectableType = (enabled ? InjectableType.Provider : InjectableType.Disabled);
 final Injectable providedInjectable = builder.addInjectable(providedType, qualFactory.forSource(providerMethod),
     EXACT_TYPE, Dependent.class, injectableType, WiringElementType.Provider, WiringElementType.DependentBean);
 builder.addProducerMemberDependency(providedInjectable, providerImplInjectable.getInjectedType(), providerImplInjectable.getQualifier(), providerMethod);
}

private static void traceConstituentHashContents(final Injectable injectable, final String name) {
 log.trace("Begin trace of hashContent for {}", name);
 log.trace("Combined content: {}", injectable.hashContent());
 log.trace("HashContent for injectable type: {}", injectable.getInjectedType().hashContent());
 for (final Dependency dep : injectable.getDependencies()) {
  log.trace("HashContent for {} dep of type {}: {}", dep.getDependencyType().toString(),
      dep.getInjectable().getInjectedType(), dep.getInjectable().getInjectedType().hashContent());
 }
 log.trace("End trace of hashContent for {}", name);
}

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;
}

protected Injectable getProviderInjectable(final Injectable depInjectable) {
 for (final Dependency dep : depInjectable.getDependencies()) {
  if (dep.getDependencyType().equals(DependencyType.ProducerMember)) {
   final MetaClass providerType = dep.getInjectable().getInjectedType();
   if (providerType.isAssignableTo(getProviderRawType())) {
    return dep.getInjectable();
   }
   else {
    throw new RuntimeException("Unrecognized contextual provider type " + providerType.getFullyQualifiedName());
   }
  }
 }
 throw new RuntimeException();
}

private void addContextualProviderInjectable(final Injectable providerInjectable,
    final DependencyGraphBuilder builder, final boolean enabled) {
 final MetaClass providerImpl = providerInjectable.getInjectedType();
 final MetaMethod providerMethod = providerImpl.getMethod("provide", Class[].class, Annotation[].class);
 // Do not get generic return type for contextual providers
 final MetaClass providedType = providerMethod.getReturnType();
 final InjectableType injectableType = (enabled ? InjectableType.ContextualProvider : InjectableType.Disabled);
 final Injectable providedInjectable = builder.addInjectable(providedType,
     qualFactory.forUniversallyQualified(), EXACT_TYPE, Dependent.class, injectableType,
     WiringElementType.Provider, WiringElementType.DependentBean);
 builder.addProducerMemberDependency(providedInjectable, providerImpl, providerInjectable.getQualifier(), providerMethod);
}

private void addDependency(final Injectable injectable, final Dependency dependency) {
 assert (injectable instanceof InjectableImpl);
 if (InjectableType.Disabled.equals(injectable.getInjectableType())
     && (!DependencyType.ProducerMember.equals(dependency.getDependencyType())
         || !injectable.getDependencies().isEmpty())) {
  throw new RuntimeException("The injectable, " + injectable + ", is disabled."
      + " A disabled injectable may only have a single dependency if it is produced by a disabled bean.");
 }
 final InjectableImpl injectableAsImpl = (InjectableImpl) injectable;
 injectableAsImpl.dependencies.add(BaseDependency.class.cast(dependency));
}

private Injectable getRootDisabledInjectable(Injectable inj, final Collection<String> problems,
    final Map<String, Injectable> customProvidedInjectables) {
 while (inj.getDependencies().size() == 1) {
  final Dependency dep = inj.getDependencies().iterator().next();
  if (DependencyType.ProducerMember.equals(dep.getDependencyType())) {
   inj = resolveDependency((BaseDependency) dep, inj, problems, customProvidedInjectables);
  }
 }
 return inj;
}

private MetaClass addFactoryDeclaration(final Injectable injectable, final IOCProcessingContext processingContext) {
 final String factoryName = injectable.getFactoryName();
 final MetaClass typeCreatedByFactory = injectable.getInjectedType();
 return addFactoryDeclaration(factoryName, typeCreatedByFactory, processingContext);
}

 @Override
 public void validate(final Injectable injectable, final Collection<String> problems) {
  for (final Dependency dep : injectable.getDependencies()) {
   if (dep.getInjectable().loadAsync()) {
    problems.add("The bean " + injectable + " is not @LoadAsync but depends on the @LoadAsync bean " + dep.getInjectable());
   }
  }
 }
}

 @Override
 public boolean matches(final Injectable injectable) {
  return injectable.getInjectableType().equals(InjectableType.JsType)
      && injectable.getWiringElementTypes().contains(WiringElementType.SharedSingleton);
 }
},

private void addDisposerDependencies(final Injectable producedInjectable, final MetaMethod disposer, final DependencyGraphBuilder builder) {
 for (final MetaParameter param : disposer.getParameters()) {
  if (param.isAnnotationPresent(Disposes.class)) {
   builder.addDisposesMethodDependency(producedInjectable, disposer.getDeclaringClass(), qualFactory.forSink(disposer.getDeclaringClass()), disposer);
  } else {
   builder.addDisposesParamDependency(producedInjectable, param.getType(), qualFactory.forSink(param), param.getIndex(), param);
  }
 }
}

private void addConstructorInjectionPoints(final Injectable concreteInjectable, final MetaConstructor injectableConstructor, final DependencyGraphBuilder builder) {
 final MetaParameter[] params = injectableConstructor.getParameters();
 for (int i = 0; i < params.length; i++) {
  final MetaParameter param = params[i];
  builder.addConstructorDependency(concreteInjectable, param.getType(), qualFactory.forSink(param), i, param);
 }
}

@Override
public boolean isContextual() {
 return InjectableType.ContextualProvider.equals(injectableType);
}

public String getBeanName() {
 return qualifier.getName();
}

private void processProducerField(final Injectable producerInjectable, final MetaClass producerType,
    final DependencyGraphBuilder builder, final Collection<MetaMethod> disposesMethods, final MetaField field,
    final boolean enabled, final List<String> problems) {
 final Class<? extends Annotation> scopeAnno = getScope(field);
 final InjectableType injectableType = (enabled ? InjectableType.Producer : InjectableType.Disabled);
 final Injectable producedInjectable = builder.addInjectable(field.getType(), qualFactory.forSource(field), getPathPredicate(field, problems),
     scopeAnno, injectableType, getWiringTypeForProducer(producerType, field, scopeAnno));
 if (field.isStatic()) {
  builder.addProducerMemberDependency(producedInjectable, producerType, field);
 }
 else {
  builder.addProducerMemberDependency(producedInjectable, producerInjectable.getInjectedType(), producerInjectable.getQualifier(), field);
 }
 if (enabled) {
  processDisposerDependencies(builder, disposesMethods, field, producedInjectable);
 }
}

 @Override
 public boolean matches(final Injectable injectable) {
  return injectable.getWiringElementTypes().contains(WiringElementType.AlternativeBean)
      && !InjectableType.Disabled.equals(injectable.getInjectableType());
 }
},

 @Override
 public boolean matches(final Injectable injectable) {
  return InjectableType.JsType.equals(injectable.getInjectableType());
 }
},