Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
Apache BCEL Source Code Files
Apache BCEL Source Code Files are inside the Apache BCEL source package file like bcel-6.6.1-src.zip. Unzip the source package file and go to the "src/main" sub-directory, you will see source code files.
Here is the list of Java source code files of the Apache BCEL 6.6.1 in \Users\fyicenter\bcel-6.6.1\src:
✍: FYIcenter
⏎ org/apache/bcel/generic/FieldGen.java
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.bcel.generic; import java.util.ArrayList; import java.util.List; import java.util.Objects; import java.util.stream.Stream; import org.apache.bcel.Const; import org.apache.bcel.classfile.Annotations; import org.apache.bcel.classfile.Attribute; import org.apache.bcel.classfile.Constant; import org.apache.bcel.classfile.ConstantObject; import org.apache.bcel.classfile.ConstantPool; import org.apache.bcel.classfile.ConstantValue; import org.apache.bcel.classfile.Field; import org.apache.bcel.classfile.Utility; import org.apache.bcel.util.BCELComparator; /** * Template class for building up a field. The only extraordinary thing one can do is to add a constant value attribute * to a field (which must of course be compatible with to the declared type). * * @see Field */ public class FieldGen extends FieldGenOrMethodGen { private static BCELComparator bcelComparator = new BCELComparator() { @Override public boolean equals(final Object o1, final Object o2) { final FieldGen THIS = (FieldGen) o1; final FieldGen THAT = (FieldGen) o2; return Objects.equals(THIS.getName(), THAT.getName()) && Objects.equals(THIS.getSignature(), THAT.getSignature()); } @Override public int hashCode(final Object o) { final FieldGen THIS = (FieldGen) o; return THIS.getSignature().hashCode() ^ THIS.getName().hashCode(); } }; /** * @return Comparison strategy object */ public static BCELComparator getComparator() { return bcelComparator; } /** * @param comparator Comparison strategy object */ public static void setComparator(final BCELComparator comparator) { bcelComparator = comparator; } private Object value; private List<FieldObserver> observers; /** * Instantiate from existing field. * * @param field Field object * @param cp constant pool (must contain the same entries as the field's constant pool) */ public FieldGen(final Field field, final ConstantPoolGen cp) { this(field.getAccessFlags(), Type.getType(field.getSignature()), field.getName(), cp); final Attribute[] attrs = field.getAttributes(); for (final Attribute attr : attrs) { if (attr instanceof ConstantValue) { setValue(((ConstantValue) attr).getConstantValueIndex()); } else if (attr instanceof Annotations) { final Annotations runtimeAnnotations = (Annotations) attr; runtimeAnnotations.forEach(element -> addAnnotationEntry(new AnnotationEntryGen(element, cp, false))); } else { addAttribute(attr); } } } /** * Declare a field. If it is static (isStatic() == true) and has a basic type like int or String it may have an initial * value associated with it as defined by setInitValue(). * * @param accessFlags access qualifiers * @param type field type * @param name field name * @param cp constant pool */ public FieldGen(final int accessFlags, final Type type, final String name, final ConstantPoolGen cp) { super(accessFlags); setType(type); setName(name); setConstantPool(cp); } private void addAnnotationsAsAttribute(final ConstantPoolGen cp) { Stream.of(AnnotationEntryGen.getAnnotationAttributes(cp, super.getAnnotationEntries())).forEach(this::addAttribute); } private int addConstant() { switch (super.getType().getType()) { // sic case Const.T_INT: case Const.T_CHAR: case Const.T_BYTE: case Const.T_BOOLEAN: case Const.T_SHORT: return super.getConstantPool().addInteger(((Integer) value).intValue()); case Const.T_FLOAT: return super.getConstantPool().addFloat(((Float) value).floatValue()); case Const.T_DOUBLE: return super.getConstantPool().addDouble(((Double) value).doubleValue()); case Const.T_LONG: return super.getConstantPool().addLong(((Long) value).longValue()); case Const.T_REFERENCE: return super.getConstantPool().addString((String) value); default: throw new IllegalStateException("Unhandled : " + super.getType().getType()); // sic } } /** * Add observer for this object. */ public void addObserver(final FieldObserver o) { if (observers == null) { observers = new ArrayList<>(); } observers.add(o); } /** * Remove any initial value. */ public void cancelInitValue() { value = null; } private void checkType(final Type atype) { final Type superType = super.getType(); if (superType == null) { throw new ClassGenException("You haven't defined the type of the field yet"); } if (!isFinal()) { throw new ClassGenException("Only final fields may have an initial value!"); } if (!superType.equals(atype)) { throw new ClassGenException("Types are not compatible: " + superType + " vs. " + atype); } } /** * @return deep copy of this field */ public FieldGen copy(final ConstantPoolGen cp) { final FieldGen fg = (FieldGen) clone(); fg.setConstantPool(cp); return fg; } /** * Return value as defined by given BCELComparator strategy. By default two FieldGen objects are said to be equal when * their names and signatures are equal. * * @see Object#equals(Object) */ @Override public boolean equals(final Object obj) { return bcelComparator.equals(this, obj); } /** * Get field object after having set up all necessary values. */ public Field getField() { final String signature = getSignature(); final int nameIndex = super.getConstantPool().addUtf8(super.getName()); final int signatureIndex = super.getConstantPool().addUtf8(signature); if (value != null) { checkType(super.getType()); final int index = addConstant(); addAttribute(new ConstantValue(super.getConstantPool().addUtf8("ConstantValue"), 2, index, super.getConstantPool().getConstantPool())); // sic } addAnnotationsAsAttribute(super.getConstantPool()); return new Field(super.getAccessFlags(), nameIndex, signatureIndex, getAttributes(), super.getConstantPool().getConstantPool()); // sic } public String getInitValue() { if (value != null) { return value.toString(); } return null; } @Override public String getSignature() { return super.getType().getSignature(); } /** * Return value as defined by given BCELComparator strategy. By default return the hashcode of the field's name XOR * signature. * * @see Object#hashCode() */ @Override public int hashCode() { return bcelComparator.hashCode(this); } /** * Remove observer for this object. */ public void removeObserver(final FieldObserver o) { if (observers != null) { observers.remove(o); } } public void setInitValue(final boolean b) { checkType(Type.BOOLEAN); if (b) { value = Integer.valueOf(1); } } public void setInitValue(final byte b) { checkType(Type.BYTE); if (b != 0) { value = Integer.valueOf(b); } } public void setInitValue(final char c) { checkType(Type.CHAR); if (c != 0) { value = Integer.valueOf(c); } } public void setInitValue(final double d) { checkType(Type.DOUBLE); if (d != 0.0) { value = Double.valueOf(d); } } public void setInitValue(final float f) { checkType(Type.FLOAT); if (f != 0.0) { value = Float.valueOf(f); } } public void setInitValue(final int i) { checkType(Type.INT); if (i != 0) { value = Integer.valueOf(i); } } public void setInitValue(final long l) { checkType(Type.LONG); if (l != 0L) { value = Long.valueOf(l); } } public void setInitValue(final short s) { checkType(Type.SHORT); if (s != 0) { value = Integer.valueOf(s); } } /** * Set (optional) initial value of field, otherwise it will be set to null/0/false by the JVM automatically. */ public void setInitValue(final String str) { checkType(ObjectType.getInstance("java.lang.String")); if (str != null) { value = str; } } private void setValue(final int index) { final ConstantPool cp = super.getConstantPool().getConstantPool(); final Constant c = cp.getConstant(index); value = ((ConstantObject) c).getConstantValue(cp); } /** * Return string representation close to declaration format, `public static final short MAX = 100', e.g.. * * @return String representation of field */ @Override public final String toString() { String name; String signature; String access; // Short cuts to constant pool access = Utility.accessToString(super.getAccessFlags()); access = access.isEmpty() ? "" : access + " "; signature = super.getType().toString(); name = getName(); final StringBuilder buf = new StringBuilder(32); // CHECKSTYLE IGNORE MagicNumber buf.append(access).append(signature).append(" ").append(name); final String value = getInitValue(); if (value != null) { buf.append(" = ").append(value); } return buf.toString(); } /** * Call notify() method on all observers. This method is not called automatically whenever the state has changed, but * has to be called by the user after they have finished editing the object. */ public void update() { if (observers != null) { for (final FieldObserver observer : observers) { observer.notify(this); } } } }
⏎ org/apache/bcel/generic/FieldGen.java
Or download all of them as a single archive file:
File name: bcel-6.6.1-sources.jar File size: 688374 bytes Release date: 2022-09-18 Download
⇒ Install Apache BCEL 6.5.0 Binary Package
⇐ Download and Install Apache BCEL Source Package
2021-08-21, 63012👍, 0💬
Popular Posts:
The JDT project provides the tool plug-ins that implement a Java IDE supporting the development of a...
commons-io-1.4.jar is the JAR file for Commons IO 1.4, which is a library of utilities to assist wit...
commons-collections4-4.2 -sources.jaris the source JAR file for Apache Commons Collections 4.2, whic...
Commons VFS provides a single API for accessing various different file systems. It presents a unifor...
Commons DBCP provides Database Connection Pooling. JAR File Size and Download Location: File name: c...