Codota Logo
SlimAnnotatedTypeContext.getExtension
Code IndexAdd Codota to your IDE (free)

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

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

  • Common ways to obtain SlimAnnotatedTypeContext
private void myMethod () {
SlimAnnotatedTypeContext s =
  • Codota IconSlimAnnotatedType type;SlimAnnotatedTypeContext.of(type)
  • Codota IconAnnotatedTypeLoader annotatedTypeLoader;String className;String bdaId;annotatedTypeLoader.loadAnnotatedType(className, bdaId)
  • Codota IconSlimAnnotatedType type;new SlimAnnotatedTypeContext<T>(type, null, null, null)
  • Smart code suggestions by Codota
}
origin: weld/core

public ProcessSyntheticAnnotatedTypeImpl(BeanManagerImpl beanManager, SlimAnnotatedTypeContext<T> annotatedTypeContext) {
  super(beanManager, annotatedTypeContext.getAnnotatedType(), ProcessSyntheticAnnotatedType.class);
  this.source = annotatedTypeContext.getExtension();
}
origin: org.jboss.weld.se/weld-se

public ProcessSyntheticAnnotatedTypeImpl(BeanManagerImpl beanManager, SlimAnnotatedTypeContext<T> annotatedTypeContext) {
  super(beanManager, annotatedTypeContext.getAnnotatedType(), ProcessSyntheticAnnotatedType.class);
  this.source = annotatedTypeContext.getExtension();
}
origin: weld/core

public ProcessSyntheticAnnotatedTypeImpl(BeanManagerImpl beanManager, SlimAnnotatedTypeContext<T> annotatedTypeContext) {
  super(beanManager, annotatedTypeContext.getAnnotatedType(), ProcessSyntheticAnnotatedType.class);
  this.source = annotatedTypeContext.getExtension();
}
origin: weld/core

public ProcessSyntheticAnnotatedTypeImpl(BeanManagerImpl beanManager, SlimAnnotatedTypeContext<T> annotatedTypeContext) {
  super(beanManager, annotatedTypeContext.getAnnotatedType(), ProcessSyntheticAnnotatedType.class);
  this.source = annotatedTypeContext.getExtension();
}
origin: org.jboss.weld.se/weld-se-shaded

public ProcessSyntheticAnnotatedTypeImpl(BeanManagerImpl beanManager, SlimAnnotatedTypeContext<T> annotatedTypeContext) {
  super(beanManager, annotatedTypeContext.getAnnotatedType(), ProcessSyntheticAnnotatedType.class);
  this.source = annotatedTypeContext.getExtension();
}
origin: org.jboss.weld.servlet/weld-servlet-shaded

public ProcessSyntheticAnnotatedTypeImpl(BeanManagerImpl beanManager, SlimAnnotatedTypeContext<T> annotatedTypeContext) {
  super(beanManager, annotatedTypeContext.getAnnotatedType(), ProcessSyntheticAnnotatedType.class);
  this.source = annotatedTypeContext.getExtension();
}
origin: weld/core

public void processAnnotatedTypes() {
  Set<SlimAnnotatedTypeContext<?>> classesToBeAdded = new HashSet<SlimAnnotatedTypeContext<?>>();
  Set<SlimAnnotatedTypeContext<?>> classesToBeRemoved = new HashSet<SlimAnnotatedTypeContext<?>>();
  for (SlimAnnotatedTypeContext<?> annotatedTypeContext : getEnvironment().getAnnotatedTypes()) {
    SlimAnnotatedType<?> annotatedType = annotatedTypeContext.getAnnotatedType();
    final ProcessAnnotatedTypeImpl<?> event = containerLifecycleEvents.fireProcessAnnotatedType(getManager(), annotatedTypeContext);
    // process the result
    if (event != null) {
      if (event.isVeto()) {
        getEnvironment().vetoJavaClass(annotatedType.getJavaClass());
        classesToBeRemoved.add(annotatedTypeContext);
      } else {
        boolean dirty = event.isDirty();
        if (dirty) {
          classesToBeRemoved.add(annotatedTypeContext); // remove the original class
          classesToBeAdded.add(SlimAnnotatedTypeContext.of(event.getResultingAnnotatedType(), annotatedTypeContext.getExtension()));
        }
        processPriority(event.getResultingAnnotatedType());
      }
    } else {
      processPriority(annotatedType);
    }
  }
  getEnvironment().removeAnnotatedTypes(classesToBeRemoved);
  getEnvironment().addAnnotatedTypes(classesToBeAdded);
}
origin: org.jboss.weld.se/weld-se

public void processAnnotatedTypes() {
  Set<SlimAnnotatedTypeContext<?>> classesToBeAdded = new HashSet<SlimAnnotatedTypeContext<?>>();
  Set<SlimAnnotatedTypeContext<?>> classesToBeRemoved = new HashSet<SlimAnnotatedTypeContext<?>>();
  for (SlimAnnotatedTypeContext<?> annotatedTypeContext : getEnvironment().getAnnotatedTypes()) {
    SlimAnnotatedType<?> annotatedType = annotatedTypeContext.getAnnotatedType();
    final ProcessAnnotatedTypeImpl<?> event = containerLifecycleEvents.fireProcessAnnotatedType(getManager(), annotatedTypeContext);
    // process the result
    if (event != null) {
      if (event.isVeto()) {
        getEnvironment().vetoJavaClass(annotatedType.getJavaClass());
        classesToBeRemoved.add(annotatedTypeContext);
      } else {
        boolean dirty = event.isDirty();
        if (dirty) {
          classesToBeRemoved.add(annotatedTypeContext); // remove the original class
          classesToBeAdded.add(SlimAnnotatedTypeContext.of(event.getResultingAnnotatedType(), annotatedTypeContext.getExtension()));
        }
        processPriority(event.getResultingAnnotatedType());
      }
    } else {
      processPriority(annotatedType);
    }
  }
  getEnvironment().removeAnnotatedTypes(classesToBeRemoved);
  getEnvironment().addAnnotatedTypes(classesToBeAdded);
}
origin: weld/core

public void processAnnotatedTypes() {
  Set<SlimAnnotatedTypeContext<?>> classesToBeAdded = new HashSet<SlimAnnotatedTypeContext<?>>();
  Set<SlimAnnotatedTypeContext<?>> classesToBeRemoved = new HashSet<SlimAnnotatedTypeContext<?>>();
  for (SlimAnnotatedTypeContext<?> annotatedTypeContext : getEnvironment().getAnnotatedTypes()) {
    SlimAnnotatedType<?> annotatedType = annotatedTypeContext.getAnnotatedType();
    final ProcessAnnotatedTypeImpl<?> event = containerLifecycleEvents.fireProcessAnnotatedType(getManager(), annotatedTypeContext);
    // process the result
    if (event != null) {
      if (event.isVeto()) {
        getEnvironment().vetoJavaClass(annotatedType.getJavaClass());
        classesToBeRemoved.add(annotatedTypeContext);
      } else {
        boolean dirty = event.isDirty();
        if (dirty) {
          classesToBeRemoved.add(annotatedTypeContext); // remove the original class
          classesToBeAdded.add(SlimAnnotatedTypeContext.of(event.getResultingAnnotatedType(), annotatedTypeContext.getExtension()));
        }
        processPriority(event.getResultingAnnotatedType());
      }
    } else {
      processPriority(annotatedType);
    }
  }
  getEnvironment().removeAnnotatedTypes(classesToBeRemoved);
  getEnvironment().addAnnotatedTypes(classesToBeAdded);
}
origin: weld/core

public void processAnnotatedTypes() {
  Set<SlimAnnotatedTypeContext<?>> classesToBeAdded = new HashSet<SlimAnnotatedTypeContext<?>>();
  Set<SlimAnnotatedTypeContext<?>> classesToBeRemoved = new HashSet<SlimAnnotatedTypeContext<?>>();
  for (SlimAnnotatedTypeContext<?> annotatedTypeContext : getEnvironment().getAnnotatedTypes()) {
    SlimAnnotatedType<?> annotatedType = annotatedTypeContext.getAnnotatedType();
    final ProcessAnnotatedTypeImpl<?> event = containerLifecycleEvents.fireProcessAnnotatedType(getManager(), annotatedTypeContext);
    // process the result
    if (event != null) {
      if (event.isVeto()) {
        getEnvironment().vetoJavaClass(annotatedType.getJavaClass());
        classesToBeRemoved.add(annotatedTypeContext);
      } else {
        boolean dirty = event.isDirty();
        if (dirty) {
          classesToBeRemoved.add(annotatedTypeContext); // remove the original class
          classesToBeAdded.add(SlimAnnotatedTypeContext.of(event.getResultingAnnotatedType(), annotatedTypeContext.getExtension()));
        }
        processPriority(event.getResultingAnnotatedType());
      }
    } else {
      processPriority(annotatedType);
    }
  }
  getEnvironment().removeAnnotatedTypes(classesToBeRemoved);
  getEnvironment().addAnnotatedTypes(classesToBeAdded);
}
origin: org.jboss.weld.se/weld-se-shaded

public void processAnnotatedTypes() {
  Set<SlimAnnotatedTypeContext<?>> classesToBeAdded = new HashSet<SlimAnnotatedTypeContext<?>>();
  Set<SlimAnnotatedTypeContext<?>> classesToBeRemoved = new HashSet<SlimAnnotatedTypeContext<?>>();
  for (SlimAnnotatedTypeContext<?> annotatedTypeContext : getEnvironment().getAnnotatedTypes()) {
    SlimAnnotatedType<?> annotatedType = annotatedTypeContext.getAnnotatedType();
    final ProcessAnnotatedTypeImpl<?> event = containerLifecycleEvents.fireProcessAnnotatedType(getManager(), annotatedTypeContext);
    // process the result
    if (event != null) {
      if (event.isVeto()) {
        getEnvironment().vetoJavaClass(annotatedType.getJavaClass());
        classesToBeRemoved.add(annotatedTypeContext);
      } else {
        boolean dirty = event.isDirty();
        if (dirty) {
          classesToBeRemoved.add(annotatedTypeContext); // remove the original class
          classesToBeAdded.add(SlimAnnotatedTypeContext.of(event.getResultingAnnotatedType(), annotatedTypeContext.getExtension()));
        }
        processPriority(event.getResultingAnnotatedType());
      }
    } else {
      processPriority(annotatedType);
    }
  }
  getEnvironment().removeAnnotatedTypes(classesToBeRemoved);
  getEnvironment().addAnnotatedTypes(classesToBeAdded);
}
origin: org.jboss.weld.servlet/weld-servlet-shaded

public void processAnnotatedTypes() {
  Set<SlimAnnotatedTypeContext<?>> classesToBeAdded = new HashSet<SlimAnnotatedTypeContext<?>>();
  Set<SlimAnnotatedTypeContext<?>> classesToBeRemoved = new HashSet<SlimAnnotatedTypeContext<?>>();
  for (SlimAnnotatedTypeContext<?> annotatedTypeContext : getEnvironment().getAnnotatedTypes()) {
    SlimAnnotatedType<?> annotatedType = annotatedTypeContext.getAnnotatedType();
    final ProcessAnnotatedTypeImpl<?> event = containerLifecycleEvents.fireProcessAnnotatedType(getManager(), annotatedTypeContext);
    // process the result
    if (event != null) {
      if (event.isVeto()) {
        getEnvironment().vetoJavaClass(annotatedType.getJavaClass());
        classesToBeRemoved.add(annotatedTypeContext);
      } else {
        boolean dirty = event.isDirty();
        if (dirty) {
          classesToBeRemoved.add(annotatedTypeContext); // remove the original class
          classesToBeAdded.add(SlimAnnotatedTypeContext.of(event.getResultingAnnotatedType(), annotatedTypeContext.getExtension()));
        }
        processPriority(event.getResultingAnnotatedType());
      }
    } else {
      processPriority(annotatedType);
    }
  }
  getEnvironment().removeAnnotatedTypes(classesToBeRemoved);
  getEnvironment().addAnnotatedTypes(classesToBeAdded);
}
origin: weld/core

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;
}
origin: org.jboss.weld.se/weld-se

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

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

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;
}
origin: org.jboss.weld.se/weld-se-shaded

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;
}
origin: org.jboss.weld.servlet/weld-servlet-shaded

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;
}
org.jboss.weld.annotated.slimSlimAnnotatedTypeContextgetExtension

Popular methods of SlimAnnotatedTypeContext

  • <init>
  • getAnnotatedType
  • getResolvedProcessAnnotatedTypeObservers
  • of

Popular in Java

  • Reading from database using SQL prepared statement
  • setRequestProperty (URLConnection)
  • startActivity (Activity)
  • getApplicationContext (Context)
  • Menu (java.awt)
  • ServerSocket (java.net)
    This class represents a server-side socket that waits for incoming client connections. A ServerSocke
  • ResourceBundle (java.util)
    Resource bundles contain locale-specific objects. When your program needs a locale-specific resource
  • Executor (java.util.concurrent)
    An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
  • Get (org.apache.hadoop.hbase.client)
    Used to perform Get operations on a single row. To get everything for a row, instantiate a Get objec
  • Location (org.springframework.beans.factory.parsing)
    Class that models an arbitrary location in a Resource.Typically used to track the location of proble
Codota Logo
  • Products

    Search for Java codeSearch for JavaScript codeEnterprise
  • IDE Plugins

    IntelliJ IDEAWebStormAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogCodota Academy Plugin user guide Terms of usePrivacy policyJava Code IndexJavascript Code Index
Get Codota for your IDE now