<p>Get thing for given class and thing name.</p>
@param pClass a Class
@param pThingName Thing Name
@return a thing
14576
@Override
  public final String getFor(final Class<?> pClass, final String pThingName) {
    if ("list".equals(pThingName)) {
      if (pClass == PaymentFrom.class || pClass == PaymentTo.class
        || pClass == PrepaymentFrom.class || pClass == PrepaymentTo.class
          || pClass == SubaccountLine.class || pClass == AdditionCostLine.class
            || pClass == Account.class) {
        return PrcPageWithSubaccTypes.class.getSimpleName();
      } else {
        return PrcEntitiesPage.class.getSimpleName();
      }
    } else if ("about".equals(pThingName)) {
      return PrcAbout.class.getSimpleName();
    }
    return null;
  }
325390
public Class<?> getClass(String pName, Class<?> defaultValue) {
        String pValue = _properties.getProperty(pName);
        return parseClass(pName, pValue, defaultValue);
    }
800257
public static Class classForName(String name) throws ClassNotFoundException {
		try {
			return Thread.currentThread().getContextClassLoader().loadClass(name);
		}
		catch (Exception e) {
			return Class.forName(name);
		}
	}
409980
public synchronized Class<?> loadClass(String className) throws ClassNotFoundException {
	// if class is already loaded flush the classloader and do new classloader
	PCLBlock cl = index.get(className);
	if (cl != null) {
	    return cl.loadClass(className);
	}
	throw new ClassNotFoundException("class " + className + " not found");
    }
1338883
protected final String getForFolSave(final Class<?> pClass) {
    if (this.seEntities.contains(pClass)) {
      return null;
    } else if (Eattachment.class == pClass) {
        return PrcEntityFfolSave.class.getSimpleName();
    }
    return PrcEntityFolSave.class.getSimpleName();
  }
869974
protected final String getForCreate(final Class<?> pClass) {
    if (this.sharedEntities.contains(pClass)) {
      return null;
    } else if (IHasSeSeller.class.isAssignableFrom(pClass)) {
      return PrcEntityCreate.class.getSimpleName();
    }
    return null;
  }
169334
private static function _loadFromApp($pClassName)
    {
        $classNameArr = explode('_', StringData::fromCamelCase($pClassName));
        $pool         = array_pop($classNameArr);

        return APP_PATH
               . Agl::APP_PHP_DIR
               . $pool
               . DS
               . implode(DS, $classNameArr)
               . Agl::PHP_EXT;
    }
82190
public Class<?> getClassForName(String className) {
        if (!StringUtils.hasText(className)) {
            return null;
        }

        for (Class<?> c : allClasses) {
            if (c.getName().equals(className)) {
                return c;
            }
        }
        return null;
    }
144896
private static Object getObject(final String className) {
        try {
            // we get the class coresponding to the life cycle name
            final Class<?> clazz = Class.forName(className);

            // we get the default constructor (with no parameter)
            final Constructor<?> contructor = clazz.getConstructor(new Class[]{});

            // we create an instance of the class using the constructor
            return contructor.newInstance(new Object[]{});

        } catch (final Exception e) {
            e.printStackTrace();
        }
        return null;
    }
1181555
private function _load($pClassName)
    {
        if (array_key_exists($pClassName, self::$_aliases)) {
            return class_alias(self::$_aliases[$pClassName], $pClassName);
        }

        if (strpos($pClassName, self::AGL_POOL) === 0) {
            $path     = self::_loadFromAgl($pClassName);
            $realPath = AGL_PATH . $path . Agl::PHP_EXT;
        } else {
            $realPath = self::_loadFromApp($pClassName);
        }

        if ($realPath and is_readable($realPath)) {
            require($realPath);
        }
    }
512386
protected final String getForFolDelete(final Class<?> pClass) {
    if (this.seEntities.contains(pClass)) {
      return null;
    } else if (Eattachment.class == pClass) {
        return PrcEntityFfolDelete.class.getSimpleName();
    }
    return PrcEntityFolDelete.class.getSimpleName();
  }
1362710
public MatchInfo getCtlMatchInfo(final String className) {
    MatchInfo match = cache.get(className);
    if (null == match) {
      match = getMatchInfo(patternSegs, className);
      if (-1 != match.startIndex) {
        cache.put(className, match);
      }
    }
    return match;
  }
1012834
public static AbstractItem getItemStreamInstance(String itemClassName) {
        AbstractItem itemStream = itemInterfaceRef.getService().getItemStreamInstance(itemClassName);;
        return itemStream;
    }
418014
public ClassInfo getClassInfo(final String className) {
        for(ClassInfo item : classInfos) {
            if(item.getClassName().equals(className)) {
                return item;
            }
        }
        return null;
    }
65571
protected final String getForEFDelete(final Class<?> pClass) {
    if (SeGoodsSpecifics.class == pClass) {
      return PrcSeGdSpecEmbFlDel.class.getSimpleName();
    } else if (SeServiceSpecifics.class == pClass) {
      return PrcSeSrvSpecEmbFlDel.class.getSimpleName();
    }
    return null;
  }
840825
protected final String getForFDelete(final Class<?> pClass) {
    if (GoodsSpecifics.class == pClass || ServiceSpecifics.class == pClass) {
      return PrcEntityFDelete.class.getSimpleName();
    }
    return null;
  }
614612
@Override
  public final Method getFor(final Class<?> pClass, final String pFieldName) {
    Map<String, Method> methMap = this.rapiMethodsMap.get(pClass);
    if (methMap == null) {
      // There is no way to get from Map partially initialized bean
      // in this double-checked locking implementation
      // cause putting to the Map fully initialized bean
      synchronized (this.rapiMethodsMap) {
        methMap = this.rapiMethodsMap.get(pClass);
        if (methMap == null) {
          methMap = new HashMap<String, Method>();
          Method[] methods = getUtlReflection().retrieveMethods(pClass);
          for (Method method : methods) {
            if (method.getName().startsWith("get")) {
              String fldNm = method.getName().substring(3, 4).toLowerCase()
                + method.getName().substring(4);
              methMap.put(fldNm, method);
            }
          }
          //assigning fully initialized object:
          this.rapiMethodsMap.put(pClass, methMap);
        }
      }
    }
    return methMap.get(pFieldName);
  }