Returns the Class object of the class specified in the OJB.properties
file for the "PersistentFieldClass" property.

@return Class The Class object of the "PersistentFieldClass" class
specified in the OJB.properties file.
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;
    }
1241347
private String getInstanceClass(
		final Tuple resultset,
		final int i,
		final Loadable persister,
		final Serializable id,
		final SharedSessionContractImplementor session)
	throws HibernateException {
		String discriminatorColumnName = persister.getDiscriminatorColumnName();
		if ( discriminatorColumnName == null ) {
			return persister.getEntityName();
		}
		else {
			Object value = resultset.get( discriminatorColumnName );
			return persister.getSubclassForDiscriminatorValue( value );
		}
	}
392233
public Class getSearchClass()
	{
		Object obj = getExampleObject();

		if (obj instanceof Identity)
		{
			return ((Identity) obj).getObjectsTopLevelClass();
		}
		else
		{
			return obj.getClass();
		}
	}
562601
public function getRelationEntityClass() {
    if ($this->type instanceof PersistentCollectionType) {
      return $this->type->getType()->getGClass();
    } elseif ($this->type instanceof EntityType) {
      return $this->type->getGClass();
    }
  }
1228106
public Class<?> getClassType() {
        try {
            return Class.forName(getType(), true, ClassLoaderHolder.getClassLoader());
        } catch (ClassNotFoundException e) {
            throw new IllegalStateException(e);
        }
    }
36541
public static OClass getCommonOClass(Iterator<ODocument> it) {
    	Set<OClass> candidates =  null;
    	OClass ret = null;
    	while(it.hasNext() && (candidates==null || !candidates.isEmpty())) {
    		ODocument doc = it.next();
    		OClass thisOClass = doc.getSchemaClass();
    		if(candidates==null){
    			candidates = new HashSet<OClass>();
    			candidates.add(thisOClass);
    			candidates.addAll(thisOClass.getAllSuperClasses());
    			ret = thisOClass;
    		}
    		else {
    			if(ret!=null && (ret.equals(thisOClass) || ret.isSuperClassOf(thisOClass))) continue;
    			else if(ret!=null && thisOClass.isSuperClassOf(ret)) {
    				ret = thisOClass;
    				candidates.clear();
    				candidates.add(ret);
    				candidates.addAll(ret.getAllSuperClasses());
    			}
    			else {
    				ret = null;
    				candidates.retainAll(thisOClass.getAllSuperClasses());
    			}
    		}
    	}
    	
    	if(ret==null && candidates!=null && !candidates.isEmpty()) {
    		ret = getDeepestOClass(candidates);
    	}
    	
    	return ret;
    }
1297439
public static ClassLoader getClassLoader() {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        if (cl == null) {
            cl = ClassLoader.getSystemClassLoader();
            if (cl == null) {
                // When this method is called for initializing a ICU4J class
                // during bootstrap, cl might be still null (other than Android?).
                // In this case, we want to use the bootstrap class loader.
                cl = getBootstrapClassLoader();
            }
        }
        return cl;
    }
359536
protected ClassDescriptor selectClassDescriptor(Map row) throws PersistenceBrokerException
    {
        ClassDescriptor result = m_cld;
        Class ojbConcreteClass = (Class) row.get(OJB_CONCRETE_CLASS_KEY);
        if(ojbConcreteClass != null)
        {
            result = m_cld.getRepository().getDescriptorFor(ojbConcreteClass);
            // if we can't find class-descriptor for concrete class, something wrong with mapping
            if (result == null)
            {
                throw new PersistenceBrokerException("Can't find class-descriptor for ojbConcreteClass '"
                        + ojbConcreteClass + "', the main class was " + m_cld.getClassNameOfObject());
            }
        }
        return result;
    }
1155000
@SuppressWarnings("unchecked")
	public T getInstance() {
		if(beanClassName == null) {
			return null;
		} else try {
			T beanInstance;
			Class<T> beanClass = null;
			try {
				try {
					ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
					beanClass = (Class<T>)Class.forName(beanClassName, true, classLoader);
				} catch(ClassNotFoundException cnfe) {
					throw new RuntimeException("Unknown class " + beanClassName, cnfe);
				}
				// Instancjonowanie i inicjalizcja w oparciu o konstruktor inicjujący:
				Constructor<T> constructor = (Constructor<T>)beanClass.getConstructor(Collection.class);
				beanInstance = constructor.newInstance(properties);
			} catch(NoSuchMethodException nsme) {
				// Instancjonowanie i inicjalizacja w oparciu o konstruktor bezargumentowy
				// i publiczne setter'y Java Beans:
				beanInstance = beanClass.newInstance();

				if(properties != null && !properties.isEmpty()) {
					BeanInfo validatorInfo = Introspector.getBeanInfo(beanClass);
					PropertyDescriptor[] propertyDescriptors = validatorInfo.getPropertyDescriptors();
					for(BeanProperty beanProperty : properties) {
						String propertyName = beanProperty.getPropertyName();
						Method writeMethod = null;
						for(PropertyDescriptor propertyDescriptor : propertyDescriptors) {
							if(propertyDescriptor.getName().equals(propertyName)) {
								writeMethod = propertyDescriptor.getWriteMethod();
								break;
							}
						}
						if(writeMethod == null) {
							throw new RuntimeException("No public setter found for property '" + propertyName + "' "
									+ "in validator class " + beanClass.getCanonicalName());
						}
						Class<?> parameterType = writeMethod.getParameterTypes()[0];
						if(BeanProperty.class.equals(parameterType)) {
							writeMethod.invoke(beanInstance, beanProperty);
						} else if(String.class.equals(parameterType)) {
							if(beanProperty.hasAttributes()) {
								throw new RuntimeException("BeanProperty '" + propertyName + "' setter should has "
										+ Parameter.class.getSimpleName() + " type parameter");
							}
							writeMethod.invoke(beanInstance, beanProperty.getPropertyValue());
						}
					}
				}
			}
			return beanInstance;
		} catch(Exception e) {
			throw new RuntimeException(e);
		}
	}
1094757
public OClass getLinkedClass() {
    if (linkedClass == null && linkedClassName != null)
      linkedClass = owner.owner.getClass(linkedClassName);
    return linkedClass;
  }
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;
    }
117396
@Override
    public Properties getProperties() {
        Properties properties = new Properties();
        if (persistenceUnitXml.getProperties() != null && persistenceUnitXml.getProperties().getProperty() != null) {
            for (Persistence.PersistenceUnit.Properties.Property p : persistenceUnitXml.getProperties().getProperty()) {
                properties.put(p.getName(), p.getValue());
            }
        }
        return properties;
    }
772474
public Class<?> getParameterType() {
		Class<?> lvParamType = null;
		if (propertyType == PROPERTY_TYPE_METHOD) {
			Method lvMethod = (Method) accessibleObject;
			Class<?>[] lvParameterTypes = lvMethod.getParameterTypes();
			if (lvParameterTypes != null && lvParameterTypes.length > 0) {
				lvParamType = lvMethod.getParameterTypes()[0];
			}
		} else {
			lvParamType = ((Field) accessibleObject).getType();
		}
		return lvParamType;
	}
901164
public ClassSymbol enclClass() {
        Symbol c = this;
        while (c != null &&
               ((c.kind & TYP) == 0 || !c.type.hasTag(CLASS))) {
            c = c.owner;
        }
        return (ClassSymbol)c;
    }
225573
public static Class<?> getPropertyClass(Class<?> beanClass, String field) {
		return INSTANCE.findPropertyClass(beanClass, field);
	}
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
    }
543245
@Nullable
  public static Class <?> getClass (@Nullable final Object aObject)
  {
    return aObject == null ? null : aObject.getClass ();
  }