org.castor.xml.AbstractInternalContext Maven / Gradle / Ivy

/*
 * Copyright 2007 Joachim Grueneis
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */
package org.castor.xml;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.io.IOException;
import java.io.OutputStream;
import java.io.Writer;

import javax.inject.Inject;
import javax.xml.parsers.SAXParser;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.castor.core.util.Messages;
import org.castor.mapping.BindingType;
import org.castor.mapping.MappingUnmarshaller;
import org.exolab.castor.mapping.Mapping;
import org.exolab.castor.mapping.MappingException;
import org.exolab.castor.mapping.MappingLoader;
import org.exolab.castor.util.RegExpEvaluator;
import org.exolab.castor.xml.AbstractXMLNaming;
import org.exolab.castor.xml.Introspector;
import org.exolab.castor.xml.NodeType;
import org.exolab.castor.xml.OutputFormat;
import org.exolab.castor.xml.ResolverException;
import org.exolab.castor.xml.Serializer;
import org.exolab.castor.xml.XMLClassDescriptor;
import org.exolab.castor.xml.XMLClassDescriptorResolver;
import org.exolab.castor.xml.XMLContext;
import org.exolab.castor.xml.XMLSerializerFactory;
import org.exolab.castor.xml.util.DefaultNaming;
import org.exolab.castor.xml.util.ResolverStrategy;
import org.exolab.castor.xml.util.XMLParserUtils;
import org.xml.sax.DocumentHandler;
import org.xml.sax.Parser;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;

/**
 * The internal context is meant as center piece providing (and keeping) all information that is
 * required by Marshaller, Unmarshaller, SourceGenerator, MappingTool, SchemaReader and
 * SchemaWriter. It is created, filled with initial data and put into all other parts of Castor by
 * {@link XMLContext}. It is NOT meant to be directly instantiated by user implementations! For all
 * other objects it provides access to Castor state information (e.g. known descriptors) and
 * configuration values.
 * 
 * @author Joachim Grueneis
 * @since 1.1.2
 */
public abstract class AbstractInternalContext implements InternalContext {

  private static final Log LOG = LogFactory.getFactory().getInstance(AbstractInternalContext.class);

  private final PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(this);

  /**
   * The properties to use internally to provide parser, serializer, ...
   */
  private org.castor.core.util.AbstractProperties _properties;

  /**
   * {@link XMLClassDescriptorResolver} instance used for caching XML-related class descriptors.
   */
  private XMLClassDescriptorResolver _xmlClassDescriptorResolver;

  /**
   * The XMLContext knows the one {@link Introspector} to be used.
   */
  private Introspector _introspector;

  /**
   * The {@link XMLClassDescriptor} resolver strategy to use.
   */
  private ResolverStrategy _resolverStrategy;

  /**
   * The {@link MappingLoader} to use.
   */
  private MappingLoader _mappingLoader;

  /**
   * The {@link AbstractXMLNaming} to be used.
   */
  private XMLNaming _xmlNaming;

  /**
   * The {@link JavaNaming} to be used.
   */
  @Inject
  private JavaNaming _javaNaming;

  /**
   * The {@link ClassLoader} to use.
   */
  private ClassLoader _classLoader;

  /**
   * The {@link NodeType} to use for primitives.
   */
  private NodeType _primitiveNodeType;

  /**
   * The {@link RegExpevaluator} to use.
   */
  private RegExpEvaluator _regExpEvaluator;

  public AbstractInternalContext() {
    _properties = XMLProperties.newInstance();
    // TODO[WG]: remove once injection works
    _javaNaming = new JavaNamingImpl(this);
  }

  @Override
  public void addMapping(final Mapping mapping) throws MappingException {
    MappingUnmarshaller mappingUnmarshaller = new MappingUnmarshaller();
    MappingLoader mappingLoader = mappingUnmarshaller.getMappingLoader(mapping, BindingType.XML);
    _xmlClassDescriptorResolver.setMappingLoader(mappingLoader);
  }

  @Override
  public void addClass(final Class clazz) throws ResolverException {
    _xmlClassDescriptorResolver.addClass(clazz);
  }

  @Override
  public void addClasses(final Class[] clazzes) throws ResolverException {
    _xmlClassDescriptorResolver.addClasses(clazzes);
  }

  @Override
  public void addPackage(final String packageName) throws ResolverException {
    _xmlClassDescriptorResolver.addPackage(packageName);
  }

  @Override
  public void addPackages(final String[] packageNames) throws ResolverException {
    _xmlClassDescriptorResolver.addPackages(packageNames);
  }

  @Override
  public void setResolver(final XMLClassDescriptorResolver xmlClassDescriptorResolver) {
    this._xmlClassDescriptorResolver = xmlClassDescriptorResolver;
  }

  @Override
  public void setProperty(final String propertyName, final Object value) {
    // resetting all values that are only reinitialized if null
    if (propertyName == null) {
      IllegalArgumentException iae = new IllegalArgumentException(
          "setProperty must not be called with a propertyName == null");
      LOG.warn(iae.getMessage());
      throw iae;
    }
    if (propertyName.equals(XMLProperties.XML_NAMING)) {
      if (value instanceof String) {
        setXMLNaming((String) value);
      } else if (value instanceof XMLNaming) {
        setXMLNaming((XMLNaming) value);
      } else {
        IllegalArgumentException iae = new IllegalArgumentException(
            "XML Naming can only be set to a String or an implementation of XMLNaming");
        LOG.warn(iae.getMessage());
        throw iae;
      }
    }
    if (propertyName.equals(XMLProperties.JAVA_NAMING)) {
      if (value instanceof String) {
        setJavaNaming((String) value);
      } else if (value instanceof JavaNaming) {
        setJavaNaming((JavaNaming) value);
      } else {
        IllegalArgumentException iae = new IllegalArgumentException(
            "Java Naming can only be set to a String or an implementation of JavaNaming");
        LOG.warn(iae.getMessage());
        throw iae;
      }
    }
    _primitiveNodeType = null;
    _regExpEvaluator = null;

    // now writing the new property
    this.setPropertyInternal(propertyName, value);
  }

  @Override
  public Object getProperty(final String propertyName) {
    return _properties.getObject(propertyName);
  }

  @Override
  public XMLNaming getXMLNaming() {
    if (_xmlNaming != null) {
      return _xmlNaming;
    }

    String prop = _properties.getString(XMLProperties.XML_NAMING, null);
    setXMLNaming(prop);
    return _xmlNaming;
  }

  /**
   * @deprecated Makes no sence!
   */
  @Override
  public XMLNaming getXMLNaming(final ClassLoader classLoader) {
    return getXMLNaming();
  } // -- getXMLNaming

  @Override
  public JavaNaming getJavaNaming() {
    return _javaNaming;
  }

  @Override
  public Parser getParser() {
    return getParser(null);
  }

  @Override
  public Parser getParser(final String features) {
    return XMLParserUtils.getParser(_properties, features);
  }

  @Override
  public XMLReader getXMLReader() {
    return getXMLReader(null);
  }

  @Override
  public XMLReader getXMLReader(final String features) {
    XMLReader reader = null;
    Boolean validation = _properties.getBoolean(XMLProperties.PARSER_VALIDATION);
    Boolean namespaces = _properties.getBoolean(XMLProperties.NAMESPACES);

    String readerClassName = _properties.getString(XMLProperties.PARSER);

    if (readerClassName == null || readerClassName.length() == 0) {
      SAXParser saxParser =
          XMLParserUtils.getSAXParser(validation.booleanValue(), namespaces.booleanValue());
      if (saxParser != null) {
        try {
          reader = saxParser.getXMLReader();
        } catch (SAXException e) {
          LOG.error(Messages.format("conf.configurationError", e));
        }
      }
    }

    if (reader == null) {
      if ((readerClassName == null) || (readerClassName.length() == 0)
          || (readerClassName.equalsIgnoreCase("xerces"))) {
        readerClassName = "org.apache.xerces.parsers.SAXParser";
      }

      reader = XMLParserUtils.instantiateXMLReader(readerClassName);
    }

    XMLParserUtils.setFeaturesOnXmlReader(
        _properties.getString(XMLProperties.PARSER_FEATURES, features),
        _properties.getString(XMLProperties.PARSER_FEATURES_DISABLED, ""),
        validation.booleanValue(), namespaces.booleanValue(), reader);

    return reader;

  }

  @Override
  public NodeType getPrimitiveNodeType() {

    if (_primitiveNodeType != null) {
      return _primitiveNodeType;
    }

    String prop = _properties.getString(XMLProperties.PRIMITIVE_NODE_TYPE, null);
    if (prop == null) {
      return null;
    }
    _primitiveNodeType = NodeType.getNodeType(prop);
    return _primitiveNodeType;
  }

  @Override
  public RegExpEvaluator getRegExpEvaluator() {
    if (_regExpEvaluator != null) {
      return _regExpEvaluator;
    }

    String className = _properties.getString(XMLProperties.REG_EXP_CLASS_NAME, "");
    if (className.length() == 0) {
      _regExpEvaluator = null;
    } else {
      try {
        Class regExpEvalClass = Class.forName(className);
        _regExpEvaluator = (RegExpEvaluator) regExpEvalClass.newInstance();
      } catch (ClassNotFoundException e) {
        throw new RuntimeException(Messages.format("conf.failedInstantiateRegExp", className, e));
      } catch (InstantiationException e) {
        throw new RuntimeException(Messages.format("conf.failedInstantiateRegExp", className, e));
      } catch (IllegalAccessException e) {
        throw new RuntimeException(Messages.format("conf.failedInstantiateRegExp", className, e));
      }
    }
    return _regExpEvaluator;
  }

  @Override
  public Serializer getSerializer() {
    return XMLParserUtils.getSerializer(_properties);
  }

  @Override
  public OutputFormat getOutputFormat() {
    return XMLParserUtils.getOutputFormat(_properties);
  }

  /**
   * Returns the currently configured XMLSerializerFactory instance.
   * 
   * @param serializerFactoryName the class name of the serializer factory
   * @return XMLSerializerFactory to use by Castor
   */
  protected XMLSerializerFactory getSerializerFactory(final String serializerFactoryName) {
    return XMLParserUtils.getSerializerFactory(serializerFactoryName);
  }

  @Override
  public DocumentHandler getSerializer(final OutputStream output) throws IOException {
    Serializer serializer;
    DocumentHandler docHandler;

    serializer = getSerializer();
    serializer.setOutputByteStream(output);
    docHandler = serializer.asDocumentHandler();
    if (docHandler == null) {
      throw new RuntimeException(
          Messages.format("conf.serializerNotSaxCapable", serializer.getClass().getName()));
    }
    return docHandler;
  }

  @Override
  public DocumentHandler getSerializer(final Writer output) throws IOException {
    Serializer serializer;
    DocumentHandler docHandler;

    serializer = getSerializer();
    serializer.setOutputCharStream(output);
    docHandler = serializer.asDocumentHandler();
    if (docHandler == null) {
      throw new RuntimeException(
          Messages.format("conf.serializerNotSaxCapable", serializer.getClass().getName()));
    }
    return docHandler;
  }

  @Override
  public XMLClassDescriptorResolver getXMLClassDescriptorResolver() {
    return _xmlClassDescriptorResolver;
  }

  @Override
  public Introspector getIntrospector() {
    return _introspector;
  }

  @Override
  public ResolverStrategy getResolverStrategy() {
    return _resolverStrategy;
  }

  @Override
  public void setResolverStrategy(final ResolverStrategy resolverStrategy) {
    _resolverStrategy = resolverStrategy;
  }

  @Override
  public void setMappingLoader(final MappingLoader mappingLoader) {
    _mappingLoader = mappingLoader;
  }

  @Override
  public MappingLoader getMappingLoader() {
    return _mappingLoader;
  }

  @Override
  public void setJavaNaming(final JavaNaming javaNaming) {
    _javaNaming = javaNaming;
  }

  public void setJavaNaming(final String javaNamingProperty) {
    if (javaNamingProperty == null || javaNamingProperty.length() == 0) {
      _javaNaming = new JavaNamingImpl(this);
    } else {
      try {
        Class cls = (Class) Class.forName(javaNamingProperty);
        _javaNaming = cls.newInstance();
      } catch (Exception e) {
        IllegalArgumentException iae =
            new IllegalArgumentException("Failed to load JavaNaming: " + e);
        LOG.warn(iae.getMessage());
        throw iae;
      }
    }
  }

  @Override
  public void setXMLNaming(final XMLNaming xmlNaming) {
    _xmlNaming = xmlNaming;
    // propagate to e.g. Introspector also!!
    if (_introspector != null) {
      _introspector.setNaming(_xmlNaming);
    }
  }

  /**
   * This XMLNaming setter is meant to be used when working in property style instead of setting an
   * XMLNaming implementation.
   * 
   * @param xmlNamingProperty to set the XMLNaming property as read from configuration
   */
  public void setXMLNaming(final String xmlNamingProperty) {
    if ((xmlNamingProperty == null) || (xmlNamingProperty.equalsIgnoreCase("lower"))) {
      setXMLNaming(new DefaultNaming());
    } else if (xmlNamingProperty.equalsIgnoreCase("mixed")) {
      DefaultNaming dn = new DefaultNaming();
      dn.setStyle(DefaultNaming.MIXED_CASE_STYLE);
      setXMLNaming(dn);
    } else {
      try {
        Class cls = (Class) Class.forName(xmlNamingProperty);
        setXMLNaming(cls.newInstance());
      } catch (Exception e) {
        IllegalArgumentException iae =
            new IllegalArgumentException("Failed to load XMLNaming: " + e);
        LOG.warn(iae.getMessage());
        throw iae;
      }
    }
    if (_xmlNaming == null) {
      IllegalArgumentException iae = new IllegalArgumentException(
          "Failed to correctly set XMLNaming; property was: " + xmlNamingProperty);
      LOG.warn(iae.getMessage());
      throw iae;
    }
  }

  @Override
  public void setProperty(final String propertyName, final boolean value) {
    this.setPropertyInternal(propertyName, Boolean.valueOf(value));
  }

  private void setPropertyInternal(final String propertyName, final Object value) {
    Object oldValue = this._properties.getObject(propertyName);

    if (oldValue == null) {
      if (value != null) {
        this._properties.put(propertyName, value);
        this.propertyChangeSupport.firePropertyChange(propertyName, oldValue, value);
      }
    } else {
      if (!oldValue.equals(value)) {
        this._properties.put(propertyName, value);
        this.propertyChangeSupport.firePropertyChange(propertyName, oldValue, value);
      }
    }
  }

  @Override
  public Boolean getBooleanProperty(final String propertyName) {
    return _properties.getBoolean(propertyName);
  }

  @Override
  public String getStringProperty(final String propertyName) {
    return _properties.getString(propertyName);
  }

  @Override
  public void setClassLoader(final ClassLoader classLoader) {
    _classLoader = classLoader;
    if (_xmlClassDescriptorResolver != null) {
      _xmlClassDescriptorResolver.setClassLoader(classLoader);
    }
  }

  @Override
  public void setXMLClassDescriptorResolver(
      final XMLClassDescriptorResolver xmlClassDescriptorResolver) {
    _xmlClassDescriptorResolver = xmlClassDescriptorResolver;
  }

  @Override
  public void setIntrospector(final Introspector introspector) {
    _introspector = introspector;
  }

  @Override
  public ClassLoader getClassLoader() {
    return _classLoader;
  }

  @Override
  public boolean getLenientIdValidation() {
    Boolean lenientIdValidation = _properties.getBoolean(XMLProperties.LENIENT_ID_VALIDATION);
    if (lenientIdValidation == null) {
      String message = "Property lenientIdValidation must not be null";
      LOG.warn(message);
      throw new IllegalStateException(message);
    }
    return lenientIdValidation.booleanValue();
  }

  @Override
  public boolean getLenientSequenceOrder() {
    Boolean lenientSequenceOrder = _properties.getBoolean(XMLProperties.LENIENT_SEQUENCE_ORDER);
    if (lenientSequenceOrder == null) {
      String message = "Property lenientSequenceOrder must not be null";
      LOG.warn(message);
      throw new IllegalStateException(message);
    }
    return lenientSequenceOrder.booleanValue();
  }

  @Override
  public Boolean getLoadPackageMapping() {
    return _properties.getBoolean(XMLProperties.LOAD_PACKAGE_MAPPING);
  }

  @Override
  public void setLoadPackageMapping(final Boolean loadPackageMapping) {
    _properties.put(XMLProperties.LOAD_PACKAGE_MAPPING, loadPackageMapping);
  }

  @Override
  public Boolean getUseIntrospector() {
    return _properties.getBoolean(XMLProperties.USE_INTROSPECTION);
  }

  @Override
  public void setUseIntrospector(final Boolean useIntrospector) {
    _properties.put(XMLProperties.USE_INTROSPECTION, useIntrospector);
  }

  @Override
  public boolean marshallingValidation() {
    Boolean marshallingValidation = _properties.getBoolean(XMLProperties.MARSHALLING_VALIDATION);
    if (marshallingValidation == null) {
      String message = "Property marshallingValidation must not be null";
      LOG.warn(message);
      throw new IllegalStateException(message);
    }
    return marshallingValidation.booleanValue();
  }

  @Override
  public boolean strictElements() {
    Boolean strictElements = _properties.getBoolean(XMLProperties.STRICT_ELEMENTS);
    if (strictElements == null) {
      String message = "Property strictElements must not be null";
      LOG.warn(message);
      throw new IllegalStateException(message);
    }
    return strictElements.booleanValue();
  }

  @Override
  public void addPropertyChangeListener(PropertyChangeListener listener) {
    this.propertyChangeSupport.addPropertyChangeListener(listener);
  }

  @Override
  public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
    this.propertyChangeSupport.addPropertyChangeListener(propertyName, listener);
  }

  @Override
  public void removePropertyChangeListener(PropertyChangeListener listener) {
    this.propertyChangeSupport.removePropertyChangeListener(listener);
  }

  @Override
  public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
    this.propertyChangeSupport.removePropertyChangeListener(propertyName, listener);
  }
}