HolyHalfDead's Application

[HolyHalfDead]

Name: Alexander "HolyHalfDead"
Age: 21
Location: Texas
Skills: I'm well versed with Linux/Windows (prefer linux). OOP is simplistic to me. Pretty much all (good) video game engines are based off the quake engine, so I assume, heh-assert, I'm decent with them. I code in C++/Java most often, although Pascal derivatives such as Delphi are interesting from time to time
Experience: Hardly anything legal.
Examples: Edit: Although not under any license currently, I still maintain intellectual property rights.
package bytecode;

import bytecode.attributes.*;
import bytecode.constants.ConstantClass;
import bytecode.constants.ConstantPool;
import bytecode.constants.ConstantUTF8;
import bytecode.members.Field;
import bytecode.members.Method;

/**
* The base object for java class files in an OOP accessible context. This is the base for the bytecode editing framework for use as a base lib in projects needing on the fly morphing and/or creation of java code based on user defined intelligence within other java applications.
*
* IE: for(ClassFile cf : classes) { if(!cf.isPublic()) cf.setPublic(true); }
* Effectively morphs all classfiles accessor bits to public allowing java.lang.reflect packages to actively read data from the application once executed through the ClassLoader api.
* @author Alex
*/
@SuppressWarnings({"FinalPrivateMethod"})
public final class ClassFile {
int version_minor;
int version_major;
ConstantPool constant_pool;
int access_flags;
int index_this;
int index_super;
int interfaces[];
Field fields[];
Method methods[];
AttributeList attributes;

public final AttributeList getAttributes() {
return attributes;
}

public final void setAttributes(AttributeList attributes) {
this.attributes = attributes;
}

public final AttributeInnerClasses getInnerClasses() {
return attributes.get("InnerClasses");
}

public final void setInnerClasses(AttributeInnerClasses ic) {
attributes.put("InnerClasses", ic);
}

public final AttributeEnclosingMethod getEnclosingMethod() {
return attributes.get("EnclosingMethod");
}

public final void setEnclosingMethod(AttributeEnclosingMethod em) {
attributes.put("EnclosingMethod", em);
}

public final AttributeSignature getSignature() {
return attributes.get("Signature");
}

public final void setSignature(int index) {
attributes.put("Signature", new AttributeSignature(index));
}

public final int getSourceFileIndex() {
return ((AttributeSourceFile) attributes.get("SourceFile")).getIndex();
}

public final String getSourceFile() {
return constant_pool.getUTF8(getSourceFileIndex());
}

public final void setSourceFile(int index) {
attributes.put("SourceFile", new AttributeSourceFile(index));
}

public final boolean isDeprecated() {
return attributes.contains("Deprecated");
}

public final void setDeprecated(boolean toggle) {
if (toggle) {
attributes.put("Deprecated", new AttributeDeprecated());
} else {
attributes.remove("Deprecated");
}
}

public final boolean isSyntheticAttribute() {
return attributes.contains("Synthetic");
}

public final void setSyntheticAttribute(boolean toggle) {
if (toggle) {
attributes.put("Synthetic", new AttributeSynthetic());
} else {
attributes.remove("Synthetic");
}
}

public final Method[] getMethods() {
return methods;
}

public final Field[] getFields() {
return fields;
}

public final String[] getInterfaces() {
String ifaces[] = new String[interfaces.length];
for (int i = 0; i < ifaces.length; i++) {
ConstantClass constantclass = constant_pool.get(interfaces[i]);
ConstantUTF8 constantutf8 = constant_pool.get(constantclass.index);
ifaces[i] = constantutf8.value.replaceAll("/", ".");
}
return ifaces;
}

public final String getName() {
ConstantClass constantclass = constant_pool.get(index_this);
ConstantUTF8 constantutf8 = constant_pool.get(constantclass.index);
return constantutf8.value.replaceAll("/", ".");
}

public final int getNameIndex() {
return index_this;
}

public final String getSuperName() {
ConstantClass constantclass = constant_pool.get(index_super);
ConstantUTF8 constantutf8 = constant_pool.get(constantclass.index);
return constantutf8.value.replaceAll("/", ".");
}

public final String getVersion() {
return version_major + "." + version_minor;
}

public final void setVersion(String version) {
if (version != null && version.length() > 2) {
if (version.matches("[0-9]{1,2}\\.[0-9]{1,2}")) {
String versions[] = version.split("\\.");
version_major = Integer.parseInt(versions[0]);
version_minor = Integer.parseInt(versions[1]);
}
}
}

public final ConstantPool getConstantPool() {
return constant_pool;
}

public final void setConstantPool(ConstantPool cp) {
constant_pool = cp;
}

private final void setAccessFlag(boolean toggle, int accessflag) {
if ((accessflag & accessflag) != 0) {
if (!toggle) {
access_flags ^= accessflag;
}
} else {
if (toggle) {
access_flags ^= accessflag;
}
}
}

public final boolean isPublic() {
return (access_flags & Constants.ACCESS_PUBLIC) != 0;
}

public final void setPublic(boolean toggle) {
setAccessFlag(toggle, Constants.ACCESS_PUBLIC);
}

public final boolean isFinal() {
return (access_flags & Constants.ACCESS_FINAL) != 0;
}

public final void setFinal(boolean toggle) {
setAccessFlag(toggle, Constants.ACCESS_FINAL);
if (toggle) {
setAbstract(false);
}
}

public final boolean isSuper() {
return (access_flags & Constants.ACCESS_SUPER) != 0;
}

public final void setSuper(boolean toggle) {
setAccessFlag(toggle, Constants.ACCESS_SUPER);
}

public final boolean isInterface() {
return (access_flags & Constants.ACCESS_INTERFACE) != 0;
}

public final void setInterface(boolean toggle) {
setAccessFlag(toggle, Constants.ACCESS_INTERFACE);
if (toggle) {
setAbstract(true);
setFinal(false);
setSuper(false);
setEnum(false);
}
}

public final boolean isAnnotation() {
return (access_flags & Constants.ACCESS_ANNOTATION) != 0;
}

public final void setAnnotation(boolean toggle) {
setAccessFlag(toggle, Constants.ACCESS_ANNOTATION);
if (toggle) {
setInterface(true);
}
}

public final boolean isAbstract() {
return (access_flags & Constants.ACCESS_ABSTRACT) != 0;
}

public final void setAbstract(boolean toggle) {
setAccessFlag(toggle, Constants.ACCESS_ABSTRACT);
if (toggle) {
setFinal(false);
}
}

public final boolean isSynthetic() {
return (access_flags & Constants.ACCESS_SYNTHETIC) != 0;
}

public final void setSynthetic(boolean toggle) {
setAccessFlag(toggle, Constants.ACCESS_SYNTHETIC);
}

public final boolean isEnum() {
return (access_flags & Constants.ACCESS_ENUM) != 0;
}

public final void setEnum(boolean toggle) {
setAccessFlag(toggle, Constants.ACCESS_ENUM);
}

}

[frikazoyd]

In the code you posted, why is nearly 3/4 of the code just accessor functions when all of the variables are public?