extensionimpl.java

java插件系统源码

        /**
         * @see org.java.plugin.registry.Extension.Parameter#getDefinition()
         */
        public ParameterDefinition getDefinition() {
            if (definitionDetected) {
                return definition;
            }
            definitionDetected = true;
            if (log.isDebugEnabled()) {
                log.debug("detecting definition for parameter " + this); //$NON-NLS-1$
            }
            Collection definitions;
            if (superParameter != null) {
                if (superParameter.getDefinition() == null) {
                    return null;
                }
                if (ParameterDefinition.TYPE_ANY.equals(
                            superParameter.getDefinition().getType())) {
                    definition = superParameter.getDefinition();
                    if (log.isDebugEnabled()) {
                        log.debug("definition detected - " + definition); //$NON-NLS-1$
                    }
                    return definition;
                }
                definitions =
                    superParameter.getDefinition().getSubDefinitions();
            } else {
                definitions = getExtensionPoint(
                            getDeclaringExtension().getExtendedPluginId(),
                            getDeclaringExtension().getExtendedPointId()).
                                getParameterDefinitions();
            }
            for (Iterator it = definitions.iterator(); it.hasNext();) {
                ParameterDefinition def = (ParameterDefinition) it.next();
                if (def.getId().equals(getId())) {
                    definition = def;
                    break;
                }
            }
            if (log.isDebugEnabled()) {
                log.debug("definition detected - " + definition); //$NON-NLS-1$
            }
            return definition;
        }

        /**
         * @see org.java.plugin.registry.Extension.Parameter#getSuperParameter()
         */
        public Parameter getSuperParameter() {
            return superParameter;
        }
        
        /**
         * @see org.java.plugin.registry.Extension.Parameter#getSubParameters()
         */
        public Collection getSubParameters() {
            return subParameters;
        }
        
        /**
         * @see org.java.plugin.registry.Extension.Parameter#getSubParameter(
         *      java.lang.String)
         */
        public Parameter getSubParameter(final String id) {
            ParameterImpl result = null;
            for (Iterator it = subParameters.iterator(); it.hasNext();) {
                ParameterImpl param = (ParameterImpl) it.next();
                if (param.getId().equals(id)) {
                    if (result == null) {
                        result = param;
                    } else {
                        throw new IllegalArgumentException(
                            "more than one parameter with ID " + id //$NON-NLS-1$
                            + " defined in extension " + getUniqueId()); //$NON-NLS-1$
                    }
                }
            }
            return result;
        }

        /**
         * @see org.java.plugin.registry.Extension.Parameter#getSubParameters(
         *      java.lang.String)
         */
        public Collection getSubParameters(final String id) {
            List result = new LinkedList();
            for (Iterator it = subParameters.iterator(); it.hasNext();) {
                ParameterImpl param = (ParameterImpl) it.next();
                if (param.getId().equals(id)) {
                    result.add(param);
                }
            }
            return Collections.unmodifiableList(result);
        }

        /**
         * @see org.java.plugin.registry.Extension.Parameter#rawValue()
         */
        public String rawValue() {
            return (modelParam.getValue() != null) ? modelParam.getValue() : ""; //$NON-NLS-1$
        }
        
        boolean isValid() {
            if (valueParser != null) {
                return valueParser.isParsingSucceeds();
            }
            if (log.isDebugEnabled()) {
                log.debug("validating parameter " + this); //$NON-NLS-1$
            }
            valueParser = new ParameterValueParser(
                    getDeclaringPluginDescriptor().getRegistry(),
                    getDefinition(), modelParam.getValue());
            if (!valueParser.isParsingSucceeds()) {
                log.warn("parsing value for parameter " + this //$NON-NLS-1$
                        + " failed, message is: " //$NON-NLS-1$
                        + valueParser.getParsingMessage());
            }
            return valueParser.isParsingSucceeds();
        }
        
        /**
         * @see org.java.plugin.registry.Extension.Parameter#valueAsBoolean()
         */
        public Boolean valueAsBoolean() {
            if (!isValid()) {
                throw new UnsupportedOperationException(
                        "parameter value is invalid"); //$NON-NLS-1$
            }
            if (!ParameterDefinition.TYPE_BOOLEAN.equals(
                    definition.getType())) {
                throw new UnsupportedOperationException("parameter type is not " //$NON-NLS-1$
                        + ParameterDefinition.TYPE_BOOLEAN);
            }
            if (valueParser.getValue() == null) {
                return (Boolean) ((ParameterDefinitionImpl) getDefinition())
                .getValueParser().getValue();
            }
            return (Boolean) valueParser.getValue();
        }
        
        /**
         * @see org.java.plugin.registry.Extension.Parameter#valueAsDate()
         */
        public Date valueAsDate() {
            if (!isValid()) {
                throw new UnsupportedOperationException(
                        "parameter value is invalid"); //$NON-NLS-1$
            }
            if (!ParameterDefinition.TYPE_DATE.equals(definition.getType())
                    && !ParameterDefinition.TYPE_DATETIME.equals(
                            definition.getType())
                    && !ParameterDefinition.TYPE_TIME.equals(
                            definition.getType())) {
                throw new UnsupportedOperationException("parameter type is not " //$NON-NLS-1$
                        + ParameterDefinition.TYPE_DATE + " nor " //$NON-NLS-1$
                        + ParameterDefinition.TYPE_DATETIME + " nor" //$NON-NLS-1$
                        + ParameterDefinition.TYPE_TIME);
            }
            if (valueParser.getValue() == null) {
                return (Date) ((ParameterDefinitionImpl) getDefinition())
                .getValueParser().getValue();
            }
            return (Date) valueParser.getValue();
        }
        
        /**
         * @see org.java.plugin.registry.Extension.Parameter#valueAsNumber()
         */
        public Number valueAsNumber() {
            if (!isValid()) {
                throw new UnsupportedOperationException(
                        "parameter value is invalid"); //$NON-NLS-1$
            }
            if (!ParameterDefinition.TYPE_NUMBER.equals(definition.getType())) {
                throw new UnsupportedOperationException("parameter type is not " //$NON-NLS-1$
                        + ParameterDefinition.TYPE_NUMBER);
            }
            if (valueParser.getValue() == null) {
                return (Number) ((ParameterDefinitionImpl) getDefinition())
                .getValueParser().getValue();
            }
            return (Number) valueParser.getValue();
        }
        
        /**
         * @see org.java.plugin.registry.Extension.Parameter#valueAsString()
         */
        public String valueAsString() {
            if (!isValid()) {
                throw new UnsupportedOperationException(
                        "parameter value is invalid"); //$NON-NLS-1$
            }
            if (!ParameterDefinition.TYPE_STRING.equals(definition.getType())
                    && !ParameterDefinition.TYPE_FIXED.equals(
                            definition.getType())) {
                throw new UnsupportedOperationException("parameter type is not " //$NON-NLS-1$
                        + ParameterDefinition.TYPE_STRING);
            }
            if (valueParser.getValue() == null) {
                return (String) ((ParameterDefinitionImpl) getDefinition())
                .getValueParser().getValue();
            }
            return (String) valueParser.getValue();
        }

        /**
         * @see org.java.plugin.registry.Extension.Parameter#valueAsExtension()
         */
        public Extension valueAsExtension() {
            if (!isValid()) {
                throw new UnsupportedOperationException(
                        "parameter value is invalid"); //$NON-NLS-1$
            }
            if (!ParameterDefinition.TYPE_EXTENSION_ID.equals(
                    definition.getType())) {
                throw new UnsupportedOperationException(
                        "parameter type is not " //$NON-NLS-1$
                        + ParameterDefinition.TYPE_EXTENSION_ID);
            }
            if (valueParser.getValue() == null) {
                return (Extension) ((ParameterDefinitionImpl) getDefinition())
                .getValueParser().getValue();
            }
            return (Extension) valueParser.getValue();
        }
        
        /**
         * @see org.java.plugin.registry.Extension.Parameter#valueAsExtensionPoint()
         */
        public ExtensionPoint valueAsExtensionPoint() {
            if (!isValid()) {
                throw new UnsupportedOperationException(
                        "parameter value is invalid"); //$NON-NLS-1$
            }
            if (!ParameterDefinition.TYPE_EXTENSION_POINT_ID.equals(
                    definition.getType())) {
                throw new UnsupportedOperationException(
                        "parameter type is not " //$NON-NLS-1$
                        + ParameterDefinition.TYPE_EXTENSION_POINT_ID);
            }
            if (valueParser.getValue() == null) {
                return (ExtensionPoint) ((ParameterDefinitionImpl) getDefinition())
                .getValueParser().getValue();
            }
            return (ExtensionPoint) valueParser.getValue();
        }
        
        /**
         * @see org.java.plugin.registry.Extension.Parameter#valueAsPluginDescriptor()
         */
        public PluginDescriptor valueAsPluginDescriptor() {
            if (!isValid()) {
                throw new UnsupportedOperationException(
                        "parameter value is invalid"); //$NON-NLS-1$
            }
            if (!ParameterDefinition.TYPE_PLUGIN_ID.equals(
                    definition.getType())) {
                throw new UnsupportedOperationException("parameter type is not " //$NON-NLS-1$
                        + ParameterDefinition.TYPE_PLUGIN_ID);
            }
            if (valueParser.getValue() == null) {
                return (PluginDescriptor) ((ParameterDefinitionImpl) getDefinition())
                .getValueParser().getValue();
            }
            return (PluginDescriptor) valueParser.getValue();
        }
        
        /**
         * @see org.java.plugin.registry.Extension.Parameter#valueAsUrl()
         */
        public URL valueAsUrl() {
            return valueAsUrl(null);
        }

        /**
         * @see org.java.plugin.registry.Extension.Parameter#valueAsUrl(
         *      org.java.plugin.PathResolver)
         */
        public URL valueAsUrl(final PathResolver pathResolver) {
            if (!isValid()) {
                throw new UnsupportedOperationException(
                        "parameter value is invalid"); //$NON-NLS-1$
            }
            if (!ParameterDefinition.TYPE_RESOURCE.equals(
                    definition.getType())) {
                throw new UnsupportedOperationException(
                        "parameter type is not " //$NON-NLS-1$
                        + ParameterDefinition.TYPE_RESOURCE);
            }
            if ((valueParser.getValue() == null) && (rawValue() == null)) {
                return valueAsUrl(pathResolver,
                        getDefinition().getDeclaringExtensionPoint(),
                        (URL) ((ParameterDefinitionImpl) getDefinition())
                        .getValueParser().getValue(),
                        getDefinition().getDefaultValue());
            }
            return valueAsUrl(pathResolver, getDeclaringPluginDescriptor(),
                    (URL) valueParser.getValue(), rawValue());
        }
        
        private URL valueAsUrl(final PathResolver pathResolver,
                final Identity idt, final URL absoluteUrl,
                final String relativeUrl) {
            if ((pathResolver == null) || (absoluteUrl != null)) {
                return absoluteUrl;
            }
            if (relativeUrl == null) {
                return null;
            }
            return pathResolver.resolvePath(idt, relativeUrl);
        }
        
        /**
         * @see java.lang.Object#toString()
         */
        public String toString() {
            return "{PluginExtension.Parameter: extUid=" //$NON-NLS-1$
                + getDeclaringExtension().getUniqueId() + "; id=" + getId() //$NON-NLS-1$
                + "}"; //$NON-NLS-1$
        }
        
        /**
         * @see org.java.plugin.registry.xml.IdentityImpl#isEqualTo(
         *      org.java.plugin.registry.Identity)
         */
        protected boolean isEqualTo(final Identity idt) {
            if (!super.isEqualTo(idt)) {
                return false;
            }
            ParameterImpl other = (ParameterImpl) idt;
            if ((getSuperParameter() == null)
                    && (other.getSuperParameter() == null)) {
                return true;
            }
            if ((getSuperParameter() == null)
                    || (other.getSuperParameter() == null)) {
                return false;
            }
            return getSuperParameter().equals(other.getSuperParameter());
        }
    }
}