Java example source code file (JSJavaInstanceKlass.java)

This example Java source code file (JSJavaInstanceKlass.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

field, field_is_abstract, field_is_interface, field_is_private, field_is_static, field_undefined, hashmap, instanceklass, iterator, list, nosuchfieldexception, object, set, string, util

The JSJavaInstanceKlass.java Java example source code

/*
 * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

package sun.jvm.hotspot.utilities.soql;

import java.util.*;
import sun.jvm.hotspot.oops.*;
import sun.jvm.hotspot.utilities.*;

/**
   This is JavaScript wrapper for InstanceKlass.
*/
public class JSJavaInstanceKlass extends JSJavaKlass {
   private static final int FIELD_SOURCE_FILE        = 1;
   private static final int FIELD_INTERFACES         = 2;
   private static final int FIELD_FIELDS             = 3;
   private static final int FIELD_METHODS            = 4;
   private static final int FIELD_IS_PRIVATE         = 5;
   private static final int FIELD_IS_PUBLIC          = 6;
   private static final int FIELD_IS_PROTECTED       = 7;
   private static final int FIELD_IS_PACKAGE_PRIVATE = 8;
   private static final int FIELD_IS_STATIC          = 9;
   private static final int FIELD_IS_FINAL           = 10;
   private static final int FIELD_IS_ABSTRACT        = 11;
   private static final int FIELD_IS_STRICT          = 12;
   private static final int FIELD_IS_SYNTHETIC       = 13;
   private static final int FIELD_IS_INTERFACE       = 14;
   private static final int FIELD_CLASS_LOADER       = 15;
   private static final int FIELD_STATICS            = 18;
   private static final int FIELD_UNDEFINED          = -1;

   public JSJavaInstanceKlass(InstanceKlass kls, JSJavaFactory fac) {
      super(kls, fac);
      this.instanceFields = new HashMap();
      this.staticFields = new HashMap();
   }

   public final InstanceKlass getInstanceKlass() {
      return (InstanceKlass) getKlass();
   }

   public Object getMetaClassFieldValue(String name) {
      int fieldID = getFieldID(name);
      InstanceKlass ik = getInstanceKlass();
      switch (fieldID) {
      case FIELD_SOURCE_FILE: {
         Symbol sourceFile = ik.getSourceFileName();
         return (sourceFile != null)? sourceFile.asString() : "<unknown>";
      }
      case FIELD_INTERFACES:
         return getInterfaces();
      case FIELD_FIELDS:
         return factory.newJSList(ik.getImmediateFields());
      case FIELD_METHODS:
         return factory.newJSList(ik.getImmediateMethods());
      case FIELD_IS_PRIVATE:
         return Boolean.valueOf(getAccessFlags().isPrivate());
      case FIELD_IS_PUBLIC:
         return Boolean.valueOf(getAccessFlags().isPublic());
      case FIELD_IS_PROTECTED:
         return Boolean.valueOf(getAccessFlags().isProtected());
      case FIELD_IS_PACKAGE_PRIVATE: {
         AccessFlags acc = getAccessFlags();
         return Boolean.valueOf(!acc.isPrivate() && !acc.isPublic() && !acc.isProtected());
      }
      case FIELD_IS_STATIC:
         return Boolean.valueOf(getAccessFlags().isStatic());
      case FIELD_IS_FINAL:
         return Boolean.valueOf(getAccessFlags().isFinal());
      case FIELD_IS_ABSTRACT:
         return Boolean.valueOf(getAccessFlags().isAbstract());
      case FIELD_IS_STRICT:
         return Boolean.valueOf(getAccessFlags().isStrict());
      case FIELD_IS_SYNTHETIC:
         return Boolean.valueOf(getAccessFlags().isSynthetic());
      case FIELD_IS_INTERFACE:
         return Boolean.valueOf(ik.isInterface());
      case FIELD_CLASS_LOADER:
         return factory.newJSJavaObject(ik.getClassLoader());
      case FIELD_STATICS:
         return getStatics();
      case FIELD_UNDEFINED:
      default:
         return super.getMetaClassFieldValue(name);
      }
   }

   public boolean hasMetaClassField(String name) {
      if (getFieldID(name) != FIELD_UNDEFINED) {
          return true;
      } else {
          return super.hasMetaClassField(name);
      }
   }

   public String getName() {
      return getInstanceKlass().getName().asString().replace('/', '.');
   }

   public boolean isArray() {
      return false;
   }

   public String[] getMetaClassFieldNames() {
      String[] superFields = super.getMetaClassFieldNames();
      Set k = fields.keySet();
      String[] res = new String[k.size() + superFields.length];
      System.arraycopy(superFields, 0, res, 0, superFields.length);
      int i = superFields.length;
      for (Iterator itr = k.iterator(); itr.hasNext();) {
          res[i] = (String) itr.next();
          i++;
      }
      return res;
   }

   public Object getInstanceFieldValue(String name, Instance instance) throws NoSuchFieldException {
      Field fld = findInstanceField(name);
      if (fld != null) {
         return getFieldValue(fld, name, instance);
      } else {
         throw new NoSuchFieldException(name + " is not field of "
                + getInstanceKlass().getName().asString().replace('/', '.'));
      }
   }

   public Object getStaticFieldValue(String name) throws NoSuchFieldException {
      Field fld = findStaticField(name);
      if (fld != null) {
         return getFieldValue(fld, name, getInstanceKlass());
      } else {
         throw new NoSuchFieldException(name + " is not field of "
                + getInstanceKlass().getName().asString().replace('/', '.'));
      }
   }

   public String[] getInstanceFieldNames() {
      if (instanceFieldNames == null) {
         InstanceKlass current = getInstanceKlass();
         while (current != null) {
            List tmp = current.getImmediateFields();
            for (Iterator itr = tmp.iterator(); itr.hasNext();) {
               Field fld = (Field) itr.next();
               if (!fld.isStatic()) {
                  String name = fld.getID().getName();
                  if (instanceFields.get(name) == null) {
                     instanceFields.put(name, fld);
                  }
               }
            }
            current = (InstanceKlass) current.getSuper();
         }

         Set s = instanceFields.keySet();
         instanceFieldNames = new String[s.size()];
         int i = 0;
         for (Iterator itr = s.iterator(); itr.hasNext(); i++) {
            instanceFieldNames[i] = (String) itr.next();
         }
      }
      return instanceFieldNames;
   }

   public boolean hasInstanceField(String name) {
      Field fld = findInstanceField(name);
      return (fld != null)? true: false;
   }

   public String[] getStaticFieldNames() {
      if (staticFieldNames == null) {
         InstanceKlass current = getInstanceKlass();
         List tmp = current.getImmediateFields();
         for (Iterator itr = tmp.iterator(); itr.hasNext();) {
            Field fld = (Field) itr.next();
            if (fld.isStatic()) {
               staticFields.put(fld.getID().getName(), fld);
            }
         }

         Set s = staticFields.keySet();
         staticFieldNames = new String[s.size()];
         int i = 0;
         for (Iterator itr = s.iterator(); itr.hasNext(); i++) {
            staticFieldNames[i] = (String) itr.next();
         }
      }
      return staticFieldNames;
   }

   public boolean hasStaticField(String name) {
      Field fld = findStaticField(name);
      return (fld != null)? true: false;
   }

   //-- Intenals only below this point
   private static Map fields = new HashMap();
   private static void addField(String name, int fieldId) {
      fields.put(name, new Integer(fieldId));
   }

   private static int getFieldID(String name) {
      Integer res = (Integer) fields.get(name);
      return (res != null)? res.intValue() : FIELD_UNDEFINED;
   }

   static {
      addField("sourceFile", FIELD_SOURCE_FILE);
      addField("interfaces", FIELD_INTERFACES);
      addField("fields", FIELD_FIELDS);
      addField("methods", FIELD_METHODS);
      addField("isPrivate", FIELD_IS_PRIVATE);
      addField("isPublic", FIELD_IS_PUBLIC);
      addField("isProtected", FIELD_IS_PROTECTED);
      addField("isPackagePrivate", FIELD_IS_PACKAGE_PRIVATE);
      addField("isStatic", FIELD_IS_STATIC);
      addField("isFinal", FIELD_IS_FINAL);
      addField("isAbstract", FIELD_IS_ABSTRACT);
      addField("isStrict", FIELD_IS_STRICT);
      addField("isSynthetic", FIELD_IS_SYNTHETIC);
      addField("isInterface", FIELD_IS_INTERFACE);
      addField("classLoader", FIELD_CLASS_LOADER);
      addField("statics", FIELD_STATICS);
   }

   private AccessFlags getAccessFlags() {
      if (accFlags == null) {
         accFlags = new AccessFlags(getInstanceKlass().computeModifierFlags());
      }
      return accFlags;
   }

   private Object getFieldValue(Field fld, String name, Oop oop) {
       FieldType fd = fld.getFieldType();
       if (fd.isObject() || fd.isArray()) {
         return factory.newJSJavaObject(((OopField)fld).getValue(oop));
       } else if (fd.isByte()) {
          return new Byte(((ByteField)fld).getValue(oop));
       } else if (fd.isChar()) {
          return new String(new char[] { ((CharField)fld).getValue(oop) });
       } else if (fd.isDouble()) {
          return new Double(((DoubleField)fld).getValue(oop));
       } else if (fd.isFloat()) {
          return new Float(((FloatField)fld).getValue(oop));
       } else if (fd.isInt()) {
          return new Integer(((IntField)fld).getValue(oop));
       } else if (fd.isLong()) {
          return new Long(((LongField)fld).getValue(oop));
       } else if (fd.isShort()) {
          return new Short(((ShortField)fld).getValue(oop));
       } else if (fd.isBoolean()) {
          return Boolean.valueOf(((BooleanField)fld).getValue(oop));
       } else {
          if (Assert.ASSERTS_ENABLED) {
             Assert.that(false, "invalid field type for " + name);
          }
          return null;
       }
   }

   private Object getFieldValue(Field fld, String name, InstanceKlass oop) {
       FieldType fd = fld.getFieldType();
       if (fd.isObject() || fd.isArray()) {
         return factory.newJSJavaObject(((OopField)fld).getValue(oop));
       } else if (fd.isByte()) {
          return new Byte(((ByteField)fld).getValue(oop));
       } else if (fd.isChar()) {
          return new String(new char[] { ((CharField)fld).getValue(oop) });
       } else if (fd.isDouble()) {
          return new Double(((DoubleField)fld).getValue(oop));
       } else if (fd.isFloat()) {
          return new Float(((FloatField)fld).getValue(oop));
       } else if (fd.isInt()) {
          return new Integer(((IntField)fld).getValue(oop));
       } else if (fd.isLong()) {
          return new Long(((LongField)fld).getValue(oop));
       } else if (fd.isShort()) {
          return new Short(((ShortField)fld).getValue(oop));
       } else if (fd.isBoolean()) {
          return Boolean.valueOf(((BooleanField)fld).getValue(oop));
       } else {
          if (Assert.ASSERTS_ENABLED) {
             Assert.that(false, "invalid field type for " + name);
          }
          return null;
       }
   }

   private Field findInstanceField(String name) {
      Field fld = (Field) instanceFields.get(name);
      if (fld != null) {
         return fld;
      } else {
         InstanceKlass current = getInstanceKlass();
         while (current != null) {
            List tmp = current.getImmediateFields();
            for (Iterator itr = tmp.iterator(); itr.hasNext();) {
               fld = (Field) itr.next();
               if (fld.getID().getName().equals(name) && !fld.isStatic()) {
                   instanceFields.put(name, fld);
                   return fld;
               }
            }
            // lookup in super class.
            current = (InstanceKlass) current.getSuper();
         }
      }
      // no match
      return null;
   }

   private Field findStaticField(String name) {
      Field fld = (Field) staticFields.get(name);
      if (fld != null) {
         return fld;
      } else {
         // static fields are searched only in current.
         // Direct/indirect super classes and interfaces
         // are not included in search.
         InstanceKlass current = getInstanceKlass();
         List tmp = current.getImmediateFields();
         for (Iterator itr = tmp.iterator(); itr.hasNext();) {
            fld = (Field) itr.next();
            if (fld.getID().getName().equals(name) && fld.isStatic()) {
               staticFields.put(name, fld);
               return fld;
            }
         }
         // no match
         return null;
      }
   }

   private JSList getInterfaces() {
      InstanceKlass ik = getInstanceKlass();
      List intfs = ik.getDirectImplementedInterfaces();
      List res = new ArrayList(0);
      for (Iterator itr = intfs.iterator(); itr.hasNext();) {
          Klass k = (Klass) itr.next();
          res.add(k.getJavaMirror());
      }
      return factory.newJSList(res);
   }

   private JSMap getStatics() {
      String[] names = getStaticFieldNames();
      Map map = new HashMap();
      for (int i=0; i < names.length; i++) {
         try {
            map.put(names[i], getStaticFieldValue(names[i]));
         } catch (NoSuchFieldException exp) {}
      }
      return factory.newJSMap(map);
  }

   private Map           instanceFields;
   private Map           staticFields;
   private String[]      instanceFieldNames;
   private String[]      staticFieldNames;
   private AccessFlags   accFlags;
}