Information

0
Story Points

Technologies

Decompiled Java File
package org.castor.xml;

import java.io.IOException;
import java.io.OutputStream;
import java.io.Writer;
import javax.xml.parsers.SAXParser;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.castor.core.util.AbstractProperties;
import org.castor.core.util.Messages;
import org.castor.mapping.BindingType;
import org.castor.mapping.MappingUnmarshaller;
import org.castor.xml.InternalContext;
import org.castor.xml.JavaNaming;
import org.castor.xml.JavaNamingImpl;
import org.castor.xml.XMLNaming;
import org.castor.xml.XMLProperties;
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.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.XMLClassDescriptorResolver;
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;

public abstract class AbstractInternalContext implements InternalContext {
   private static final Log LOG = LogFactory.getFactory().getInstance(AbstractInternalContext.class);
   private AbstractProperties _properties = XMLProperties.newInstance();
   private XMLClassDescriptorResolver _xmlClassDescriptorResolver;
   private Introspector _introspector;
   private ResolverStrategy _resolverStrategy;
   private MappingLoader _mappingLoader;
   private XMLNaming _xmlNaming;
   private JavaNaming _javaNaming = new JavaNamingImpl();
   private ClassLoader _classLoader;
   private NodeType _primitiveNodeType;
   private RegExpEvaluator _regExpEvaluator;

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

   public void addClass(Class clazz) throws ResolverException {
      this._xmlClassDescriptorResolver.addClass(clazz);
   }

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

   public void addPackage(String packageName) throws ResolverException {
      this._xmlClassDescriptorResolver.addPackage(packageName);
   }

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

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

   public void setProperty(String propertyName, Object value) {
      IllegalArgumentException iae;
      if(propertyName == null) {
         iae = new IllegalArgumentException("setProperty must not be called with a propertyName == null");
         LOG.warn(iae.getMessage());
         throw iae;
      } else {
         if(propertyName.equals("org.exolab.castor.xml.naming")) {
            if(value instanceof String) {
               this.setXMLNaming((String)value);
            } else {
               if(!(value instanceof XMLNaming)) {
                  iae = new IllegalArgumentException("XML Naming can only be set to a String or an implementation of XMLNaming");
                  LOG.warn(iae.getMessage());
                  throw iae;
               }

               this.setXMLNaming((XMLNaming)value);
            }
         }

         if(propertyName.equals("org.castor.xml.java.naming")) {
            if(value instanceof String) {
               this.setJavaNaming((String)value);
            } else {
               if(!(value instanceof JavaNaming)) {
                  iae = new IllegalArgumentException("Java Naming can only be set to a String or an implementation of JavaNaming");
                  LOG.warn(iae.getMessage());
                  throw iae;
               }

               this.setJavaNaming((JavaNaming)value);
            }
         }

         this._primitiveNodeType = null;
         this._regExpEvaluator = null;
         this._properties.put(propertyName, value);
      }
   }

   public Object getProperty(String propertyName) {
      return this._properties.getObject(propertyName);
   }

   public XMLNaming getXMLNaming() {
      if(this._xmlNaming != null) {
         return this._xmlNaming;
      } else {
         String prop = this._properties.getString("org.exolab.castor.xml.naming", (String)null);
         this.setXMLNaming(prop);
         return this._xmlNaming;
      }
   }

   /** @deprecated */
   public XMLNaming getXMLNaming(ClassLoader classLoader) {
      return this.getXMLNaming();
   }

   public JavaNaming getJavaNaming() {
      return this._javaNaming;
   }

   public Parser getParser() {
      return this.getParser((String)null);
   }

   public Parser getParser(String features) {
      return XMLParserUtils.getParser(this._properties, features);
   }

   public XMLReader getXMLReader() {
      return this.getXMLReader((String)null);
   }

   public XMLReader getXMLReader(String features) {
      XMLReader reader = null;
      Boolean validation = this._properties.getBoolean("org.exolab.castor.parser.validation");
      Boolean namespaces = this._properties.getBoolean("org.exolab.castor.parser.namespaces");
      String readerClassName = this._properties.getString("org.exolab.castor.parser");
      if(readerClassName == null || readerClassName.length() == 0) {
         SAXParser saxParser = XMLParserUtils.getSAXParser(validation.booleanValue(), namespaces.booleanValue());
         if(saxParser != null) {
            try {
               reader = saxParser.getXMLReader();
            } catch (SAXException var8) {
               LOG.error(Messages.format("conf.configurationError", var8));
            }
         }
      }

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

         reader = XMLParserUtils.instantiateXMLReader(readerClassName);
      }

      XMLParserUtils.setFeaturesOnXmlReader(this._properties.getString("org.exolab.castor.sax.features", features), this._properties.getString("org.exolab.castor.sax.features-to-disable", ""), validation.booleanValue(), namespaces.booleanValue(), reader);
      return reader;
   }

   public NodeType getPrimitiveNodeType() {
      if(this._primitiveNodeType != null) {
         return this._primitiveNodeType;
      } else {
         String prop = this._properties.getString("org.exolab.castor.xml.introspector.primitive.nodetype", (String)null);
         if(prop == null) {
            return null;
         } else {
            this._primitiveNodeType = NodeType.getNodeType(prop);
            return this._primitiveNodeType;
         }
      }
   }

   public RegExpEvaluator getRegExpEvaluator() {
      if(this._regExpEvaluator != null) {
         return this._regExpEvaluator;
      } else {
         String className = this._properties.getString("org.exolab.castor.regexp", "");
         if(className.length() == 0) {
            this._regExpEvaluator = null;
         } else {
            try {
               Class e = Class.forName(className);
               this._regExpEvaluator = (RegExpEvaluator)e.newInstance();
            } catch (ClassNotFoundException var3) {
               throw new RuntimeException(Messages.format("conf.failedInstantiateRegExp", className, var3));
            } catch (InstantiationException var4) {
               throw new RuntimeException(Messages.format("conf.failedInstantiateRegExp", className, var4));
            } catch (IllegalAccessException var5) {
               throw new RuntimeException(Messages.format("conf.failedInstantiateRegExp", className, var5));
            }
         }

         return this._regExpEvaluator;
      }
   }

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

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

   protected XMLSerializerFactory getSerializerFactory(String serializerFactoryName) {
      return XMLParserUtils.getSerializerFactory(serializerFactoryName);
   }

   public DocumentHandler getSerializer(OutputStream output) throws IOException {
      Serializer serializer = this.getSerializer();
      serializer.setOutputByteStream(output);
      DocumentHandler docHandler = serializer.asDocumentHandler();
      if(docHandler == null) {
         throw new RuntimeException(Messages.format("conf.serializerNotSaxCapable", serializer.getClass().getName()));
      } else {
         return docHandler;
      }
   }

   public DocumentHandler getSerializer(Writer output) throws IOException {
      Serializer serializer = this.getSerializer();
      serializer.setOutputCharStream(output);
      DocumentHandler docHandler = serializer.asDocumentHandler();
      if(docHandler == null) {
         throw new RuntimeException(Messages.format("conf.serializerNotSaxCapable", serializer.getClass().getName()));
      } else {
         return docHandler;
      }
   }

   public XMLClassDescriptorResolver getXMLClassDescriptorResolver() {
      return this._xmlClassDescriptorResolver;
   }

   public Introspector getIntrospector() {
      return this._introspector;
   }

   public ResolverStrategy getResolverStrategy() {
      return this._resolverStrategy;
   }

   public void setResolverStrategy(ResolverStrategy resolverStrategy) {
      this._resolverStrategy = resolverStrategy;
   }

   public void setMappingLoader(MappingLoader mappingLoader) {
      this._mappingLoader = mappingLoader;
   }

   public MappingLoader getMappingLoader() {
      return this._mappingLoader;
   }

   public void setJavaNaming(JavaNaming javaNaming) {
      this._javaNaming = javaNaming;
   }

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

   }

   public void setXMLNaming(XMLNaming xmlNaming) {
      this._xmlNaming = xmlNaming;
      if(this._introspector != null) {
         this._introspector.setNaming(this._xmlNaming);
      }

   }

   public void setXMLNaming(String xmlNamingProperty) {
      if(xmlNamingProperty != null && !xmlNamingProperty.equalsIgnoreCase("lower")) {
         if(xmlNamingProperty.equalsIgnoreCase("mixed")) {
            DefaultNaming iae = new DefaultNaming();
            iae.setStyle(1);
            this.setXMLNaming((XMLNaming)iae);
         } else {
            try {
               Class iae2 = Class.forName(xmlNamingProperty);
               this.setXMLNaming((XMLNaming)iae2.newInstance());
            } catch (Exception var4) {
               IllegalArgumentException iae1 = new IllegalArgumentException("Failed to load XMLNaming: " + var4);
               LOG.warn(iae1.getMessage());
               throw iae1;
            }
         }
      } else {
         this.setXMLNaming((XMLNaming)(new DefaultNaming()));
      }

      if(this._xmlNaming == null) {
         IllegalArgumentException iae3 = new IllegalArgumentException("Failed to correctly set XMLNaming; property was: " + xmlNamingProperty);
         LOG.warn(iae3.getMessage());
         throw iae3;
      }
   }

   public void setProperty(String propertyName, boolean value) {
      this._properties.put(propertyName, Boolean.valueOf(value));
   }

   public Boolean getBooleanProperty(String propertyName) {
      return this._properties.getBoolean(propertyName);
   }

   public String getStringProperty(String propertyName) {
      return this._properties.getString(propertyName);
   }

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

   }

   public void setXMLClassDescriptorResolver(XMLClassDescriptorResolver xmlClassDescriptorResolver) {
      this._xmlClassDescriptorResolver = xmlClassDescriptorResolver;
   }

   public void setIntrospector(Introspector introspector) {
      this._introspector = introspector;
   }

   public ClassLoader getClassLoader() {
      return this._classLoader;
   }

   public boolean getLenientIdValidation() {
      Boolean lenientIdValidation = this._properties.getBoolean("org.exolab.castor.xml.lenient.id.validation");
      if(lenientIdValidation == null) {
         String message = "Property lenientIdValidation must not be null";
         LOG.warn(message);
         throw new IllegalStateException(message);
      } else {
         return lenientIdValidation.booleanValue();
      }
   }

   public boolean getLenientSequenceOrder() {
      Boolean lenientSequenceOrder = this._properties.getBoolean("org.exolab.castor.xml.lenient.sequence.order");
      if(lenientSequenceOrder == null) {
         String message = "Property lenientSequenceOrder must not be null";
         LOG.warn(message);
         throw new IllegalStateException(message);
      } else {
         return lenientSequenceOrder.booleanValue();
      }
   }

   public Boolean getLoadPackageMapping() {
      return this._properties.getBoolean("org.exolab.castor.xml.loadPackageMappings");
   }

   public void setLoadPackageMapping(Boolean loadPackageMapping) {
      this._properties.put("org.exolab.castor.xml.loadPackageMappings", loadPackageMapping);
   }

   public Boolean getUseIntrospector() {
      return this._properties.getBoolean("org.castor.xml.class-resolver.use-introspection");
   }

   public void setUseIntrospector(Boolean useIntrospector) {
      this._properties.put("org.castor.xml.class-resolver.use-introspection", useIntrospector);
   }

   public boolean marshallingValidation() {
      Boolean marshallingValidation = this._properties.getBoolean("org.exolab.castor.marshalling.validation");
      if(marshallingValidation == null) {
         String message = "Property marshallingValidation must not be null";
         LOG.warn(message);
         throw new IllegalStateException(message);
      } else {
         return marshallingValidation.booleanValue();
      }
   }

   public boolean strictElements() {
      Boolean strictElements = this._properties.getBoolean("org.exolab.castor.xml.strictelements");
      if(strictElements == null) {
         String message = "Property strictElements must not be null";
         LOG.warn(message);
         throw new IllegalStateException(message);
      } else {
         return strictElements.booleanValue();
      }
   }
}
Page generated: Oct 19, 2017 2:34:25 PM