aQute.bnd.osgi.Clazz java code examples

Refine search

Common ways to obtain Clazz

private void myMethod () {
 Clazz c =Qute.bnd.osgi.Analyzer analyzer;Qute.bnd.osgi.Descriptors.TypeRef typeRef;analyzer.findClass(typeRef)
Qute.bnd.osgi.Analyzer analyzer;String path;Qute.bnd.osgi.Resource resource;new Clazz(analyzer, path, resource)
Qute.bnd.osgi.Analyzer analyzer;String str;new Clazz(analyzer, str, null)
Smart code suggestions by Tabnine
}

 function Clazz() {};
Clazz.staticMethod = function() {
  alert('STATIC!!!');
};

Clazz.prototype.func = function() {
  this.constructor.staticMethod();
}

var obj = new Clazz();
obj.func(); // <- Alert's "STATIC!!!"

    analyzer.error(
        "AD for %s.%s uses an array of collections in return type (%s), Metatype allows either Vector or array",
        clazz.getClassName().getFQN(), defined.getName(), defined.getType().getFQN());
  Matcher m = COLLECTION.matcher(rtype);
  if (m.matches()) {
    rtype = Clazz.objectDescriptorToFQN(m.group(3));
    ad.cardinality = Integer.MIN_VALUE;
TypeRef typeRef = analyzer.getTypeRefFromFQN(rtype);
try {
  Clazz c = analyzer.findClass(typeRef);
  if (c != null && c.isEnum()) {
    parseOptionValues(c, ad.options);
  analyzer.error(
      "AD for %s.%s Can not parse option values from type (%s), %s",
      clazz.getClassName().getFQN(), defined.getName(), defined.getType().getFQN(), e.getMessage());

Analyzer a = new Analyzer();
Clazz clazz = new Clazz(a, "", new URLResource(url));
Map<String,String> d = ComponentAnnotationReader.getDefinition(clazz);
    Matcher matcher = REFERENCE.matcher(key);
    if (matcher.matches()) {
      Reference r = new Reference();
      r.name = matcher.group(1);
      r.set = findMethod(matcher.group(2));
      r.unset = findMethod(matcher.group(3));

Matcher m = Patterns.UPDATED_CONFIG_TYPES.matcher(callbackDescriptor);
List<String> types = new ArrayList<>();
while (m.find()) {
  String type = m.group(5);
  if (type != null) {
    m_logger.debug("checking if type %s is an interface or an annotation", type);
    TypeRef typeRef = m_analyzer.getTypeRef(type);
    try {
      Clazz clazz = m_analyzer.findClass(typeRef);
      if (! clazz.isAnnotation() && ! clazz.isInterface()) {
        m_logger.debug("ignoring updated callback signature %s (argument type not an interface or an annotation", callbackDescriptor);
        continue;

private boolean identifiableCollection(TypeRef type, boolean intface, boolean topLevel) {
  try {
    Clazz clazz = analyzer.findClass(type);
    if (clazz != null && (!topLevel || !clazz.isAbstract())
      && ((intface && clazz.isInterface()) ^ clazz.hasPublicNoArgsConstructor())) {
      TypeRef[] intfs = clazz.getInterfaces();
      if (intfs != null) {
        for (TypeRef intf : intfs) {
          if (COLLECTION.matcher(intf.getFQN())
            .matches() || identifiableCollection(intf, true, false)) {
            return true;
          }
        }
      }
      TypeRef ext = clazz.getSuper();
      return ext != null && identifiableCollection(ext, false, false);
    }
  } catch (Exception e) {
    return false;
  }
  return false;
}

  if (!PACKAGEPATTERN.matcher(element.trim())
    .matches()) {
    allElementsAreTypes = false;
    break;
if (activatorClazz.isInterface()) {
  registerActivatorErrorLocation(
    error("The Bundle Activator %s is an interface and therefore cannot be instantiated.",
    bactivator, ActivatorErrorType.IS_INTERFACE);
} else {
  if (activatorClazz.isAbstract()) {
    registerActivatorErrorLocation(
      error("The Bundle Activator %s is abstract and therefore cannot be instantiated.",
      bactivator, ActivatorErrorType.IS_ABSTRACT);
  if (!activatorClazz.isPublic()) {
    registerActivatorErrorLocation(
      error("Bundle Activator classes must be public, and %s is not.", bactivator), bactivator,
      ActivatorErrorType.NOT_PUBLIC);
  if (!activatorClazz.hasPublicNoArgsConstructor()) {
    registerActivatorErrorLocation(error(
      "Bundle Activator classes must have a public zero-argument constructor and %s does not.",
  if (!analyzer.assignable(activatorClazz.getFQN(), "org.osgi.framework.BundleActivator")) {

  name);
FileLine where = getHeader(Pattern.compile(Constants.SERVICE_COMPONENT),
  Pattern.compile(Pattern.quote(name)));
if (where != null) {
  where.set(warning);
Collection<Clazz> classes = analyzer.getClasses(null, "NAMED", name, "ANNOTATED",
  "aQute.bnd.annotation.component.Component");
    clazz.getFQN());
  TypeRef cname = clazz.getClassName();
  String source = analyzer.getSourceFileFor(cname);
  if (source != null) {
    File f = getFile(source);

/* int max_stack = */in.readUnsignedShort();
/* int max_locals = */in.readUnsignedShort();
int code_length = in.readInt();
byte code[] = new byte[code_length];
in.readFully(code);
crawl(code);
int exception_table_length = in.readUnsignedShort();
in.skipBytes(exception_table_length * 8);
doAttributes(in, ElementType.METHOD, false, 0);

/* int max_stack = */in.readUnsignedShort();
/* int max_locals = */in.readUnsignedShort();
int code_length = in.readInt();
byte code[] = new byte[code_length];
in.readFully(code);
crawl(code);
int exception_table_length = in.readUnsignedShort();
for (int i = 0; i < exception_table_length; i++) {
  int handler_pc = in.readUnsignedShort();
  int catch_type = in.readUnsignedShort();
  classConstRef(catch_type);
doAttributes(in, ElementType.METHOD, false, 0);

case 'I' : // Integer
case 'S' : // Short
  int const_value_index = in.readUnsignedShort();
  return intPool[const_value_index];
  int type_name_index = in.readUnsignedShort();
  if (policy == RetentionPolicy.RUNTIME) {
    referTo(type_name_index, 0);
    if (api != null && (Modifier.isPublic(access_flags) || Modifier.isProtected(access_flags))) {
      TypeRef name = analyzer.getTypeRef((String) pool[type_name_index]);
      api.add(name.getPackageRef());
  int class_info_index = in.readUnsignedShort();
  if (policy == RetentionPolicy.RUNTIME) {
    referTo(class_info_index, 0);
    if (api != null && (Modifier.isPublic(access_flags) || Modifier.isProtected(access_flags))) {
      TypeRef name = analyzer.getTypeRef((String) pool[class_info_index]);
      api.add(name.getPackageRef());
  return doAnnotation(in, member, policy, collect, access_flags);
  Object[] result = new Object[num_values];
  for (int i = 0; i < num_values; i++) {
    result[i] = doElementValue(in, member, policy, collect, access_flags);

private void doAnnotations(DataInputStream in, ElementType member, RetentionPolicy policy, int access_flags)
    throws IOException {
  int num_annotations = in.readUnsignedShort(); // # of annotations
  for (int a = 0; a < num_annotations; a++) {
    if (cd == null)
      doAnnotation(in, member, policy, false, access_flags);
    else {
      Annotation annotion = doAnnotation(in, member, policy, true, access_flags);
      cd.annotation(annotion);
    }
  }
}

Map<String, Clazz> mismatched = new HashMap<>();
      String relativeDir = relativePath.substring(0, n);
        clazz = new Clazz(this, path, resource);
        clazz.parseClassFile();
      } catch (Throwable e) {
        exception(e, "Invalid class file %s (%s)", relativePath, e);
        continue next;
      String calculatedPath = clazz.getClassName()
        .getPath();
      if (!calculatedPath.equals(relativePath)) {
          mismatched.put(clazz.getAbsolutePath(), clazz);
      } else {
        classspace.put(clazz.getClassName(), clazz);
        PackageRef packageRef = clazz.getClassName()
          .getPackageRef();
        learnPackage(jar, prefix, packageRef, contained);
        for (PackageRef p : clazz.getReferred()) {
          referred.put(p);
          refs.add(p);
        apiUses.addAll(packageRef, clazz.getAPIUses());

/**
 * Visit each class on the class path.
 * 
 * @param visitor the visitor
 */
public void visit(ClassVisitor visitor) throws Exception {
  try (Analyzer analyzer = new Analyzer()) {
    for (File f : entries) {
      try (Jar jar = new Jar(f)) {
        for (String path : jar.getResources()
          .keySet()) {
          if (path.endsWith(".class")) {
            Resource r = jar.getResource(path);
            Clazz c = new Clazz(analyzer, path, r);
            c.parseClassFile();
            visitor.visit(c);
          }
        }
      }
    }
  }
}

  return;
Manifest m = analyzer.getJar().getManifest();
if (m == null) {
  error("No manifest");
Set<PackageRef> unresolvedReferences = new TreeSet<PackageRef>(analyzer.getReferred().keySet());
unresolvedReferences.removeAll(analyzer.getContained().keySet());
for ( String pname : domain.getImportPackage().keySet()) {
  PackageRef pref = analyzer.getPackageRef(pname);
    for (Clazz clazz : analyzer.getClassspace().values()) {
      if (hasOverlap(unresolvedReferences, clazz.getReferred()))
        culprits.add(clazz.getAbsolutePath());

/**
 * Visit each class on the class path.
 * 
 * @param visitor
 *            the visitor
 */
public void visit(ClassVisitor visitor) throws Exception {
  Analyzer analyzer = new Analyzer();
  try {
    for (File f : entries) {
      Jar jar = new Jar(f);
      try {
        for (String path : jar.getResources().keySet()) {
          if (path.endsWith(".class")) {
            Resource r = jar.getResource(path);
            Clazz c = new Clazz(analyzer, path, r);
            c.parseClassFile();
            visitor.visit(c);
          }
        }
      }
      finally {
        jar.close();
      }
    }
  }
  finally {
    analyzer.close();
  }
}

  public boolean analyzeJar(Analyzer analyzer) throws Exception {

    Parameters map = analyzer.parseHeader(analyzer.getProperty(Constants.METATYPE));

    Jar jar = analyzer.getJar();
    for (String name : map.keySet()) {
      Collection<Clazz> metatypes = analyzer.getClasses("", QUERY.ANNOTATED.toString(), Meta.OCD.class.getName(), //
          QUERY.NAMED.toString(), name //
          );
      for (Clazz c : metatypes) {
        jar.putResource("OSGI-INF/metatype/" + c.getFQN() + ".xml", new MetaTypeReader(c, analyzer));
      }
    }
    return false;
  }
}

private ComponentDef getDef() throws Exception {
  if (clazz.isEnum() || clazz.isInterface() || clazz.isAnnotation()) {
    if (clazz.is(ANNOTATED, COMPONENT_INSTR, analyzer)) {
      analyzer
        .error("The type %s is not a class and therfore not suitable for the @Component annotation",
          clazz.getFQN())
        .details(
          new DeclarativeServicesAnnotationError(clazz.getFQN(), null, ErrorType.INVALID_COMPONENT_TYPE));
  if (!clazz.is(ANNOTATED, COMPONENT_INSTR, analyzer)) {
  clazz.parseClassFileWithCollector(this);
  if (component.implementation == null)
    return null;
        break;
      Clazz ec = analyzer.findClass(extendsClass);
      if (ec == null) {
        analyzer
          .error("Missing super class for DS annotations: %s from %s", extendsClass, clazz.getClassName())
          .details(new DeclarativeServicesAnnotationError(className.getFQN(), null, null,
            ErrorType.UNABLE_TO_LOCATE_SUPER_CLASS));
        break;
      } else {
        ec.parseClassFileWithCollector(this);

public boolean analyzeJar(Analyzer analyzer) throws Exception {
  Parameters header = OSGiHeader.parseHeader(analyzer.getProperty(Constants.DSANNOTATIONS));
  if (header.size() == 0)
    return false;
  Instructions instructions = new Instructions(header);
  Collection<Clazz> list = analyzer.getClassspace().values();
  String sc = analyzer.getProperty(Constants.SERVICE_COMPONENT);
  List<String> names = new ArrayList<String>();
  if (sc != null && sc.trim().length() > 0)
    names.add(sc);
  for (Clazz c: list) {
    for (Instruction instruction : instructions.keySet()) {
      if (instruction.matches(c.getFQN())) {
        if (instruction.isNegated())
          break;
        ComponentDef definition = AnnotationReader.getDefinition(c, analyzer);
        if (definition != null) {
          definition.sortReferences();
          definition.prepare(analyzer);
          String name = "OSGI-INF/" + analyzer.validResourcePath(definition.name, "Invalid component name") + ".xml";
          names.add(name);
          analyzer.getJar().putResource(name, new TagResource(definition.getTag()));
        }
      }
    }
  }
  sc = Processor.append(names.toArray(new String[names.size()]));
  analyzer.setProperty(Constants.SERVICE_COMPONENT, sc);
  return false;
}

private List<BeanDef> getDefs() throws Exception {
  if (clazz.isEnum() || clazz.isInterface() || clazz.isAnnotation()) {
  if (options.contains(Discover.all) && !clazz.is(QUERY.CONCRETE, null, analyzer)) {
    return null;
    if (clazz.is(QUERY.ANNOTATED, VETOED_INSTR, analyzer)
      || (!clazz.is(QUERY.INDIRECTLY_ANNOTATED, COMPONENTSCOPED_INSTR, analyzer)
        && !clazz.is(QUERY.INDIRECTLY_ANNOTATED, NORMALSCOPE_INSTR, analyzer)
        && !clazz.is(QUERY.INDIRECTLY_ANNOTATED, STEREOTYPE_INSTR, analyzer)
        && !clazz.is(QUERY.ANNOTATED, DEPENDENT_INSTR, analyzer)
        && !clazz.is(QUERY.ANNOTATED, INTERCEPTOR_INSTR, analyzer))
      || clazz.is(QUERY.IMPLEMENTS, EXTENSION_INSTR, analyzer)) {
    Clazz packageClazz = analyzer.getPackageInfo(clazz.getClassName()
      .getPackageRef());
    if (packageClazz != null && packageClazz.is(QUERY.ANNOTATED, VETOED_INSTR, analyzer)) {
      return null;
  clazz.parseClassFileWithCollector(this);

TypeRef typeRef = analyzer.getTypeRef(param.binary);
try {
  Clazz clazz = analyzer.findClass(typeRef);
  if (clazz.isAnnotation()) {
    component.updateVersion(V1_3);
    clazz.parseClassFileWithCollector(
      new ComponentPropertyTypeDataCollector(propertyDefKey, memberDescriptor, details));
  } else if (clazz.isInterface() && options.contains(Options.felixExtensions)) {
    component.updateVersion(V1_3);
  } else {
    analyzer
      .error("Non annotation type for activation object with descriptor %s, type %s",
        memberDescriptor, param.binary)
      .details(details);

Most used methods

<init>
parseClassFileWithCollector
getClassName
getFQN
getReferred
is
isAnnotation
isInterface
crawl
We must find Class.forName references ...
doAnnotation
doAnnotations
doAttribute
Process a single attribute, if not recognized, skip it.

Popular in Java

Finding current android device location
getContentResolver (Context)
getSystemService (Context)
setScale (BigDecimal)
BufferedReader (java.io)
Wraps an existing Reader and buffers the input. Expensive interaction with the underlying reader is
Runnable (java.lang)
Represents a command that can be executed. Often used to run code in a different Thread.
Thread (java.lang)
A thread is a thread of execution in a program. The Java Virtual Machine allows an application to ha
ServerSocket (java.net)
This class represents a server-side socket that waits for incoming client connections. A ServerSocke
SocketTimeoutException (java.net)
This exception is thrown when a timeout expired on a socket read or accept operation.
Deque (java.util)
A linear collection that supports element insertion and removal at both ends. The name deque is shor

How to useClazz in aQute.bnd.osgi

Best Java code snippets using aQute.bnd.osgi.Clazz (Showing top 20 results out of 315)

Refine search

How to use
Clazz
in
aQute.bnd.osgi