Tabnine Logo
Annotation
Code IndexAdd Tabnine to your IDE (free)

How to use
Annotation
in
javassist.bytecode.annotation

Best Java code snippets using javassist.bytecode.annotation.Annotation (Showing top 20 results out of 945)

Refine searchRefine arrow

  • AnnotationsAttribute
  • StanfordCoreNLP
  • Properties
  • CtClass
  • ClassFile
  • StringMemberValue
origin: stackoverflow.com

props = new Properties();
props.put("annotators", "tokenize, ssplit, pos, lemma");
this.pipeline = new StanfordCoreNLP(props);
Annotation document = new Annotation(documentText);
List<CoreMap> sentences = document.get(SentencesAnnotation.class);
for(CoreMap sentence: sentences) {
origin: BroadleafCommerce/BroadleafCommerce

List<?> classFileAttributes = classFile.getAttributes();
Iterator<?> classItr = classFileAttributes.iterator();
AnnotationsAttribute attr = null;
  if (AnnotationsAttribute.class.isAssignableFrom(object.getClass())) {
    attr = (AnnotationsAttribute) object;
    Annotation[] items = attr.getAnnotations();
    for (Annotation annotation : items) {
      String typeName = annotation.getTypeName();
      if (typeName.equals(Table.class.getName())) {
        Set<String> keys = annotation.getMemberNames();
        for (String key : keys) {
          if (key.equalsIgnoreCase("name")) {
            StringMemberValue value = (StringMemberValue) annotation.getMemberValue(key);
            String oldTableName = value.getValue();
            value.setValue(tableName);
            if (LOG.isDebugEnabled()) {
              LOG.debug("Altering " + classFile.getName() + " table name from: " + oldTableName + "" +
                  " to: " + value.getValue());
    attr.setAnnotations(items);
    break;
  classFile.addAttribute(attr);
origin: apache/incubator-dubbo

ClassPool pool = ClassGenerator.getClassPool(clazz.getClassLoader());
CtClass ctClass = pool.makeClass(parameterClassName);
ClassFile classFile = ctClass.getClassFile();
classFile.setVersionToJava5();
ctClass.addConstructor(CtNewConstructor.defaultConstructor(pool.getCtClass(parameterClassName)));
  Class<?> type = parameterTypes[i];
  Annotation[] annotations = parameterAnnotations[i];
  AnnotationsAttribute attribute = new AnnotationsAttribute(classFile.getConstPool(), AnnotationsAttribute.visibleTag);
  for (Annotation annotation : annotations) {
    if (annotation.annotationType().isAnnotationPresent(Constraint.class)) {
      javassist.bytecode.annotation.Annotation ja = new javassist.bytecode.annotation.Annotation(
          classFile.getConstPool(), pool.getCtClass(annotation.annotationType().getName()));
      Method[] members = annotation.annotationType().getMethods();
      for (Method member : members) {
            MemberValue memberValue = createMemberValue(
                classFile.getConstPool(), pool.get(member.getReturnType().getName()), value);
            ja.addMemberValue(member.getName(), memberValue);
      attribute.addAnnotation(ja);
  CtField ctField = CtField.make("public " + type.getCanonicalName() + " " + fieldName + ";", pool.getCtClass(parameterClassName));
  ctField.getFieldInfo().addAttribute(attribute);
  ctClass.addField(ctField);
parameterClass = ctClass.toClass(clazz.getClassLoader(), null);
origin: xtuhcy/gecco

@Override
public DynamicField requestParameter(String param) {
  Annotation annot = new Annotation(RequestParameter.class.getName(), cpool);
  annot.addMemberValue("value", new StringMemberValue(param, cpool));
  attr.addAnnotation(annot);
  return this;
}
origin: xtuhcy/gecco

@Override
public DynamicField text(boolean own) {
  Annotation annot = new Annotation(Text.class.getName(), cpool);
  annot.addMemberValue("own", new BooleanMemberValue(own, cpool));
  attr.addAnnotation(annot);
  return this;
}

origin: redisson/redisson

/**
 * Returns a string representation of the annotation.
 */
public String toString() {
  StringBuffer buf = new StringBuffer("@");
  buf.append(getTypeName());
  if (members != null) {
    buf.append("(");
    Iterator mit = members.keySet().iterator();
    while (mit.hasNext()) {
      String name = (String)mit.next();
      buf.append(name).append("=").append(getMemberValue(name));
      if (mit.hasNext())
        buf.append(", ");
    }
    buf.append(")");
  }
  return buf.toString();
}
origin: stackoverflow.com

 Annotation ann = new Annotation("this is a sentence");
StanfordCoreNLP stage1 = new StanfordCoreNLP(new Properties(){{
 setProperty("annotators", "tokenize,ssplit,pos");
}});
stage1.annotate(ann);
// <DO OTHER THINGS>
StanfordCoreNLP stage1 = new StanfordCoreNLP(new Properties(){{
 setProperty("annotators", "ner");
 setProperty("enforceRequirements", "true");
}});
stage2.annotate(ann);
origin: changmingxie/tcc-transaction

public Class<?> toClass() {
  if (mCtc != null)
    mCtc.detach();
  long id = CLASS_NAME_COUNTER.getAndIncrement();
  try {
    CtClass ctcs = mSuperClass == null ? null : mPool.get(mSuperClass);
    if (mClassName == null)
      mClassName = (mSuperClass == null || javassist.Modifier.isPublic(ctcs.getModifiers())
          ? TccClassGenerator.class.getName() : mSuperClass + "$sc") + id;
    mCtc = mPool.makeClass(mClassName);
    if (mSuperClass != null)
      mCtc.setSuperclass(ctcs);
    mCtc.addInterface(mPool.get(DC.class.getName())); // add dynamic class tag.
    if (mInterfaces != null)
            ConstPool constpool = mCtc.getClassFile().getConstPool();
            AnnotationsAttribute attr = new AnnotationsAttribute(constpool, AnnotationsAttribute.visibleTag);
            Annotation annot = new Annotation("org.mengyun.tcctransaction.api.Compensable", constpool);
            EnumMemberValue enumMemberValue = new EnumMemberValue(constpool);
            enumMemberValue.setType("org.mengyun.tcctransaction.api.Propagation");
            enumMemberValue.setValue("SUPPORTS");
            annot.addMemberValue("propagation", enumMemberValue);
            annot.addMemberValue("confirmMethod", new StringMemberValue(ctMethod.getName(), constpool));
            annot.addMemberValue("cancelMethod", new StringMemberValue(ctMethod.getName(), constpool));
            annot.addMemberValue("transactionContextEditor", classMemberValue);
            attr.addAnnotation(annot);
            ctMethod.getMethodInfo().addAttribute(attr);
origin: apache/ignite

cl.setSuperclass(cp.get(cls.getName()));
ClassFile ccFile = cl.getClassFile();
ConstPool constpool = ccFile.getConstPool();
AnnotationsAttribute attr = new AnnotationsAttribute(constpool, AnnotationsAttribute.visibleTag);
Annotation annot = new Annotation("org.junit.BeforeClass", constpool);
attr.addAnnotation(annot);
mtd.getMethodInfo().addAttribute(attr);
cl.addMethod(mtd);
return cl.toClass();
origin: BroadleafCommerce/BroadleafCommerce

ClassFile classFile = new ClassFile(new DataInputStream(new ByteArrayInputStream(classfileBuffer)));
boolean containsTypeLevelAnnotation = false;
  List<FieldInfo> fieldInfos = classFile.getFields();
  ConstPool constantPool = classFile.getConstPool();
  for (FieldInfo myField : fieldInfos) {
    List<?> attributes = myField.getAttributes();
    Iterator<?> itr = attributes.iterator();
    AnnotationsAttribute annotationsAttribute = new AnnotationsAttribute(constantPool, AnnotationsAttribute.visibleTag);
    while (itr.hasNext()) {
      Object object = itr.next();
      if (AnnotationsAttribute.class.isAssignableFrom(object.getClass())) {
        AnnotationsAttribute attr = (AnnotationsAttribute) object;
        Annotation[] items = attr.getAnnotations();
        for (Annotation annotation : items) {
          String typeName = annotation.getTypeName();
          if (typeName.equals(Type.class.getName())) {
            StringMemberValue annot = (StringMemberValue) annotation.getMemberValue("type");
            if (annot != null && annot.getValue().equals(StringClobType.class.getName())) {
              Annotation clobType = new Annotation(Type.class.getName(), constantPool);
              StringMemberValue type = new StringMemberValue(constantPool);
              type.setValue(MaterializedClobType.class.getName());
              clobType.addMemberValue("type", type);
              annotationsAttribute.addAnnotation(clobType);
              transformed = true;
origin: hs-web/hsweb-framework

@SneakyThrows
public Proxy<I> addField(String code, Class<? extends java.lang.annotation.Annotation> annotation, Map<String, Object> annotationProperties) {
  return handleException(() -> {
    CtField ctField = CtField.make(code, ctClass);
    if (null != annotation) {
      ConstPool constPool = ctClass.getClassFile().getConstPool();
      AnnotationsAttribute attributeInfo = new AnnotationsAttribute(constPool, AnnotationsAttribute.visibleTag);
      Annotation ann = new javassist.bytecode.annotation.Annotation(annotation.getName(), constPool);
      if (null != annotationProperties) {
        annotationProperties.forEach((key, value) -> {
          MemberValue memberValue = createMemberValue(value, constPool);
          if (memberValue != null) {
            ann.addMemberValue(key, memberValue);
          }
        });
      }
      attributeInfo.addAnnotation(ann);
      ctField.getFieldInfo().addAttribute(attributeInfo);
    }
    ctClass.addField(ctField);
  });
}
origin: redisson/redisson

/**
 * Constructs an annotation that can be accessed through the interface
 * represented by <code>clazz</code>.  The values of the members are
 * not specified.
 *
 * @param cp        the constant pool table.
 * @param clazz     the interface.
 * @throws NotFoundException when the clazz is not found 
 */
public Annotation(ConstPool cp, CtClass clazz)
  throws NotFoundException
{
  // todo Enums are not supported right now.
  this(cp.addUtf8Info(Descriptor.of(clazz.getName())), cp);
  if (!clazz.isInterface())
    throw new RuntimeException(
      "Only interfaces are allowed for Annotation creation.");
  CtMethod methods[] = clazz.getDeclaredMethods();
  if (methods.length > 0) {
    members = new LinkedHashMap();
  }
  for (int i = 0; i < methods.length; i++) {
    CtClass returnType = methods[i].getReturnType();
    addMemberValue(methods[i].getName(),
            createMemberValue(cp, returnType));
    
  }
}
origin: BroadleafCommerce/BroadleafCommerce

  if (AnnotationsAttribute.class.isAssignableFrom(object.getClass())) {
    AnnotationsAttribute attr = (AnnotationsAttribute) object;
    Annotation[] items = attr.getAnnotations();
    for (Annotation annotation : items) {
      String typeName = annotation.getTypeName();
      if (!typeName.equals(Inheritance.class.getName())) {
        annotationsAttribute.addAnnotation(annotation);
Annotation inheritance = new Annotation(Inheritance.class.getName(), constantPool);
ClassPool pool = ClassPool.getDefault();
pool.importPackage("javax.persistence");
pool.importPackage("java.lang");
EnumMemberValue strategy = (EnumMemberValue) Annotation.createMemberValue(constantPool, pool.makeClass("InheritanceType"));
strategy.setType(InheritanceType.class.getName());
strategy.setValue(InheritanceType.SINGLE_TABLE.name());
inheritance.addMemberValue("strategy", strategy);
  Annotation discriminator = new Annotation(DiscriminatorColumn.class.getName(), constantPool);
  StringMemberValue name = new StringMemberValue(constantPool);
  name.setValue(myInfo.getDiscriminatorName());
  discriminator.addMemberValue("name", name);
  EnumMemberValue discriminatorType = (EnumMemberValue) Annotation.createMemberValue(constantPool, pool.makeClass("DiscriminatorType"));
  discriminatorType.setType(DiscriminatorType.class.getName());
  discriminatorType.setValue(myInfo.getDiscriminatorType().name());
  discriminator.addMemberValue("discriminatorType", discriminatorType);
  IntegerMemberValue length = new IntegerMemberValue(constantPool);
  length.setValue(myInfo.getDiscriminatorLength());
  discriminator.addMemberValue("length", length);
origin: org.streampipes/streampipes-empire-core

private static void inheritAnnotations(final CtClass theClass, final CtMethod theMethod) throws NotFoundException {
  if (hasMethod(theClass, theMethod)) {
    CtMethod aOtherMethod = theClass.getMethod(theMethod.getName(), theMethod.getSignature());
    // method we're probably overriding or implementing in the case of an abstract method.
    AnnotationsAttribute annotationsAttribute = (AnnotationsAttribute) aOtherMethod.getMethodInfo().getAttribute(AnnotationsAttribute.visibleTag);
    if (annotationsAttribute != null) {
      ConstPool cp = theClass.getClassFile().getConstPool();
      AnnotationsAttribute attr = new AnnotationsAttribute(cp, AnnotationsAttribute.visibleTag);
      for (Object obj : annotationsAttribute.getAnnotations()) {
        Annotation a = (Annotation) obj;
        Annotation theAnnotation = new Annotation(a.getTypeName(), cp);
        if (a.getMemberNames() != null) {
          for (Object aName : a.getMemberNames()) {
            theAnnotation.addMemberValue(aName.toString(), a.getMemberValue(aName.toString()));
          }
        }
        attr.addAnnotation(theAnnotation);
      }
      theMethod.getMethodInfo().addAttribute(attr);
    }
  }
}
origin: redisson/redisson

else if (type == CtClass.doubleType)
  return new DoubleMemberValue(cp);
else if (type.getName().equals("java.lang.Class"))
  return new ClassMemberValue(cp);
else if (type.getName().equals("java.lang.String"))
  return new StringMemberValue(cp);
else if (type.isArray()) {
  CtClass arrayType = type.getComponentType();
  MemberValue member = createMemberValue(cp, arrayType);
  return new ArrayMemberValue(member, cp);
else if (type.isInterface()) {
  Annotation info = new Annotation(cp, type);
  return new AnnotationMemberValue(info, cp);
origin: stackoverflow.com

 private static void addAnnotation(final CtClass clazz, final String fieldName, final String annotationName, String member, int memberValue) throws Exception {
  final ClassFile cfile = clazz.getClassFile();
  final ConstPool cpool = cfile.getConstPool();
  final CtField cfield = clazz.getField(fieldName);

  final AnnotationsAttribute attr = new AnnotationsAttribute(cpool, AnnotationsAttribute.visibleTag);
  final Annotation annot = new Annotation(annotationName, cpool);
  annot.addMemberValue(member, new IntegerMemberValue(cpool, memberValue));
  attr.addAnnotation(annot);
  cfield.getFieldInfo().addAttribute(attr);
}
origin: ru.vyarus/guice-ext-annotations

private static void createAnchorConstructor(final CtClass impl, final CtClass anchor)
    throws Exception {
  final ClassPool classPool = impl.getClassPool();
  final CtConstructor ctConstructor = CtNewConstructor.make(
      new CtClass[]{anchor},
      null,
      CtNewConstructor.PASS_NONE, null, null, impl);
  final ConstPool constPool = impl.getClassFile().getConstPool();
  final MethodInfo methodInfo = ctConstructor.getMethodInfo();
  // add injection annotation
  final AnnotationsAttribute attr = new AnnotationsAttribute(constPool, AnnotationsAttribute.visibleTag);
  final Annotation annotation = new Annotation(constPool,
      classPool.get(javax.inject.Inject.class.getName()));
  attr.addAnnotation(annotation);
  methodInfo.addAttribute(attr);
  impl.addConstructor(ctConstructor);
}
origin: xtuhcy/gecco

@Override
public JavassistDynamicBean gecco(String[] matchUrl, String downloader, int timeout, String... pipelines) {
  AnnotationsAttribute attr = new AnnotationsAttribute(cpool, AnnotationsAttribute.visibleTag);
  Annotation annot = new Annotation(Gecco.class.getName(), cpool);
  MemberValue[] elementMatchUrls = new StringMemberValue[matchUrl.length];
  for (int i = 0; i < matchUrl.length; i++) {
    elementMatchUrls[i] = new StringMemberValue(matchUrl[i], cpool);
  annot.addMemberValue("matchUrl", arrayMemberValueMatchUrl);
  annot.addMemberValue("downloader", new StringMemberValue(downloader, cpool));
  annot.addMemberValue("timeout", new IntegerMemberValue(cpool, timeout));
    elements[i] = new StringMemberValue(pipelines[i], cpool);
  annot.addMemberValue("pipelines", arrayMemberValue);
  attr.addAnnotation(annot);
  cfile.addAttribute(attr);
  return this;
origin: BroadleafCommerce/BroadleafCommerce

if (AnnotationsAttribute.class.isAssignableFrom(object.getClass())) {
  AnnotationsAttribute attr = (AnnotationsAttribute) object;
  Annotation[] items = attr.getAnnotations();
  List<Annotation> newItems = new ArrayList<Annotation>();
  ArrayMemberValue namedQueryArray = new ArrayMemberValue(constantPool);
  ArrayMemberValue nativeQueryArray = new ArrayMemberValue(constantPool);
  for (Annotation annotation : items) {
    String typeName = annotation.getTypeName();
    if (typeName.equals(NamedQueries.class.getName())) {
      namedQueryArray = (ArrayMemberValue) annotation.getMemberValue("value");
    } else if (typeName.equals(NamedNativeQueries.class.getName())) {
      nativeQueryArray = (ArrayMemberValue) annotation.getMemberValue("value");
    } else {
      newItems.add(annotation);
    Annotation namedQueriesAnnotation = new Annotation(NamedQueries.class.getName(), constantPool);
    namedQueriesAnnotation.addMemberValue("value", namedQueryArray);
    newItems.add(namedQueriesAnnotation);
    Annotation nativeQueriesAnnotation = new Annotation(NamedQueries.class.getName(), constantPool);
    nativeQueriesAnnotation.addMemberValue("value", nativeQueryArray);
    newItems.add(nativeQueriesAnnotation);
  attr.setAnnotations(newItems.toArray(new Annotation[newItems.size()]));
origin: BroadleafCommerce/BroadleafCommerce

protected void buildClassLevelAnnotations(ClassFile classFile, ClassFile templateClassFile, ConstPool constantPool) throws NotFoundException {
  List<?> templateAttributes = templateClassFile.getAttributes();
  Iterator<?> templateItr = templateAttributes.iterator();
  Annotation templateEntityListeners = null;
    if (AnnotationsAttribute.class.isAssignableFrom(object.getClass())) {
      AnnotationsAttribute attr = (AnnotationsAttribute) object;
      Annotation[] items = attr.getAnnotations();
      for (Annotation annotation : items) {
        String typeName = annotation.getTypeName();
        if (typeName.equals(EntityListeners.class.getName())) {
          templateEntityListeners = annotation;
    AnnotationsAttribute annotationsAttribute = new AnnotationsAttribute(constantPool, AnnotationsAttribute.visibleTag);
    List<?> attributes = classFile.getAttributes();
    Iterator<?> itr = attributes.iterator();
    Annotation existingEntityListeners = null;
      if (AnnotationsAttribute.class.isAssignableFrom(object.getClass())) {
        AnnotationsAttribute attr = (AnnotationsAttribute) object;
        Annotation[] items = attr.getAnnotations();
        for (Annotation annotation : items) {
          String typeName = annotation.getTypeName();
          if (typeName.equals(EntityListeners.class.getName())) {
            logger.debug("Stripping out previous EntityListeners annotation at the class level - will merge into new EntityListeners");
    annotationsAttribute.addAnnotation(entityListeners);
    classFile.addAttribute(annotationsAttribute);
javassist.bytecode.annotationAnnotation

Javadoc

The annotation structure.

An instance of this class is returned by getAnnotations() in AnnotationsAttribute or in ParameterAnnotationsAttribute.

Most used methods

  • <init>
    Constructs an annotation that can be accessed through the interface represented by clazz. The values
  • getTypeName
    Obtains the name of the annotation type.
  • addMemberValue
  • getMemberValue
    Obtains the member value with the given name.If this annotation does not have a value for the specif
  • createMemberValue
    Makes an instance of MemberValue.
  • getMemberNames
    Obtains all the member names.
  • toAnnotationType
    Constructs an annotation-type object representing this annotation. For example, if this annotation r
  • equals
    Returns true if the given object represents the same annotation as this object. The equality test ch
  • toString
    Returns a string representation of the annotation.
  • write
    Writes this annotation.
  • get
  • getShape
  • get,
  • getShape,
  • set,
  • setLeft,
  • setText,
  • setTop,
  • toShorterString

Popular in Java

  • Start an intent from android
  • getApplicationContext (Context)
  • notifyDataSetChanged (ArrayAdapter)
  • requestLocationUpdates (LocationManager)
  • Point (java.awt)
    A point representing a location in (x,y) coordinate space, specified in integer precision.
  • ByteBuffer (java.nio)
    A buffer for bytes. A byte buffer can be created in either one of the following ways: * #allocate
  • DecimalFormat (java.text)
    A concrete subclass of NumberFormat that formats decimal numbers. It has a variety of features desig
  • HashMap (java.util)
    HashMap is an implementation of Map. All optional operations are supported.All elements are permitte
  • UUID (java.util)
    UUID is an immutable representation of a 128-bit universally unique identifier (UUID). There are mul
  • Join (org.hibernate.mapping)
  • 21 Best IntelliJ Plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now