aQute.bnd.osgi.Clazz.isInterface 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
}

private void doXmlAttribute(Annotation annotation, XMLAttribute xmlAttr) {
  if (current == null) {
    if (clazz.isInterface()) {
      ocd.addExtensionAttribute(xmlAttr, annotation);
    }
  } else {
    current.addExtensionAttribute(xmlAttr, annotation);
  }
}

private void doXmlAttribute(Annotation annotation, XMLAttribute xmlAttr) {
  if (current == null) {
    if (clazz.isInterface()) {
      ocd.addExtensionAttribute(xmlAttr, annotation);
    }
  } else {
    current.addExtensionAttribute(xmlAttr, annotation);
  }
}

@Override
public void implementsInterfaces(TypeRef names[]) throws Exception {
  Arrays.sort(names); // ignore type reordering
  for (TypeRef name : names) {
    String comment = null;
    if (clazz.isInterface() || clazz.isAbstract())
      comment = inherit(members, name);
    members.add(new Element(IMPLEMENTS, name.getFQN(), null, MINOR, MAJOR, comment));
  }
}

@Override
public void implementsInterfaces(TypeRef names[]) throws Exception {
  Arrays.sort(names); // ignore type reordering
  for (TypeRef name : names) {
    String comment = null;
    if (clazz.isInterface() || clazz.isAbstract())
      comment = inherit(members, name);
    members.add(new Element(IMPLEMENTS, name.getFQN(), null, MINOR, MAJOR, comment));
  }
}

@Override
public void implementsInterfaces(TypeRef names[]) throws Exception {
  // TODO is interface reordering important for binary
  // compatibility??
  for (TypeRef name : names) {
    String comment = null;
    if (clazz.isInterface() || clazz.isAbstract())
      comment = inherit(members, name);
    members.add(new Element(Type.IMPLEMENTS, name.getFQN(), null, MINOR, MAJOR, comment));
  }
}

@Override
public void implementsInterfaces(TypeRef names[]) throws Exception {
  // TODO is interface reordering important for binary
  // compatibility??
  for (TypeRef name : names) {
    String comment = null;
    if (clazz.isInterface() || clazz.isAbstract())
      comment = inherit(members, name);
    members.add(new Element(Type.IMPLEMENTS, name.getFQN(), null, MINOR, MAJOR, comment));
  }
}

@Override
public void implementsInterfaces(TypeRef names[]) throws Exception {
  // TODO is interface reordering important for binary
  // compatibility??
  for (TypeRef name : names) {
    String comment = null;
    if (clazz.isInterface() || clazz.isAbstract())
      comment = inherit(members, name);
    members.add(new Element(Type.IMPLEMENTS, name.getFQN(), null, MINOR, MAJOR, comment));
  }
}

private boolean acceptableType(String rtype) {
  TypeRef ref = analyzer.getTypeRef(rtype);
  try {
    Clazz returnType = analyzer.findClass(ref);
    if (returnType.isEnum()) {
      return true;
    }
    // TODO check this is true for interfaces and annotations
    if (!returnType.isAbstract() || (returnType.isInterface() && options.contains(Options.nested))) {
      return true;
    }
    if (!returnType.isInterface()) {
      analyzer.error("Abstract classes not allowed as interface method return values: %s", rtype);
    } else {
      analyzer.error("Nested metatype only allowed with option: nested type %s", rtype);
    }
    return false;
  } catch (Exception e) {
    analyzer.exception(e, "could not examine class for return type %s, exception message: %s", rtype, e);
    return false;
  }
}

@Override
public void extendsClass(TypeRef name) throws Exception {
  String comment = null;
  if (!clazz.isInterface())
    comment = inherit(members, name);
  Clazz c = analyzer.findClass(name);
  if ((c == null || c.isPublic()) && !name.isObject())
    members.add(new Element(EXTENDS, name.getFQN(), null, MICRO, MAJOR, comment));
}

private boolean acceptableType(String rtype) {
  TypeRef ref = analyzer.getTypeRef(rtype);
  try {
    Clazz returnType = analyzer.findClass(ref);
    if (returnType.isEnum()) {
      return true;
    }
    // TODO check this is true for interfaces and annotations
    if (!returnType.isAbstract() || (returnType.isInterface() && options.contains(Options.nested))) {
      return true;
    }
    if (!returnType.isInterface()) {
      analyzer.error("Abstract classes not allowed as interface method return values: %s", rtype);
    } else {
      analyzer.error("Nested metatype only allowed with option: nested type %s", rtype);
    }
    return false;
  } catch (Exception e) {
    analyzer.exception(e, "could not examine class for return type %s, exception message: %s", rtype, e);
    return false;
  }
}

@Override
public void extendsClass(TypeRef name) throws Exception {
  String comment = null;
  if (!clazz.isInterface())
    comment = inherit(members, name);
  Clazz c = analyzer.findClass(name);
  if ((c == null || c.isPublic()) && !name.isObject())
    members.add(new Element(Type.EXTENDS, name.getFQN(), null, MICRO, MAJOR, comment));
}

@Override
public void extendsClass(TypeRef name) throws Exception {
  String comment = null;
  if (!clazz.isInterface())
    comment = inherit(members, name);
  Clazz c = analyzer.findClass(name);
  if ((c == null || c.isPublic()) && !name.isObject())
    members.add(new Element(Type.EXTENDS, name.getFQN(), null, MICRO, MAJOR, comment));
}

@Override
public void extendsClass(TypeRef name) throws Exception {
  String comment = null;
  if (!clazz.isInterface())
    comment = inherit(members, name);
  Clazz c = analyzer.findClass(name);
  if ((c == null || c.isPublic()) && !name.isObject())
    members.add(new Element(EXTENDS, name.getFQN(), null, MICRO, MAJOR, comment));
}

@Override
public void extendsClass(TypeRef name) throws Exception {
  String comment = null;
  if (!clazz.isInterface())
    comment = inherit(members, name);
  Clazz c = analyzer.findClass(name);
  if ((c == null || c.isPublic()) && !name.isObject())
    members.add(new Element(Type.EXTENDS, name.getFQN(), null, MICRO, MAJOR, comment));
}

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

private List<BeanDef> getDefs() throws Exception {
  if (clazz.isEnum() || clazz.isInterface() || clazz.isAnnotation()) {

  clazz.parseClassFileWithCollector(
    new ComponentPropertyTypeDataCollector(propertyDefKey, memberDescriptor, details));
} else if (clazz.isInterface() && options.contains(Options.felixExtensions)) {
  component.updateVersion(V1_3);
} else {

private void doOCD(ObjectClassDefinition o, Annotation annotation) {
  if (ocd.id == null) {
    if (clazz.isInterface()) {
      ocd.id = annotation.get("id") == null ? name.getFQN() : o.id();
      ocd.name = annotation.get("name") == null ? space(ocd.id) : o.name();
      ocd.description = annotation.get("description") == null ? "" : o.description();
      ocd.localization = annotation.get("localization") == null ? "OSGI-INF/l10n/" + name.getFQN()
        : o.localization();
      if (annotation.get("pid") != null) {
        String[] pids = o.pid();
        designates(name.getFQN(), pids, false);
      }
      if (annotation.get("factoryPid") != null) {
        String[] pids = o.factoryPid();
        designates(name.getFQN(), pids, true);
      }
      if (annotation.get("icon") != null) {
        Icon[] icons = o.icon();
        for (Icon icon : icons) {
          ocd.icons.add(new IconDef(icon.resource(), icon.size()));
        }
      }
    } else {
      analyzer.error("ObjectClassDefinition applied to non-interface, non-annotation class %s", clazz);
    }
  }
}

private void doOCD(ObjectClassDefinition o, Annotation annotation) {
  if (ocd.id == null) {
    if (clazz.isInterface()) {
      ocd.id = annotation.get("id") == null ? name.getFQN() : o.id();
      ocd.name = annotation.get("name") == null ? space(ocd.id) : o.name();
      ocd.description = annotation.get("description") == null ? "" : o.description();
      ocd.localization = annotation.get("localization") == null ? "OSGI-INF/l10n/" + name.getFQN()
        : o.localization();
      if (annotation.get("pid") != null) {
        String[] pids = o.pid();
        designates(name.getFQN(), pids, false);
      }
      if (annotation.get("factoryPid") != null) {
        String[] pids = o.factoryPid();
        designates(name.getFQN(), pids, true);
      }
      if (annotation.get("icon") != null) {
        Icon[] icons = o.icon();
        for (Icon icon : icons) {
          ocd.icons.add(new IconDef(icon.resource(), icon.size()));
        }
      }
    } else {
      analyzer.error("ObjectClassDefinition applied to non-interface, non-annotation class %s", clazz);
    }
  }
}

Popular methods of Clazz

<init>
parseClassFileWithCollector
getClassName
getFQN
getReferred
is
isAnnotation
crawl
We must find Class.forName references ...
doAnnotation
doAnnotations
doAttribute
Process a single attribute, if not recognized, skip it.
doAttributes
Called for each attribute in the class, field, or method.

Popular in Java

Making http requests using okhttp
setRequestProperty (URLConnection)
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
getApplicationContext (Context)
Component (java.awt)
A component is an object having a graphical representation that can be displayed on the screen and t
LinkedList (java.util)
Doubly-linked list implementation of the List and Dequeinterfaces. Implements all optional list oper
ResourceBundle (java.util)
ResourceBundle is an abstract class which is the superclass of classes which provide Locale-specifi
ReentrantLock (java.util.concurrent.locks)
A reentrant mutual exclusion Lock with the same basic behavior and semantics as the implicit monitor
Modifier (javassist)
The Modifier class provides static methods and constants to decode class and member access modifiers
Runner (org.openjdk.jmh.runner)

How to use isInterfacemethodin aQute.bnd.osgi.Clazz

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

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