org.jboss.weld.annotated.slim.SlimAnnotatedTypeContext.getExtension 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 ProcessSyntheticAnnotatedTypeImpl(BeanManagerImpl beanManager, SlimAnnotatedTypeContext<T> annotatedTypeContext) {
  super(beanManager, annotatedTypeContext.getAnnotatedType(), ProcessSyntheticAnnotatedType.class);
  this.source = annotatedTypeContext.getExtension();
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

How to use getExtensionmethodin 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)

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