aQute.bnd.osgi.Clazz.getInterfaces java code examples

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
}

/**
 * Find the packages we depend on, where we implement an interface that is a
 * Provider Type. These packages, when we import them, must use the provider
 * policy.
 * 
 * @throws Exception
 */
Set<PackageRef> findProvidedPackages() throws Exception {
  Set<PackageRef> providers = Create.set();
  Set<TypeRef> cached = Create.set();
  for (Clazz c : classspace.values()) {
    TypeRef[] interfaces = c.getInterfaces();
    if (interfaces != null)
      for (TypeRef t : interfaces)
        if (cached.contains(t) || isProvider(t)) {
          cached.add(t);
          providers.add(t.getPackageRef());
        }
  }
  return providers;
}

/**
 * Find the packages we depend on, where we implement an interface that is a
 * Provider Type. These packages, when we import them, must use the provider
 * policy.
 * 
 * @throws Exception
 */
Set<PackageRef> findProvidedPackages() throws Exception {
  Set<PackageRef> providers = Create.set();
  Set<TypeRef> cached = Create.set();
  for (Clazz c : classspace.values()) {
    TypeRef[] interfaces = c.getInterfaces();
    if (interfaces != null)
      for (TypeRef t : interfaces)
        if (cached.contains(t) || isProvider(t)) {
          cached.add(t);
          providers.add(t.getPackageRef());
        }
  }
  return providers;
}

private void handleInheritedClasses(Clazz child) throws Exception {
  TypeRef[] ifaces = child.getInterfaces();
  if (ifaces != null) {
    for (TypeRef ref : ifaces) {
      parseAndMergeInheritedMetadata(ref, child);
    }
  }
  TypeRef superClazz = child.getSuper();
  if (superClazz != null) {
    parseAndMergeInheritedMetadata(superClazz, child);
  }
}

/**
 * Find the packages we depend on, where we implement an interface that is a
 * Provider Type. These packages, when we import them, must use the provider
 * policy.
 * 
 * @throws Exception
 */
Set<PackageRef> findProvidedPackages() throws Exception {
  Set<PackageRef> providers = Create.set();
  Set<TypeRef> cached = Create.set();
  for (Clazz c : classspace.values()) {
    TypeRef[] interfaces = c.getInterfaces();
    if (interfaces != null)
      for (TypeRef t : interfaces)
        if (cached.contains(t) || isProvider(t)) {
          cached.add(t);
          providers.add(t.getPackageRef());
        }
  }
  return providers;
}

private void handleInheritedClasses(Clazz child) throws Exception {
  TypeRef[] ifaces = child.getInterfaces();
  if (ifaces != null) {
    for (TypeRef ref : ifaces) {
      parseAndMergeInheritedMetadata(ref, child);
    }
  }
  TypeRef superClazz = child.getSuper();
  if (superClazz != null) {
    parseAndMergeInheritedMetadata(superClazz, child);
  }
}

private void handleInheritedClasses(Clazz child) throws Exception {
  TypeRef[] ifaces = child.getInterfaces();
  if (ifaces != null) {
    for (TypeRef ref : ifaces) {
      parseAndMergeInheritedMetadata(ref, child);
    }
  }
  TypeRef superClazz = child.getSuper();
  if (superClazz != null) {
    parseAndMergeInheritedMetadata(superClazz, child);
  }
}

private void handleInheritedClasses(Clazz child) throws Exception {
  TypeRef[] ifaces = child.getInterfaces();
  if (ifaces != null) {
    for (TypeRef ref : ifaces) {
      parseAndMergeInheritedMetadata(ref, child);
    }
  }
  TypeRef superClazz = child.getSuper();
  if (superClazz != null) {
    parseAndMergeInheritedMetadata(superClazz, child);
  }
}

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

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

getCovariantReturns(set, clazz.getSuper());
TypeRef[] interfaces = clazz.getInterfaces();
if (interfaces != null)
  for (TypeRef intf : interfaces) {

TypeRef[] intfs = annoServiceClazz.getInterfaces();
if (intfs != null) {
  for (TypeRef intf : intfs) {

private void parseExtends(Clazz clazz) {
  TypeRef[] inherits = clazz.getInterfaces();
  if (inherits != null) {
    for (TypeRef typeRef : inherits) {
      if (!typeRef.isJava() && analyzed.add(typeRef)) {
        try {
          Clazz inherit = analyzer.findClass(typeRef);
          if (inherit != null) {
            inherit.parseClassFileWithCollector(new OCDDataCollector(ocd));
            parseExtends(inherit);
          } else {
            analyzer.error("Could not obtain super class %s of class %s", typeRef.getFQN(),
              clazz.getClassName()
                .getFQN());
          }
        } catch (Exception e) {
          analyzer.exception(e, "Could not obtain super class %s of class %s; exception %s",
            typeRef.getFQN(), clazz.getClassName()
              .getFQN(),
            e);
        }
      }
    }
  }
}

TypeRef[] intfs = annoServiceClazz.getInterfaces();
if (intfs != null) {
  for (TypeRef intf : intfs) {

private void parseExtends(Clazz clazz) {
  TypeRef[] inherits = clazz.getInterfaces();
  if (inherits != null) {
    for (TypeRef typeRef : inherits) {
      if (!typeRef.isJava() && analyzed.add(typeRef)) {
        try {
          Clazz inherit = analyzer.findClass(typeRef);
          if (inherit != null) {
            inherit.parseClassFileWithCollector(new OCDDataCollector(ocd));
            parseExtends(inherit);
          } else {
            analyzer.error("Could not obtain super class %s of class %s", typeRef.getFQN(),
              clazz.getClassName()
                .getFQN());
          }
        } catch (Exception e) {
          analyzer.exception(e, "Could not obtain super class %s of class %s; exception %s",
            typeRef.getFQN(), clazz.getClassName()
              .getFQN(),
            e);
        }
      }
    }
  }
}

Popular methods of Clazz

<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

Parsing JSON documents to java classes using gson
getResourceAsStream (ClassLoader)
putExtra (Intent)
setScale (BigDecimal)
PrintWriter (java.io)
Wraps either an existing OutputStream or an existing Writerand provides convenience methods for prin
Dictionary (java.util)
Note: Do not use this class since it is obsolete. Please use the Map interface for new implementatio
CountDownLatch (java.util.concurrent)
A synchronization aid that allows one or more threads to wait until a set of operations being perfor
Stream (java.util.stream)
A sequence of elements supporting sequential and parallel aggregate operations. The following exampl
IOUtils (org.apache.commons.io)
General IO stream manipulation utilities. This class provides static utility methods for input/outpu
Scheduler (org.quartz)
This is the main interface of a Quartz Scheduler. A Scheduler maintains a registry of org.quartz.Job

How to use getInterfacesmethodin aQute.bnd.osgi.Clazz

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

How to use
getInterfaces
method
in
aQute.bnd.osgi.Clazz