How to use

BeanMetaData

in

org.jboss.beans.metadata.spi

  protected String getComponentName(BeanMetaData attachment)
  {
   return attachment.getName();
  }
}

/**
* Checks if the context contains the passed in dependency
* 
* @param dependency the dependency to check
* @return true if the context contains the dependency
*/
private boolean containsDependency(DependencyMetaData dependency)
{
 return context.getBeanMetaData().getDepends() != null && context.getBeanMetaData().getDepends().contains(dependency);
}

  @Override
  protected boolean isMetaDataAlreadyPresent(ClassInfo info, SpringBean annotation, BeanMetaData beanMetaData)
  {
   Set<PropertyMetaData> properties = beanMetaData.getProperties();
   if (properties != null && properties.isEmpty() == false)
   {
     for (PropertyMetaData property : properties)
     {
      if (BNP.equals(property.getName()))
      {
        return true;
      }
     }
   }
   return false;
  }
}

public BeanInfo getBeanInfo(BeanMetaData metaData) throws Throwable
{
 ClassLoader cl = Configurator.getClassLoader(metaData);
 String className = metaData.getBean();
 if (className == null)
   return null;
 return getBeanInfo(className, cl, metaData.getAccessMode());
}

@Override
public void undeploy(DeploymentUnit unit, BeanMetaData deployment)
{
 BeanMetaDataDeployerPlugin plugin = deployedWithPlugin.remove(deployment.getName());
 if (plugin == null || plugin.uninstallContext(controller, unit, deployment) == false)
 {
   ControllerContext context = controller.uninstall(deployment.getName());
   removeContext(context, unit.getParent());
 }
 
 // Remove any classloader metadata we added (not necessary if we clone above)
 ClassLoaderMetaData classLoader = deployment.getClassLoader();
 if (classLoader instanceof DeploymentClassLoaderMetaData)
   deployment.setClassLoader(null);
}

/**
* Update class annotations
* 
* @param mutable the mutable metadata
* @param context the context
* @param add true for add, false for remove
*/
private void updateClassAnnotations(MutableMetaDataLoader mutable, KernelControllerContext context, boolean add)
{
 BeanMetaData beanMetaData = context.getBeanMetaData();
 if (beanMetaData != null)
 {
   ClassLoader cl;
   try
   {
    cl = Configurator.getClassLoader(beanMetaData);
   }
   catch(Throwable t)
   {
    throw new RuntimeException("Error getting classloader for " + beanMetaData.getName(), t);
   }
   updateAnnotations(cl, mutable, beanMetaData.getAnnotations(), add);
 }
}

if (classLoaderBean.getClassLoader() == null)
  classLoaderBean.setClassLoader(new AbstractClassLoaderMetaData(new AbstractValueMetaData()));
result.add((BeanMetaData) classLoader);
     Set<AnnotationMetaData> annotationsBMD = bmd.getAnnotations();
     if (annotationsBMD == null)
      bmd.setAnnotations(annotationsBMD);
   ClassLoaderMetaData beanClassLoader = bmd.getClassLoader();
   if (beanClassLoader == null)
      if (classLoader instanceof BeanMetaData)
        classLoader = new AbstractDependencyValueMetaData(((BeanMetaData) classLoader).getName());
        beanClassLoader = new AbstractClassLoaderMetaData(classLoader);
      bmd.setClassLoader(beanClassLoader);

/**
* Create an abstract controller context
*
* @param info     the bean info
* @param metaData the meta data
* @param target   any target object
*/
public AbstractKernelControllerContext(BeanInfo info, BeanMetaData metaData, Object target)
{
 super(metaData.getName(), determineAliases(metaData), target == null ? actions : noInstantiate, new AbstractDependencyInfo(), target);
 this.info = info;
 this.metaData = metaData;
 ControllerMode mode = metaData.getMode();
 if (mode != null)
   setMode(mode);
 ErrorHandlingMode errorHandlingMode = metaData.getErrorHandlingMode();
 if (errorHandlingMode != null)
   setErrorHandlingMode(errorHandlingMode);
 boolean autowireCandidate = metaData.isAutowireCandidate();
 getDependencyInfo().setAutowireCandidate(autowireCandidate);
 if (System.getSecurityManager() != null)
   accessContext = AccessController.getContext();
 initKernelScopeInfo();
}

BeanMetaData clone = (BeanMetaData)root.clone();
List<Pair> pairs = new ArrayList<Pair>();
addPairs(clone, pairs);
 if (bean.getName() == null)
   bean.setName(generateName(previous));
 replaceWithInjection(previous, bean);
 result.add(bean);

protected List<? extends MetaDataVisitorNode> internalApplyAnnotation(ClassInfo info, MetaData retrieval, Aliases annotation, KernelControllerContext context) throws Throwable
{
 BeanMetaData beanMetaData = context.getBeanMetaData();
 Set<Object> aliases = beanMetaData.getAliases();
 Controller controller = context.getController();
 for(String alias : annotation.value())
 {
   // check for ${property}
   if (annotation.replace())
    alias = StringPropertyReplacer.replaceProperties(alias);
   if (aliases == null || aliases.contains(alias) == false)
   {
    controller.addAlias(alias, beanMetaData.getName());
   }
 }
 // no metadata added
 return null;
}

Set<DependencyMetaData> dependencies = builder.getBeanMetaData().getDepends();
if (dependencies != null)
Set<DemandMetaData> demands = builder.getBeanMetaData().getDemands();
if (demands != null)
Set<SupplyMetaData> supplies = builder.getBeanMetaData().getSupplies();
if (supplies != null)

public void removeSupplies(KernelControllerContext context)
 Set<SupplyMetaData> supplies = metaData.getSupplies();
 if (supplies != null)

protected DeploymentUnit addComponent(DeploymentUnit unit, BeanMetaData attachment)
{
 DeploymentUnit component = super.addComponent(unit, attachment);
 String className = attachment.getBean();
 if (className != null)
 {
   Object qualifier;
   if (attachment.getClassLoader() == null)
   {
    ClassLoader cl = unit.getClassLoader();
    try
    {
      qualifier = cl.loadClass(className);
    }
    catch (Exception e)
    {
      throw new IllegalArgumentException("Exception loading class for ScopeKey addition.", e);              
    }
   }
   else
   {
    qualifier = className;
   }
   component.getScope().addScope(CommonLevels.CLASS, qualifier);
 }
 return component;
}

protected void initKernelScopeInfo()
{
 String className = null;
 Object target = getTarget();
 if (target != null)
   className = target.getClass().getName();
 BeanMetaData bmd = getBeanMetaData();
 if (bmd != null)
 {
   String bean = bmd.getBean();
   if (bean != null)
    className = bean;
 }
 setScopeInfo(new KernelScopeInfo(getName(), className, bmd));
}

/**
* Get the classloader for some BeanMetaData
*
* @param metaData the metaData
* @return the classloader
* @throws Throwable for any error
*/
public static ClassLoader getClassLoader(BeanMetaData metaData) throws Throwable
{
 ClassLoaderMetaData clmd = null;
 if (metaData != null)
   clmd = metaData.getClassLoader();
 return getClassLoader(clmd);
}

  public boolean accepts(ControllerContext context) {
    Set<AnnotationMetaData> annotationMetaDataSet = ((KernelControllerContext) context).getBeanMetaData().getAnnotations();
    for (AnnotationMetaData annotationMetaData : annotationMetaDataSet) {
      if (annotationType.isAssignableFrom(annotationMetaData.getAnnotationInstance().annotationType())) {
        return true;
      }
    }
    return false;
  }
});

if (deployment.getClassLoader() == null)
   deployment.setClassLoader(new DeploymentClassLoaderMetaData(unit));
  throw DeploymentException.rethrowAsDeploymentException("Error deploying: " + deployment.getName(), t);

public void addSupplies(KernelControllerContext context)
 Set<SupplyMetaData> supplies = metaData.getSupplies();
 if (supplies != null)

protected AbstractConstructorMetaData createParametrizedMetaData(MethodInfo info, FactoryMethod annotation, BeanMetaData beanMetaData)
{
 AbstractConstructorMetaData constructor = new AbstractConstructorMetaData();
 constructor.setFactoryClass(beanMetaData.getBean());
 constructor.setFactoryMethod(info.getName());
 return constructor;
}

  protected Object getName(BeanMetaData handle)
  {
   return handle.getName();
  }
}