The overridden renderer class for the given fully qualified classname.

@param classname the fully qualified classname of the WComponent to check for an overridden renderer.
@return the parameter value, else null if not set.
429272
public static String getRendererOverride(final String classname) {
		if (StringUtils.isBlank(classname)) {
			throw new IllegalArgumentException("classname cannot be blank.");
		}

		return get().getString(RENDERER_OVERRIDE_PREFIX + classname);
	}
1324677
@SuppressWarnings( "unchecked" )
    private <T> Class<T> loadClassIfVisible( String className, ClassLoader classLoader )
    {
        try
        {
            Class<T> klass = (Class<T>) classLoader.loadClass( className );
            return klass;
        }
        catch ( ClassNotFoundException e )
        {
            return null;
        }
    }
1350644
private JClassType findClassType( Class<?> clazz ) {
        JClassType mapperType = context.getTypeOracle().findType( clazz.getCanonicalName() );
        if ( null == mapperType ) {
            logger.log( Type.WARN, "Cannot find the type denoted by the class " + clazz.getCanonicalName()
                       + " or GWT compilation of that class failed. In the latter case, compile with -failOnError to discover the real error." );
            return null;
        }
        return mapperType;
    }
583031
@Override
    public String fromClassNameToShortComponentName(final String className) {
        if (LdiStringUtil.isEmpty(className)) {
            throw new EmptyRuntimeException("className");
        }
        String s = LdiStringUtil.decapitalize(LdiClassUtil.getShortClassName(className));
        if (s.endsWith(implementationSuffix)) {
            return s.substring(0, s.length() - implementationSuffix.length());
        }
        return s;
    }
1318461
public static ClassName className(String className) {
		int index = className.lastIndexOf(".");
		if (index > 0) {
			return classNameWithSuffix(className.substring(0, index), className.substring(index + 1), "");
		}
		return ClassName.get("", className);

	}
1078898
public String getParameterClassName(String attributeName, JspCoreContext context) throws JspCoreException {
        String parameterClassName = null;
        
        if (parameterClassNameMap == null) {
            parameterClassNameMap = new HashMap();
        }
        
        parameterClassName = (String)parameterClassNameMap.get(attributeName);
        
        if (parameterClassName == null) {
            TagAttributeInfo[] attributeInfos = ti.getAttributes();
            for (int i = 0; i < attributeInfos.length; i++) {
                if (attributeInfos[i].getName().equals(attributeName)) {
                    //PK69319
                	if(attributeInfos[i].isFragment()){
                		parameterClassName = "javax.servlet.jsp.tagext.JspFragment";
                	} else{
                		parameterClassName = attributeInfos[i].getTypeName();
                	}
                    parameterClassNameMap.put(attributeName, parameterClassName);
                    break;
                }
            }
        }
        return (parameterClassName);
    }
969088
@Override
    @FFDCIgnore(ClassNotFoundException.class)
    public Class<?> classForName(String className)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
        {
            Tr.debug(tc, "Loading class " + className + " using classloader " + delegate);
        }
        try
        {
            return delegate.loadClass(className);
        } catch (ClassNotFoundException e)
        {
            return loadFromWeldBundleCL(className);
        }
    }
303996
public JsEngineComponent getEngineComponent(String className) {

        String thisMethodName = "getEngineComponent";

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(tc, thisMethodName, className);
        }

        JsEngineComponent foundEngineComponent = null;

        // No need to synchronize on jmeComponents to prevent concurrent
        // modification from dynamic config and runtime callbacks, because
        // jmeComponents is now a CopyOnWriteArrayList.
        Iterator<ComponentList> vIter = jmeComponents.iterator();

        while (vIter.hasNext() && foundEngineComponent == null) {
            ComponentList c = vIter.next();
            if (c.getClassName().equals(className)) {
                foundEngineComponent = c.getRef();
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(tc, thisMethodName, foundEngineComponent);
        }

        return foundEngineComponent;
    }
988577
@Nullable
    public static String classToSignature(String className) {
        if (className == null) {
            return null;
        } else if (className.startsWith(Values.SIG_ARRAY_PREFIX)) {
            // convert the classname inside the array
            return Values.SIG_ARRAY_PREFIX + classToSignature(className.substring(Values.SIG_ARRAY_PREFIX.length()));
        } else if (PRIMITIVE_TYPES.contains(className) || className.endsWith(Values.SIG_QUALIFIED_CLASS_SUFFIX)) {
            return className.replace('.', '/');
        } else {
            String primitive = PRIMITIVE_NAME_TO_SIG.get(className);
            if (primitive != null) {
                return primitive;
            }

            return Values.SIG_QUALIFIED_CLASS_PREFIX + className.replace('.', '/') + Values.SIG_QUALIFIED_CLASS_SUFFIX_CHAR;
        }
    }
982250
private boolean isJavaSystemClassName(String className) {
        if (className == null) {
            return false;
        }

        if (className.startsWith("java/") || className.startsWith("javax/")) {
            return true;
        }
        return false;
    }
205613
static Class getClassForName(String className)
      throws ClassNotFoundException
  {
    // Hack for backwards compatibility with XalanJ1 stylesheets
    if(className.equals("org.apache.xalan.xslt.extensions.Redirect")) {
      className = "org.apache.xalan.lib.Redirect";
    }

    return ObjectFactory.findProviderClass(
        className, ObjectFactory.findClassLoader(), true);
  }
640395
private static String getSimpleClassName(final String fullyQualifiedClassName) {
		int dotIndex = fullyQualifiedClassName.lastIndexOf('.');
		if (dotIndex < 0) {
			return fullyQualifiedClassName;
		} else {
			return fullyQualifiedClassName.substring(dotIndex + 1);
		}
	}
241832
public static boolean isClassPresent(String classname) {
		try {
			Class.forName(classname);
			return true;
		} catch (ClassNotFoundException e) {

		}
		return false;
	}
1125377
public Class<?> getClassByName(String name) throws ClassNotFoundException {
		Class<?> ret = getClassByNameOrNull(name);
		if (ret == null) {
			throw new ClassNotFoundException("Class " + name + " not found");
		}
		return ret;
	}
1112393
public static String determineReadableClassName(String qualifiedName) {

        String readableClassName = StringUtils.removeWhitespace(qualifiedName);
        if (readableClassName == null) {

            throw new IllegalArgumentException("qualifiedName must not be null.");
        } else if (readableClassName.startsWith("[")) {

            StringBuilder classNameBuffer = new StringBuilder();
            while (readableClassName.startsWith("[")) {
                classNameBuffer.append("[]");
                readableClassName = readableClassName.substring(1);
            }
            
            if (PRIMITIVE_MAPPING.containsValue(readableClassName)) {
                
                for (Map.Entry<String,String> next : PRIMITIVE_MAPPING.entrySet()) {
                    if (next.getValue().equals(readableClassName)) {
                        readableClassName = next.getKey() + classNameBuffer.toString();
                        break;
                    }
                }
                
            } else if (readableClassName.startsWith("L") && readableClassName.endsWith(";")) {
                readableClassName = readableClassName.substring(1, readableClassName.length() - 1) + classNameBuffer.toString();
            } else {
                throw new IllegalArgumentException("qualifiedName was invalid {" + readableClassName + "}");                
            }
        } else if (readableClassName.endsWith("]")) {
            throw new IllegalArgumentException("qualifiedName was invalid {" + readableClassName + "}");
        }
        
        return readableClassName;
    }
861664
private String getType(final WComponent component) {
		for (Class<?> clazz = component.getClass(); clazz != null && WComponent.class.
				isAssignableFrom(clazz); clazz = clazz.getSuperclass()) {
			if ("com.github.bordertech.wcomponents".equals(clazz.getPackage().getName())) {
				return clazz.getName();
			}
		}

		return null;
	}
185661
private String resolveDocByClass(String className) {
        String urlBase = doc.getProperty(className);
        if(urlBase != null) {
            return urlBase + className.replace(".", "/")+".html";
        }
        return null;
    }