How to use org.jboss.weld.environment.osgi.impl.extension.beans

@Override
public T get() {
  populateServices();
  return service;
}

@Override
public <T> Service<T> getServiceReference() {
  return new ServiceImpl<T>(contract, registry);
}

@Override
public boolean isAmbiguous() {
  return (size() > 1);
}

@Produces
public <T> Registration<T> getRegistrations(BundleHolder bundleHolder,
                      RegistrationHolder holder,
                      InjectionPoint p) {
  logger.trace("Entering OSGiUtilitiesProducer : getRegistrations() "
      + "with parameters {} | {} | {}",
         new Object[] {bundleHolder,holder,p});
  Class<T> contract = ((Class<T>) ((ParameterizedType) p.getType()).getActualTypeArguments()[0]);
  Registration<T> result = new RegistrationImpl<T>(contract,
                           bundleHolder.getContext(),
                           bundleHolder.getBundle(),
                           holder);
  logger.debug("Returning the registrations {}", result);
  return result;
}

@Override
public <T, U extends T> Registration<T> registerService(Class<T> contract,
                            U implementation) {
  ServiceRegistration reg = registry.registerService(contract.getName(),
                            implementation,
                            null);
  holder.addRegistration(reg);
  return new RegistrationImpl<T>(contract, registry, bundle, holder);
}

@Produces
public BundleContext getBundleContext(BundleHolder holder, InjectionPoint p) {
  logger.trace("Entering OSGiUtilitiesProducer : getBundleContext() "
      + "with parameters {} | {}",
         new Object[] {holder,p});
  logger.debug("Returning the current bundle {} bundle context {}",
         holder.getBundle(),
         holder.getContext());
  return holder.getContext();
}

@Override
public Registration<T> select(String filter) {
  Filter osgiFilter = null;
  try {
    osgiFilter = FrameworkUtil.createFilter(filter);
  }
  catch(InvalidSyntaxException e) {
    throw new IllegalArgumentException("Invalid LDAP filter : "
                      + e.getMessage());
  }
  RegistrationHolder holder = new RegistrationsHolderImpl();
  for (ServiceRegistration registration : holder.getRegistrations()) {
    if (osgiFilter.match(registration.getReference())) {
      holder.addRegistration(registration);
    }
  }
  return new RegistrationImpl<T>(contract, registry, bundle, holder);
}

public void bind(@Observes ServiceEvents.ServiceArrival arrival) {
  checkForValidDependencies(arrival);
}

@Override
public Iterator<Registration<T>> iterator() {
  populate();
  return registrations.iterator();
}

public <T> void registerNewType(Class<T> type) {
  if (!types.containsKey(type)) {
    types.put(type, new Beantype<T>(type, manager));
  }
}

@PreDestroy
public void stop() {
  for (Beantype<?> type : types.values()) {
    type.destroy();
  }
}

@Produces
public Bundle getBundle(BundleHolder holder, InjectionPoint p) {
  logger.trace("Entering OSGiUtilitiesProducer : getBundle() "
         + "with parameters {} | {}",
         new Object[] {holder,p});
  logger.debug("Returning the current bundle {}", holder.getBundle());
  return holder.getBundle();
}

@Override
public <T> Registration<T> registerService(Class<T> contract,
                      Class<? extends T> implementation) {
  ServiceRegistration reg = registry.registerService(contract.getName(),
                            instances.select(implementation).get(),
                            null);
  holder.addRegistration(reg);
  return new RegistrationImpl<T>(contract, registry, bundle, holder);
}

public void changed(@Observes ServiceEvents.ServiceChanged changed) {
  checkForValidDependencies(changed);
}

@Override
public int size() {
  if (service == null) {
    try {
      populateServices();
    }
    catch(Exception e) {
      e.printStackTrace();
      return -1;
    }
  }
  return services.size();
}

@Override
public <T> Service<T> getServiceReferences(Class<T> contract) {
  return new ServiceImpl<T>(contract, registry);
}

@Override
public boolean isUnsatisfied() {
  return (size() <= 0);
}

public void unbind(@Observes ServiceEvents.ServiceDeparture departure) {
  checkForValidDependencies(departure);
}

@Override
public Iterator<T> iterator() {
  try {
    populateServices();
  }
  catch(Exception ex) {
    ex.printStackTrace();
    services = Collections.emptyList();
  }
  return services.iterator();
}

public void listenStartup(@Observes BundleContainerEvents.BundleContainerInitialized event) {
  osgiServiceDependencies = extension.getRequiredOsgiServiceDependencies();
  checkForValidDependencies(null);
}