Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source.
   *
   * Copyright 2012 Red Hat, Inc.
   *
   * Licensed 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.jboss.classfilewriter.constpool;
 
 import java.util.Map;
 
 
 
 public class ConstPool implements WritableEntry {
 
     private final LinkedHashMap<ShortConstPoolEntryentries = new LinkedHashMap<ShortConstPoolEntry>();
 
     private final Map<StringShortutf8Locations = new HashMap<StringShort>();
     private final Map<StringShortclassLocations = new HashMap<StringShort>();
     private final Map<StringShortstringLocations = new HashMap<StringShort>();
     private final Map<NameAndTypeShortnameAndTypeLocations = new HashMap<NameAndTypeShort>();
     private final Map<MemberInfoShortfieldLocations = new HashMap<MemberInfoShort>();
     private final Map<MemberInfoShortmethodLocations = new HashMap<MemberInfoShort>();
     private final Map<MemberInfoShortinterfaceMethodLocations = new HashMap<MemberInfoShort>();
     private final Map<IntegerShortintegerLocations = new HashMap<IntegerShort>();
     private final Map<FloatShortfloatLocations = new HashMap<FloatShort>();
     private final Map<LongShortlongLocations = new HashMap<LongShort>();
     private final Map<DoubleShortdoubleLocations = new HashMap<DoubleShort>();
 
     private short count = 1;

    
The constant_pool_count field of the class file format
 
     private short constPoolSize = 1;
 
     public short addUtf8Entry(String entry) {
         if (.containsKey(entry)) {
             return .get(entry);
         }
         final short index = ++;
         ++;
         .put(indexnew Utf8Entry(entry));
         .put(entryindex);
         return index;
     }

    
Adds a CONSTANT_Class_info to the const pool. This must be in internal form
 
     public short addClassEntry(String className) {
         className = className.replace('.''/');
         if (.containsKey(className)) {
             return .get(className);
         }
         final short utf8Location = addUtf8Entry(className);
         final short index = ++;
         ++;
         .put(indexnew ClassEntry(utf8Location));
         .put(classNameindex);
         return index;
     }

    
Adds a CONSTANT_String_info to the const pool.
 
     public short addStringEntry(String string) {
         if (.containsKey(string)) {
             return .get(string);
         }
         final short utf8Location = addUtf8Entry(string);
         final short index = ++;
         ++;
         .put(indexnew StringEntry(utf8Location));
         .put(stringindex);
         return index;
     }
 
     public short addIntegerEntry(int entry) {
         if (.containsKey(entry)) {
             return .get(entry);
         }
        final short index = ++;
        ++;
        .put(indexnew IntegerEntry(entry));
        .put(entryindex);
        return index;
    }
    public short addFloatEntry(float entry) {
        if (.containsKey(entry)) {
            return .get(entry);
        }
        final short index = ++;
        ++;
        .put(indexnew FloatEntry(entry));
        .put(entryindex);
        return index;
    }
    public short addLongEntry(long entry) {
        if (.containsKey(entry)) {
            return .get(entry);
        }
        final short index = ++;
        ++;
         += 2;
        .put(indexnew LongEntry(entry));
        .put(entryindex);
        return index;
    }
    public short addDoubleEntry(double entry) {
        if (.containsKey(entry)) {
            return .get(entry);
        }
        final short index = ++;
        ++;
         += 2;
        .put(indexnew DoubleEntry(entry));
        .put(entryindex);
        return index;
    }
    public short addNameAndTypeEntry(String nameString type) {
        final NameAndType typeInfo = new NameAndType(nametype);
        if(.containsKey(typeInfo)) {
            return .get(typeInfo);
        }
        final short nameIndex = addUtf8Entry(name);
        final short typeIndex = addUtf8Entry(type);
        final short index = ++;
        ++;
        .put(index,new NameAndTypeEntry(nameIndextypeIndex));
        .put(typeInfoindex);
        return index;
    }
    public short addFieldEntry(String classNameString fieldNameString fieldType) {
        final NameAndType nameAndType = new NameAndType(fieldNamefieldType);
        final MemberInfo field = new MemberInfo(classNamenameAndType);
        if (.containsKey(field)) {
            return .get(field);
        }
        final short nameAndTypeIndex = addNameAndTypeEntry(fieldNamefieldType);
        final short classIndex = addClassEntry(className);
        final short index = ++;
        ++;
        .put(indexnew FieldRefEntry(classIndexnameAndTypeIndex));
        .put(fieldindex);
        return index;
    }
    public short addMethodEntry(String classNameString methodNameString descriptor) {
        final NameAndType nameAndType = new NameAndType(methodNamedescriptor);
        final MemberInfo method = new MemberInfo(classNamenameAndType);
        if (.containsKey(method)) {
            return .get(method);
        }
        final short nameAndTypeIndex = addNameAndTypeEntry(methodNamedescriptor);
        final short classIndex = addClassEntry(className);
        final short index = ++;
        ++;
        .put(indexnew MethodRefEntry(classIndexnameAndTypeIndex));
        .put(methodindex);
        return index;
    }
    public short addInterfaceMethodEntry(String classNameString methodNameString descriptor) {
        final NameAndType nameAndType = new NameAndType(methodNamedescriptor);
        final MemberInfo method = new MemberInfo(classNamenameAndType);
        if (.containsKey(method)) {
            return .get(method);
        }
        final short nameAndTypeIndex = addNameAndTypeEntry(methodNamedescriptor);
        final short classIndex = addClassEntry(className);
        final short index = ++;
        ++;
        .put(indexnew InterfaceMethodRefEntry(classIndexnameAndTypeIndex));
        .put(methodindex);
        return index;
    }
    public void write(ByteArrayDataOutputStream streamthrows IOException {
        stream.writeShort();
        for (Entry<ShortConstPoolEntryentry : .entrySet()) {
            entry.getValue().write(stream);
        }
    }
    private static final class NameAndType {
        private final String nametype;
        public NameAndType(String nameString type) {
            this. = name;
            this. = type;
        }
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + (( == null) ? 0 : .hashCode());
            result = prime * result + (( == null) ? 0 : .hashCode());
            return result;
        }
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            NameAndType other = (NameAndTypeobj;
            if ( == null) {
                if (other.name != null)
                    return false;
            } else if (!.equals(other.name))
                return false;
            if ( == null) {
                if (other.type != null)
                    return false;
            } else if (!.equals(other.type))
                return false;
            return true;
        }
    }
    private static class MemberInfo {
        private final String className;
        private final NameAndType nameAndType;
        public MemberInfo(String className,NameAndType nameAndType) {
            this. = className;
            this. = nameAndType;
        }
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + (( == null) ? 0 : .hashCode());
            result = prime * result + (( == null) ? 0 : .hashCode());
            return result;
        }
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            MemberInfo other = (MemberInfoobj;
            if ( == null) {
                if (other.className != null)
                    return false;
            } else if (!.equals(other.className))
                return false;
            if ( == null) {
                if (other.nameAndType != null)
                    return false;
            } else if (!.equals(other.nameAndType))
                return false;
            return true;
        }
    }
New to GrepCode? Check out our FAQ X