public boolean contains(String fullJavaName) 
{
        return _xbeanSet.contains(fullJavaName);
}

 public static String emitType(JClass cls) 
{
        if (cls.isArrayType())
            return emitType(cls.getArrayComponentType()) + "[]";
        else
            return cls.getQualifiedName().replace('$', '.');
}

 public String getInterface() 
{
        return _interfaceClassName;
}

 static JMethod getMethod(JClass cls,
    String name,
    JClass[] paramTypes) 
{
        JMethod[] methods = cls.getMethods();
        for (int i = 0; i <  methods.length; i++)
        {
            JMethod method = methods[i];
            if (!name.equals(method.getSimpleName()))
                continue;
            JParameter[] mParams = method.getParameters();
            // can have methods with same name but different # of params
            if (mParams.length != paramTypes.length)
                continue;
            for (int j = 0; j <  mParams.length; j++)
            {
                JParameter mParam = mParams[j];
                if (!mParam.getType().equals(paramTypes[j]))
                    continue;
            }
            return method;
        }
        return null;
}

 public MethodSignature[] getMethods() 
{
        return _methods;
}

 public String getStaticHandler() 
{
        return _delegateToClassName;
}

 static InterfaceExtensionImpl newInstance(JamClassLoader loader,
    NameSet xbeanSet,
    Interface intfXO) 
{
        InterfaceExtensionImpl result = new InterfaceExtensionImpl();
        result._xbeanSet = xbeanSet;
        JClass interfaceJClass = validateInterface(loader, intfXO.getName(), intfXO);
        if (interfaceJClass == null)
        {
            BindingConfigImpl.error("Interface '" + intfXO.getStaticHandler() + "' not found.", intfXO);
            return null;
        }
        result._interfaceClassName = interfaceJClass.getQualifiedName();
        result._delegateToClassName = intfXO.getStaticHandler();
        JClass delegateJClass = validateClass(loader, result._delegateToClassName, intfXO);
        if (delegateJClass == null) // no HandlerClass
        {
            BindingConfigImpl.warning("Handler class '" + intfXO.getStaticHandler() + "' not found on classpath, skip validation.", intfXO);
            return result;
        }
        if (!result.validateMethods(interfaceJClass, delegateJClass, intfXO))
            return null;
        return result;
}

 public String toString() 
{
        StringBuffer buf = new StringBuffer();
        buf.append("  static handler: ").append(_delegateToClassName).append("\n");
        buf.append("  interface: ").append(_interfaceClassName).append("\n");
        buf.append("  name set: ").append(_xbeanSet).append("\n");
        for (int i = 0; i <  _methods.length; i++)
            buf.append("  method[").append(i).append("]=").append(_methods[i]).append("\n");
        return buf.toString();
}

 static JClass validateClass(JamClassLoader loader,
    String clsStr,
    XmlObject loc) 
{
        return validateJava(loader, clsStr, false, loc);
}

 static JClass validateJava(JamClassLoader loader,
    String clsStr,
    boolean isInterface,
    XmlObject loc) 
{
        if (loader==null)
            return null;
        final String ent = isInterface ? "Interface" : "Class";
        JClass cls = loader.loadClass(clsStr);
        if (cls==null || cls.isUnresolvedType())
        {
            BindingConfigImpl.error(ent + " '" + clsStr + "' not found.", loc);
            return null;
        }
        if ( (isInterface && !cls.isInterface()) ||
                (!isInterface && cls.isInterface()))
        {
            BindingConfigImpl.error("'" + clsStr + "' must be " +
                (isInterface ? "an interface" : "a class") + ".", loc);
        }
        if (!cls.isPublic())
        {
            BindingConfigImpl.error(ent + " '" + clsStr + "' is not public.", loc);
        }
        return cls;
}