org.jboss.weld.annotated.slim.SlimAnnotatedTypeContext.getResolvedProcessAnnotatedTypeObservers java code examples

Common ways to obtain SlimAnnotatedTypeContext

private void myMethod () {
 SlimAnnotatedTypeContext s =SlimAnnotatedType type;SlimAnnotatedTypeContext.of(type)
AnnotatedTypeLoader annotatedTypeLoader;String className;String bdaId;annotatedTypeLoader.loadAnnotatedType(className, bdaId)
SlimAnnotatedType type;new SlimAnnotatedTypeContext<T>(type, null, null, null)
Smart code suggestions by Codota
}

public <T> ProcessAnnotatedTypeImpl<T> fireProcessAnnotatedType(BeanManagerImpl beanManager, SlimAnnotatedTypeContext<T> annotatedTypeContext) {
  if (!isProcessAnnotatedTypeObserved()) {
    return null;
  }
  final Set<ContainerLifecycleEventObserverMethod<?>> observers = annotatedTypeContext.getResolvedProcessAnnotatedTypeObservers();
  final SlimAnnotatedType<T> annotatedType = annotatedTypeContext.getAnnotatedType();
  // if the fast resolver resolved an empty set of observer methods, skip this event
  if (observers != null && observers.isEmpty()) {
    BootstrapLogger.LOG.patSkipped(annotatedType);
    return null;
  }
  ProcessAnnotatedTypeImpl<T> event = null;
  if (annotatedTypeContext.getExtension() == null) {
    event = new ProcessAnnotatedTypeImpl<T>(beanManager, annotatedType);
  } else {
    event = new ProcessSyntheticAnnotatedTypeImpl<T>(beanManager, annotatedTypeContext);
  }
  if (observers == null) {
    BootstrapLogger.LOG.patDefaultResolver(annotatedType);
    fireProcessAnnotatedType(event, beanManager);
  } else {
    BootstrapLogger.LOG.patFastResolver(annotatedType);
    fireProcessAnnotatedType(event, annotatedTypeContext.getResolvedProcessAnnotatedTypeObservers(), beanManager);
  }
  return event;
}

public <T> ProcessAnnotatedTypeImpl<T> fireProcessAnnotatedType(BeanManagerImpl beanManager, SlimAnnotatedTypeContext<T> annotatedTypeContext) {
  if (!isProcessAnnotatedTypeObserved()) {
    return null;
  }
  final Set<ContainerLifecycleEventObserverMethod<?>> observers = annotatedTypeContext.getResolvedProcessAnnotatedTypeObservers();
  final SlimAnnotatedType<T> annotatedType = annotatedTypeContext.getAnnotatedType();
  // if the fast resolver resolved an empty set of observer methods, skip this event
  if (observers != null && observers.isEmpty()) {
    BootstrapLogger.LOG.patSkipped(annotatedType);
    return null;
  }
  ProcessAnnotatedTypeImpl<T> event = null;
  if (annotatedTypeContext.getExtension() == null) {
    event = new ProcessAnnotatedTypeImpl<T>(beanManager, annotatedType);
  } else {
    event = new ProcessSyntheticAnnotatedTypeImpl<T>(beanManager, annotatedTypeContext);
  }
  if (observers == null) {
    BootstrapLogger.LOG.patDefaultResolver(annotatedType);
    fireProcessAnnotatedType(event, beanManager);
  } else {
    BootstrapLogger.LOG.patFastResolver(annotatedType);
    fireProcessAnnotatedType(event, annotatedTypeContext.getResolvedProcessAnnotatedTypeObservers(), beanManager);
  }
  return event;
}

public <T> ProcessAnnotatedTypeImpl<T> fireProcessAnnotatedType(BeanManagerImpl beanManager, SlimAnnotatedTypeContext<T> annotatedTypeContext) {
  if (!isProcessAnnotatedTypeObserved()) {
    return null;
  }
  final Set<ContainerLifecycleEventObserverMethod<?>> observers = annotatedTypeContext.getResolvedProcessAnnotatedTypeObservers();
  final SlimAnnotatedType<T> annotatedType = annotatedTypeContext.getAnnotatedType();
  // if the fast resolver resolved an empty set of observer methods, skip this event
  if (observers != null && observers.isEmpty()) {
    BootstrapLogger.LOG.patSkipped(annotatedType);
    return null;
  }
  ProcessAnnotatedTypeImpl<T> event = null;
  if (annotatedTypeContext.getExtension() == null) {
    event = new ProcessAnnotatedTypeImpl<T>(beanManager, annotatedType);
  } else {
    event = new ProcessSyntheticAnnotatedTypeImpl<T>(beanManager, annotatedTypeContext);
  }
  if (observers == null) {
    BootstrapLogger.LOG.patDefaultResolver(annotatedType);
    fireProcessAnnotatedType(event, beanManager);
  } else {
    BootstrapLogger.LOG.patFastResolver(annotatedType);
    fireProcessAnnotatedType(event, annotatedTypeContext.getResolvedProcessAnnotatedTypeObservers(), beanManager);
  }
  return event;
}

public <T> ProcessAnnotatedTypeImpl<T> fireProcessAnnotatedType(BeanManagerImpl beanManager, SlimAnnotatedTypeContext<T> annotatedTypeContext) {
  if (!isProcessAnnotatedTypeObserved()) {
    return null;
  }
  final Set<ExtensionObserverMethodImpl<?, ?>> observers = annotatedTypeContext.getResolvedProcessAnnotatedTypeObservers();
  final SlimAnnotatedType<T> annotatedType = annotatedTypeContext.getAnnotatedType();
  // if the fast resolver resolved an empty set of observer methods, skip this event
  if (observers != null && observers.isEmpty()) {
    BootstrapLogger.LOG.patSkipped(annotatedType);
    return null;
  }
  ProcessAnnotatedTypeImpl<T> event = null;
  if (annotatedTypeContext.getExtension() == null) {
    event = new ProcessAnnotatedTypeImpl<T>(beanManager, annotatedType);
  } else {
    event = new ProcessSyntheticAnnotatedTypeImpl<T>(beanManager, annotatedTypeContext);
  }
  if (observers == null) {
    BootstrapLogger.LOG.patDefaultResolver(annotatedType);
    fireProcessAnnotatedType(event, beanManager);
  } else {
    BootstrapLogger.LOG.patFastResolver(annotatedType);
    fireProcessAnnotatedType(event, annotatedTypeContext.getResolvedProcessAnnotatedTypeObservers());
  }
  return event;
}

public <T> ProcessAnnotatedTypeImpl<T> fireProcessAnnotatedType(BeanManagerImpl beanManager, SlimAnnotatedTypeContext<T> annotatedTypeContext) {
  if (!isProcessAnnotatedTypeObserved()) {
    return null;
  }
  final Set<ContainerLifecycleEventObserverMethod<?>> observers = annotatedTypeContext.getResolvedProcessAnnotatedTypeObservers();
  final SlimAnnotatedType<T> annotatedType = annotatedTypeContext.getAnnotatedType();
  // if the fast resolver resolved an empty set of observer methods, skip this event
  if (observers != null && observers.isEmpty()) {
    BootstrapLogger.LOG.patSkipped(annotatedType);
    return null;
  }
  ProcessAnnotatedTypeImpl<T> event = null;
  if (annotatedTypeContext.getExtension() == null) {
    event = new ProcessAnnotatedTypeImpl<T>(beanManager, annotatedType);
  } else {
    event = new ProcessSyntheticAnnotatedTypeImpl<T>(beanManager, annotatedTypeContext);
  }
  if (observers == null) {
    BootstrapLogger.LOG.patDefaultResolver(annotatedType);
    fireProcessAnnotatedType(event, beanManager);
  } else {
    BootstrapLogger.LOG.patFastResolver(annotatedType);
    fireProcessAnnotatedType(event, annotatedTypeContext.getResolvedProcessAnnotatedTypeObservers(), beanManager);
  }
  return event;
}

public <T> ProcessAnnotatedTypeImpl<T> fireProcessAnnotatedType(BeanManagerImpl beanManager, SlimAnnotatedTypeContext<T> annotatedTypeContext) {
  if (!isProcessAnnotatedTypeObserved()) {
    return null;
  }
  final Set<ContainerLifecycleEventObserverMethod<?>> observers = annotatedTypeContext.getResolvedProcessAnnotatedTypeObservers();
  final SlimAnnotatedType<T> annotatedType = annotatedTypeContext.getAnnotatedType();
  // if the fast resolver resolved an empty set of observer methods, skip this event
  if (observers != null && observers.isEmpty()) {
    BootstrapLogger.LOG.patSkipped(annotatedType);
    return null;
  }
  ProcessAnnotatedTypeImpl<T> event = null;
  if (annotatedTypeContext.getExtension() == null) {
    event = new ProcessAnnotatedTypeImpl<T>(beanManager, annotatedType);
  } else {
    event = new ProcessSyntheticAnnotatedTypeImpl<T>(beanManager, annotatedTypeContext);
  }
  if (observers == null) {
    BootstrapLogger.LOG.patDefaultResolver(annotatedType);
    fireProcessAnnotatedType(event, beanManager);
  } else {
    BootstrapLogger.LOG.patFastResolver(annotatedType);
    fireProcessAnnotatedType(event, annotatedTypeContext.getResolvedProcessAnnotatedTypeObservers(), beanManager);
  }
  return event;
}

Popular methods of SlimAnnotatedTypeContext

Popular in Java

Running tasks concurrently on multiple threads
putExtra (Intent)
findViewById (Activity)
getSupportFragmentManager (FragmentActivity)
Return the FragmentManager for interacting with fragments associated with this activity.
VirtualMachine (com.sun.tools.attach)
A Java virtual machine. A VirtualMachine represents a Java virtual machine to which this Java vir
Runnable (java.lang)
Represents a command that can be executed. Often used to run code in a different Thread.
ConcurrentHashMap (java.util.concurrent)
A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updat
Semaphore (java.util.concurrent)
A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each #acquire blocks if
Response (javax.ws.rs.core)
Defines the contract between a returned instance and the runtime when an application needs to provid
Location (org.springframework.beans.factory.parsing)
Class that models an arbitrary location in a Resource.Typically used to track the location of proble

How to use getResolvedProcessAnnotatedTypeObserversmethodin org.jboss.weld.annotated.slim.SlimAnnotatedTypeContext

Best Java code snippets using org.jboss.weld.annotated.slim.SlimAnnotatedTypeContext.getResolvedProcessAnnotatedTypeObservers (Showing top 6 results out of 315)

How to use
getResolvedProcessAnnotatedTypeObservers
method
in
org.jboss.weld.annotated.slim.SlimAnnotatedTypeContext