javassist.bytecode.ParameterAnnotationsAttribute Maven / Gradle / Ivy
Show all versions of jersey-all Show documentation
/*
* Javassist, a Java-bytecode translator toolkit.
* Copyright (C) 1999- Shigeru Chiba. All Rights Reserved.
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. Alternatively, the contents of this file may be used under
* the terms of the GNU Lesser General Public License Version 2.1 or later,
* or the Apache License Version 2.0.
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*/
package javassist.bytecode;
import java.util.HashMap;
import java.util.Map;
import java.io.IOException;
import java.io.DataInputStream;
import java.io.ByteArrayOutputStream;
import javassist.bytecode.AnnotationsAttribute.Copier;
import javassist.bytecode.AnnotationsAttribute.Parser;
import javassist.bytecode.AnnotationsAttribute.Renamer;
import javassist.bytecode.annotation.*;
/**
* A class representing RuntimeVisibleAnnotations_attribute and
* RuntimeInvisibleAnnotations_attribute.
*
* To obtain an ParameterAnnotationAttribute object, invoke
* getAttribute(ParameterAnnotationsAttribute.invisibleTag)
* in MethodInfo.
* The obtained attribute is a
* runtime invisible annotations attribute.
* If the parameter is
* ParameterAnnotationAttribute.visibleTag, then the obtained
* attribute is a runtime visible one.
*/
public class ParameterAnnotationsAttribute extends AttributeInfo {
/**
* The name of the RuntimeVisibleParameterAnnotations
* attribute.
*/
public static final String visibleTag
= "RuntimeVisibleParameterAnnotations";
/**
* The name of the RuntimeInvisibleParameterAnnotations
* attribute.
*/
public static final String invisibleTag
= "RuntimeInvisibleParameterAnnotations";
/**
* Constructs
* a Runtime(In)VisibleParameterAnnotations_attribute.
*
* @param cp constant pool
* @param attrname attribute name (visibleTag or
* invisibleTag).
* @param info the contents of this attribute. It does not
* include attribute_name_index or
* attribute_length.
*/
public ParameterAnnotationsAttribute(ConstPool cp, String attrname,
byte[] info) {
super(cp, attrname, info);
}
/**
* Constructs an empty
* Runtime(In)VisibleParameterAnnotations_attribute.
* A new annotation can be later added to the created attribute
* by setAnnotations().
*
* @param cp constant pool
* @param attrname attribute name (visibleTag or
* invisibleTag).
* @see #setAnnotations(Annotation[][])
*/
public ParameterAnnotationsAttribute(ConstPool cp, String attrname) {
this(cp, attrname, new byte[] { 0 });
}
/**
* @param n the attribute name.
*/
ParameterAnnotationsAttribute(ConstPool cp, int n, DataInputStream in)
throws IOException
{
super(cp, n, in);
}
/**
* Returns num_parameters.
*/
public int numParameters() {
return info[0] & 0xff;
}
/**
* Copies this attribute and returns a new copy.
*/
public AttributeInfo copy(ConstPool newCp, Map classnames) {
Copier copier = new Copier(info, constPool, newCp, classnames);
try {
copier.parameters();
return new ParameterAnnotationsAttribute(newCp, getName(),
copier.close());
}
catch (Exception e) {
throw new RuntimeException(e.toString());
}
}
/**
* Parses the annotations and returns a data structure representing
* that parsed annotations. Note that changes of the node values of the
* returned tree are not reflected on the annotations represented by
* this object unless the tree is copied back to this object by
* setAnnotations().
*
* @return Each element of the returned array represents an array of
* annotations that are associated with each method parameter.
*
* @see #setAnnotations(Annotation[][])
*/
public Annotation[][] getAnnotations() {
try {
return new Parser(info, constPool).parseParameters();
}
catch (Exception e) {
throw new RuntimeException(e.toString());
}
}
/**
* Changes the annotations represented by this object according to
* the given array of Annotation objects.
*
* @param params the data structure representing the
* new annotations. Every element of this array
* is an array of Annotation and
* it represens annotations of each method parameter.
*/
public void setAnnotations(Annotation[][] params) {
ByteArrayOutputStream output = new ByteArrayOutputStream();
AnnotationsWriter writer = new AnnotationsWriter(output, constPool);
try {
int n = params.length;
writer.numParameters(n);
for (int i = 0; i < n; ++i) {
Annotation[] anno = params[i];
writer.numAnnotations(anno.length);
for (int j = 0; j < anno.length; ++j)
anno[j].write(writer);
}
writer.close();
}
catch (IOException e) {
throw new RuntimeException(e); // should never reach here.
}
set(output.toByteArray());
}
/**
* @param oldname a JVM class name.
* @param newname a JVM class name.
*/
void renameClass(String oldname, String newname) {
HashMap map = new HashMap();
map.put(oldname, newname);
renameClass(map);
}
void renameClass(Map classnames) {
Renamer renamer = new Renamer(info, getConstPool(), classnames);
try {
renamer.parameters();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
void getRefClasses(Map classnames) { renameClass(classnames); }
/**
* Returns a string representation of this object.
*/
public String toString() {
Annotation[][] aa = getAnnotations();
StringBuilder sbuf = new StringBuilder();
int k = 0;
while (k < aa.length) {
Annotation[] a = aa[k++];
int i = 0;
while (i < a.length) {
sbuf.append(a[i++].toString());
if (i != a.length)
sbuf.append(" ");
}
if (k != aa.length)
sbuf.append(", ");
}
return sbuf.toString();
}
}