<p>Getter for the field <code>ctClass</code>.</p>

@return a {@link javassist.CtClass} object.
349873
public CtClass getCtClass() {
        if (ctClass == null && fileName.endsWith(".class")) {
            try {
                ctClass = ClassPool.getDefault().makeClass(getFileStream());
            } catch (IOException e) {
                logger.error("make class error", e);
            }
        }
        return ctClass;
    }
1253888
public Class<? extends ElementBase> getRootClass() {
        LayoutElement top = root == null ? null : root.getChild(LayoutElement.class);
        return top == null ? null : top.getDefinition().getClazz();
    }
792010
private static CtClass[] generateClassField(Class<?>... classes) throws NotFoundException {
        CtClass[] result = new CtClass[classes.length];
        for (int i = 0; i < classes.length; i++) {
            result[i] = cp.get(classes[i].getName());
        }
        return result;
    }
1333091
public Class getJavaClass()
  {
    try {
      ClassLoader loader = Thread.currentThread().getContextClassLoader();
      
      return Class.forName(getName(), false, loader);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
82827
public static Class<?> getCallingClass() {
        ClassContextSecurityManager securityManager = getSecurityManager();
        if (securityManager == null)
            return null;
        Class<?>[] trace = securityManager.getClassContext();
        String thisClassName = Util.class.getName();

        // Advance until Util is found
        int i;
        for (i = 0; i < trace.length; i++) {
            if (thisClassName.equals(trace[i].getName()))
                break;
        }

        // trace[i] = Util; trace[i+1] = caller; trace[i+2] = caller's caller
        if (i >= trace.length || i + 2 >= trace.length) {
            throw new IllegalStateException("Failed to find org.slf4j.helpers.Util or its caller in the stack; " + "this should not happen");
        }

        return trace[i + 2];
    }
780034
public ASTField getField(Field field) {
        ASTAccessModifier modifier = ASTAccessModifier.getModifier(field.getModifiers());

        return new ASTClassField(field, getType(field.getType(), field.getGenericType()), modifier, getAnnotations(field));
    }
165816
public Class getPersistentFieldClass()
    {
        if (m_persistenceClass == null)
        {
            Properties properties = new Properties();
            try
            {
                this.logWarning("Loading properties file: " + getPropertiesFile());
                properties.load(new FileInputStream(getPropertiesFile()));
            }
            catch (IOException e)
            {
                this.logWarning("Could not load properties file '" + getPropertiesFile()
                        + "'. Using PersistentFieldDefaultImpl.");
                e.printStackTrace();
            }
            try
            {
                String className = properties.getProperty("PersistentFieldClass");

                m_persistenceClass = loadClass(className);
            }
            catch (ClassNotFoundException e)
            {
                e.printStackTrace();
                m_persistenceClass = PersistentFieldPrivilegedImpl.class;
            }
            logWarning("PersistentFieldClass: " + m_persistenceClass.toString());
        }
        return m_persistenceClass;
    }
898729
public static Field getField(String fieldName, Class<?> clazz) {
    Field field = null;
    try {
      field = clazz.getDeclaredField(fieldName);
    }
    catch (SecurityException e) {
      throw LOG.unableToAccessField(field, clazz.getName());
    }
    catch (NoSuchFieldException e) {
      // for some reason getDeclaredFields doesnt search superclasses
      // (which getFields() does ... but that gives only public fields)
      Class<?> superClass = clazz.getSuperclass();
      if (superClass != null) {
        return getField(fieldName, superClass);
      }
    }
    return field;
  }
1355271
public <T> T getBean(@NonNull Class<T> cls) {
        return this.ioc.getBean(cls);
    }
1144233
public ClassInfo readFieldClass()
    {
        try   {
            String strBaseClass = null;
            String strFieldClass = "Error-no based records";
            Record recClassInfo = this.getMainRecord();
            FieldData recFieldData = (FieldData)this.getRecord(FieldData.FIELD_DATA_FILE);
            String strRecordClass = recFieldData.getField(FieldData.FIELD_FILE_NAME).getString();
            String strFieldName = recFieldData.getField(FieldData.FIELD_NAME).getString();
            String strBaseFieldName = recFieldData.getField(FieldData.BASE_FIELD_NAME).getString();
            m_BasedFieldHelper.getBasedField(recFieldData, strRecordClass, strFieldName, strBaseFieldName);  // Get the field this is based on
            strFieldClass = recFieldData.getField(FieldData.FIELD_CLASS).getString();
            m_recClassInfo2.getField(ClassInfo.CLASS_NAME).setString(strFieldClass);
            m_recClassInfo2.setKeyArea(ClassInfo.CLASS_NAME_KEY);
            boolean bClassInfoExists = m_recClassInfo2.seek("=");
            if (bClassInfoExists)
                strBaseClass = m_recClassInfo2.getField(ClassInfo.BASE_CLASS_NAME).getString();  // This will probally be the base class
            String strInitField = this.getInitField(recFieldData, false, false);
            if (strInitField.length() != 0)
            {
                strBaseClass = strFieldClass;
                strFieldClass = recFieldData.getField(FieldData.FIELD_NAME).getString();
                strFieldClass = strRecordClass + "_" + strFieldClass;
                m_recClassInfo2.addNew(); // Clear info
                m_recClassInfo2.getField(ClassInfo.CLASS_NAME).setString(strFieldClass);
                m_recClassInfo2.getField(ClassInfo.BASE_CLASS_NAME).setString(strBaseClass);
                m_recClassInfo2.getField(ClassInfo.CLASS_PACKAGE).setString(this.getPackage(CodeType.THICK)); // Manual classes are from the same package
                m_recClassInfo2.getField(ClassInfo.CLASS_SOURCE_FILE).moveFieldToThis(recClassInfo.getField(ClassInfo.CLASS_SOURCE_FILE));
                m_recClassInfo2.getField(ClassInfo.CLASS_PROJECT_ID).moveFieldToThis(recClassInfo.getField(ClassInfo.CLASS_PROJECT_ID));
                return m_recClassInfo2;            // Yes, this field has a unique class
            }
            if (bClassInfoExists)
//?                if (recClassInfo.getField(ClassInfo.CLASS_SOURCE_FILE).getString().equalsIgnoreCase(m_recClassInfo2.getField(ClassInfo.CLASS_SOURCE_FILE).toString()))
                    return m_recClassInfo2;        // Yes, this field has a unique class
//            recClassInfo.getField(ClassInfo.CLASS_NAME).setString(strFieldClass);
//            recClassInfo.getField(ClassInfo.BASE_CLASS_NAME).initField(false);        // Blank base class = other class
        } catch (DBException ex)   {
            ex.printStackTrace();
        }
        return null;           // No, this field uses a different class
    }
633103
@SuppressWarnings("unchecked")
    public Class<T> delegateClass() {
	    return delegate.isPresent() ? (Class<T>) delegate.get().getClass() : null;
	}
225573
public static Class<?> getPropertyClass(Class<?> beanClass, String field) {
		return INSTANCE.findPropertyClass(beanClass, field);
	}
985153
public Class<E> getEventClass() {
        if (cachedClazz != null) {
            return cachedClazz;
        }
        Class<?> clazz = this.getClass();
        while (clazz != Object.class) {
            try {
                Type mySuperclass = clazz.getGenericSuperclass();
                Type tType = ((ParameterizedType) mySuperclass).getActualTypeArguments()[0];
                cachedClazz = (Class<E>) Class.forName(tType.getTypeName());
                return cachedClazz;
            } catch (Exception e) {
            }
            clazz = clazz.getSuperclass();
        }
        throw new IllegalStateException("Failed to load event class - " + this.getClass().getCanonicalName());
    }
536623
public static Class<?> getGenericFieldType(Field field) {
        ParameterizedType stringListType = (ParameterizedType) field.getGenericType();
        Class<?> clazz = (Class<?>) stringListType.getActualTypeArguments()[0];
        return clazz;
	}
879367
private Field findFieldInClass(Class klass, String fieldName) throws NoSuchFieldException {
        try {
            return klass.getDeclaredField(fieldName);
        } catch (NoSuchFieldException e) {
            Class superclass = klass.getSuperclass();
            if (superclass != null) {
                return findFieldInClass(superclass, fieldName);
            }
            throw new NoSuchFieldException();
        }
    }
1100907
public FieldType getField()
   {
      FieldType result = null;
      if (m_index < m_fields.length)
      {
         result = m_fields[m_index++];
      }

      return result;
   }
1023670
public synchronized Class getProxyClass()
    {
        if ((proxyClass == null) && (proxyClassName != null))
        {
            if (isDynamicProxy())
            {
                /**
                 * AClute: Return the same class back if it is dynamic. This signifies
                 * that this class become the base to a generated sub-class, regadless
                 * of which Proxy implementation is used
                 */
                return getClassOfObject();
            }
            else
            {
                try
                {
                    proxyClass = ClassHelper.getClass(proxyClassName);
                }
                catch (ClassNotFoundException e)
                {
                    throw new MetadataException(e);
                }
            }
        }
        return proxyClass;
    }