congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
org.jboss.errai.ioc.rebind.ioc.graph.api
Code IndexAdd Tabnine to your IDE (free)

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

Best Java code snippets using org.jboss.errai.ioc.rebind.ioc.graph.api (Showing top 20 results out of 315)

origin: errai/errai

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

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

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

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);
}
origin: errai/errai

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);
}
origin: errai/errai

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;
}
origin: errai/errai

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();
}
origin: errai/errai

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);
}
origin: errai/errai

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));
}
origin: errai/errai

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;
}
origin: errai/errai

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

 @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());
   }
  }
 }
}
origin: errai/errai

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

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);
  }
 }
}
origin: errai/errai

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);
 }
}
origin: errai/errai

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

public String getBeanName() {
 return qualifier.getName();
}
origin: errai/errai

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);
 }
}
origin: errai/errai

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

 @Override
 public boolean matches(final Injectable injectable) {
  return InjectableType.JsType.equals(injectable.getInjectableType());
 }
},
org.jboss.errai.ioc.rebind.ioc.graph.api

Most used classes

  • QualifierFactory
  • Injectable
  • InjectionSite
  • DependencyGraph
  • DependencyGraphBuilder$Dependency
  • DependencyGraphBuilder$ParamDependency,
  • CustomFactoryInjectable,
  • DependencyGraphBuilder$DependencyType,
  • DependencyGraphBuilder$DisposerMethodDependency,
  • DependencyGraphBuilder$InjectableType,
  • DependencyGraphBuilder$ProducerInstanceDependency,
  • DependencyGraphBuilder$ReachabilityStrategy,
  • DependencyGraphBuilder$SetterParameterDependency,
  • DependencyGraphBuilder,
  • HasInjectableHandle,
  • Qualifier
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now