void addInterfaceExtension(InterfaceExtensionImpl ext) 
{
        if (ext==null)
            return;
        _interfaceExtensions.add(ext);
}

  void addPrePostExtension(PrePostExtensionImpl ext) 
{
        if (ext==null)
            return;
        _prePostExtensions.add(ext);
}

 static  void error(String s,
    XmlObject xo) 
{
        StscState.get().error(s, XmlError.SEVERITY_ERROR, xo);
}

 public static BindingConfig forConfigDocuments(Config[] configs,
    File[] javaFiles,
    File[] classpath) 
{
        return new BindingConfigImpl(configs, javaFiles, classpath);
}

 public InterfaceExtension[] getInterfaceExtensions() 
{
        return (InterfaceExtension[])_interfaceExtensions.toArray(new InterfaceExtension[_interfaceExtensions.size()]);
}

 public InterfaceExtension[] getInterfaceExtensions(String fullJavaName) 
{
        List result = new ArrayList();
        for (int i = 0; i <  _interfaceExtensions.size(); i++)
        {
            InterfaceExtensionImpl intfExt = (InterfaceExtensionImpl) _interfaceExtensions.get(i);
            if (intfExt.contains(fullJavaName))
                result.add(intfExt);
        }
        return (InterfaceExtension[])result.toArray(new InterfaceExtension[result.size()]);
}

 public PrePostExtension getPrePostExtension(String fullJavaName) 
{
        for (int i = 0; i <  _prePostExtensions.size(); i++)
        {
            PrePostExtensionImpl prePostExt = (PrePostExtensionImpl) _prePostExtensions.get(i);
            if (prePostExt.contains(fullJavaName))
                return prePostExt;
        }
        return null;
}

 public PrePostExtension[] getPrePostExtensions() 
{
        return (PrePostExtension[])_prePostExtensions.toArray(new PrePostExtension[_prePostExtensions.size()]);
}

 public String lookupJavanameForQName(QName qname) 
{
        String result = (String)_qnameTypeMap.get(qname);
        if (result != null)
            return result;
        return (String)_qnameDocTypeMap.get(qname);
}

 public String lookupJavanameForQName(QName qname,
    int kind) 
{
        switch (kind)
        {
        case QNAME_TYPE:
            return (String)_qnameTypeMap.get(qname);
        case QNAME_DOCUMENT_TYPE:
            return (String)_qnameDocTypeMap.get(qname);
        case QNAME_ACCESSOR_ELEMENT:
            return (String)_qnameElemMap.get(qname);
        case QNAME_ACCESSOR_ATTRIBUTE:
            return (String)_qnameAttMap.get(qname);
        }
        return null;
}

 public String lookupPackageForNamespace(String uri) 
{
        return lookup(_packageMap, _packageMapByUriPrefix, uri);
}

 public String lookupPrefixForNamespace(String uri) 
{
        return lookup(_prefixMap, _prefixMapByUriPrefix, uri);
}

 public String lookupSuffixForNamespace(String uri) 
{
        return lookup(_suffixMap, _suffixMapByUriPrefix, uri);
}

  void secondPhaseValidation() 
{
        // validate interface methods collisions
        Map methodSignatures = new HashMap();
        for (int i = 0; i <  _interfaceExtensions.size(); i++)
        {
            InterfaceExtensionImpl interfaceExtension = (InterfaceExtensionImpl) _interfaceExtensions.get(i);
            InterfaceExtensionImpl.MethodSignatureImpl[] methods = (InterfaceExtensionImpl.MethodSignatureImpl[])interfaceExtension.getMethods();
            for (int j = 0; j <  methods.length; j++)
            {
                InterfaceExtensionImpl.MethodSignatureImpl ms = methods[j];
                if (methodSignatures.containsKey(methods[j]))
                {
                    InterfaceExtensionImpl.MethodSignatureImpl ms2 = (InterfaceExtensionImpl.MethodSignatureImpl) methodSignatures.get(methods[j]);
                    if (!ms.getReturnType().equals(ms2.getReturnType()))
                    {
                        BindingConfigImpl.error("Colliding methods '" + ms.getSignature() + "' in interfaces " +
                        ms.getInterfaceName() + " and " + ms2.getInterfaceName() + ".", null);
                    }
                    return;
                }
                // store it into hashmap
                methodSignatures.put(methods[j], methods[j]);
            }
        }
        // validate that PrePostExtension-s do not intersect
        for (int i = 0; i <  _prePostExtensions.size() - 1; i++)
        {
            PrePostExtensionImpl a = (PrePostExtensionImpl) _prePostExtensions.get(i);
            for (int j = 1; j <  _prePostExtensions.size(); j++)
            {
                PrePostExtensionImpl b = (PrePostExtensionImpl) _prePostExtensions.get(j);
                if (a.hasNameSetIntersection(b))
                    BindingConfigImpl.error("The applicable domain for handler '" + a.getHandlerNameForJavaSource() +
                        "' intersects with the one for '" + b.getHandlerNameForJavaSource() + "'.", null);
            }
        }
}

 static  void warning(String s,
    XmlObject xo) 
{
        StscState.get().error(s, XmlError.SEVERITY_WARNING, xo);
}