From b922b0fd81358f74197ca4942cce7dd68abbbb7f Mon Sep 17 00:00:00 2001 From: Willem Cazander Date: Sat, 24 Aug 2013 01:30:48 +0200 Subject: [PATCH] Refactored all property keys with PropertyConfig bean. --- .../src/main/java/org/x4o/xml/X4ODriver.java | 25 +- .../org/x4o/xml/el/X4OExpressionFactory.java | 18 +- .../java/org/x4o/xml/eld/EldModuleLoader.java | 34 +- .../eld/lang/ElementModuleBindingHandler.java | 11 +- .../org/x4o/xml/eld/lang/ModuleElement.java | 10 +- .../x4o/xml/eld/xsd/EldXsdXmlGenerator.java | 31 +- .../org/x4o/xml/element/AbstractElement.java | 8 +- .../xml/element/ElementNamespaceContext.java | 6 - .../org/x4o/xml/io/AbstractX4OConnection.java | 64 ++-- .../org/x4o/xml/io/AbstractX4OReader.java | 14 +- .../x4o/xml/io/AbstractX4OReaderContext.java | 8 +- .../org/x4o/xml/io/AbstractX4OWriter.java | 14 +- .../x4o/xml/io/AbstractX4OWriterContext.java | 9 +- .../java/org/x4o/xml/io/DefaultX4OReader.java | 118 +++++-- .../x4o/xml/io/DefaultX4OSchemaWriter.java | 40 ++- .../java/org/x4o/xml/io/DefaultX4OWriter.java | 283 +++++++++++++++- .../java/org/x4o/xml/io/X4OConnection.java | 18 +- .../org/x4o/xml/io/sax/X4OContentHandler.java | 12 +- .../org/x4o/xml/io/sax/X4OContentParser.java | 141 +++++++- .../org/x4o/xml/io/sax/X4ODebugWriter.java | 5 +- .../org/x4o/xml/io/sax/X4OEntityResolver.java | 15 +- .../org/x4o/xml/io/sax/X4OErrorHandler.java | 7 +- .../xml/io/sax/ext/AbstractContentWriter.java | 4 +- .../sax/ext/AbstractContentWriterHandler.java | 72 ++-- .../sax/ext/AbstractContentWriterLexical.java | 4 +- .../org/x4o/xml/io/sax/ext/ContentConfig.java | 158 --------- .../x4o/xml/io/sax/ext/ContentWriterHtml.java | 6 +- .../x4o/xml/io/sax/ext/ContentWriterXml.java | 26 +- .../xml/io/sax/ext/ContentWriterXmlTag.java | 4 +- .../x4o/xml/io/sax/ext/ContentWriterXsd.java | 4 +- .../x4o/xml/io/sax/ext/PropertyConfig.java | 248 ++++++++++++++ .../AbstractX4OLanguageConfiguration.java | 24 -- .../xml/lang/AbstractX4OLanguageContext.java | 156 ++++----- .../org/x4o/xml/lang/DefaultX4OLanguage.java | 15 +- .../lang/DefaultX4OLanguageConfiguration.java | 109 +----- .../java/org/x4o/xml/lang/X4OLanguage.java | 4 +- .../xml/lang/X4OLanguageConfiguration.java | 35 +- .../lang/X4OLanguageConfigurationLocal.java | 2 - .../org/x4o/xml/lang/X4OLanguageContext.java | 24 +- .../x4o/xml/lang/X4OLanguageContextLocal.java | 16 +- .../org/x4o/xml/lang/X4OLanguageProperty.java | 318 ------------------ .../x4o/xml/lang/X4OLanguagePropertyKeys.java | 99 ------ .../lang/phase/DefaultX4OPhaseManager.java | 74 ++-- .../java/org/x4o/xml/lang/phase/X4OPhase.java | 11 + .../xml/lang/phase/X4OPhaseLanguageRead.java | 100 +----- .../xml/lang/phase/X4OPhaseLanguageWrite.java | 303 ++--------------- .../org/x4o/xml/lang/phase/X4OPhaseType.java | 8 +- .../main/resources/META-INF/eld/eld-lang.eld | 10 +- .../org/x4o/xml/X4ODriverManagerTest.java | 2 +- .../java/org/x4o/xml/core/EmptyXmlTest.java | 2 +- .../org/x4o/xml/core/NamespaceUriTest.java | 11 +- .../org/x4o/xml/core/X4ODebugWriterTest.java | 6 +- .../x4o/xml/core/X4OEntityResolverTest.java | 23 +- .../xml/core/X4OParserConfigurationTest.java | 2 +- .../org/x4o/xml/core/X4OPhaseManagerTest.java | 2 +- .../java/org/x4o/xml/eld/EldParserTest.java | 3 +- .../org/x4o/xml/eld/EldValidatingTest.java | 10 +- .../org/x4o/xml/io/X4OConnectionTest.java | 30 +- .../org/x4o/xml/io/X4OWriterContextTest.java | 2 +- .../lang/DefaultX4OLanguageLoaderTest.java | 2 +- .../x4o/xml/lang/X4OLanguagePropertyTest.java | 10 +- .../java/org/x4o/xml/test/SwingTests.java | 3 +- .../xml/eld/doc/EldDocWriterElementClass.java | 4 +- .../eld/doc/EldDocWriterElementInterface.java | 8 +- .../eld/doc/EldDocWriterElementNamespace.java | 4 +- .../x4o/xml/eld/doc/EldDocWriterLanguage.java | 6 +- .../eld/doc/EldDocWriterLanguageModule.java | 10 +- .../eld/doc/X4OWriteLanguageDocExecutor.java | 2 +- .../xml/eld/doc/api/ApiDocContentWriter.java | 4 +- .../org/x4o/xml/eld/doc/api/ApiDocWriter.java | 38 +-- .../x4o/xml/eld/doc/api/dom/ApiDocNode.java | 23 -- .../xml/eld/doc/api/dom/ApiDocNodeBody.java | 7 +- .../x4o/xml/lang/meta/ParentObjectTest.java | 4 +- .../x4o/xml/lang/meta/ReferenceStoreTest.java | 8 +- 74 files changed, 1252 insertions(+), 1699 deletions(-) delete mode 100644 x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/ContentConfig.java create mode 100644 x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/PropertyConfig.java delete mode 100644 x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageProperty.java delete mode 100644 x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguagePropertyKeys.java diff --git a/x4o-driver/src/main/java/org/x4o/xml/X4ODriver.java b/x4o-driver/src/main/java/org/x4o/xml/X4ODriver.java index fe6fb64..adf8299 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/X4ODriver.java +++ b/x4o-driver/src/main/java/org/x4o/xml/X4ODriver.java @@ -32,7 +32,6 @@ import org.x4o.xml.io.X4OWriter; import org.x4o.xml.io.X4OWriterContext; import org.x4o.xml.lang.X4OLanguageConfiguration; -import org.x4o.xml.lang.X4OLanguageContext; import org.x4o.xml.lang.X4OLanguage; import org.x4o.xml.lang.phase.X4OPhaseManager; @@ -97,7 +96,7 @@ public abstract class X4ODriver { * @return The schema writer for this language. */ public X4OSchemaWriter createSchemaWriter(String version) { - return new DefaultX4OSchemaWriter(createLanguageContext(version)); + return new DefaultX4OSchemaWriter(createLanguage(version)); } @@ -117,7 +116,7 @@ public abstract class X4ODriver { } public X4OReaderContext createReaderContext(String version) { - return new DefaultX4OReader(createLanguageContext(version)); + return new DefaultX4OReader(createLanguage(version)); } @@ -137,7 +136,7 @@ public abstract class X4ODriver { } public X4OWriterContext createWriterContext(String version) { - return new DefaultX4OWriter(createLanguageContext(version)); + return new DefaultX4OWriter(createLanguage(version)); } @@ -162,19 +161,27 @@ public abstract class X4ODriver { } /** + * Creates the X4OLanguage for the default version. + * @return The created X4OLanguage. + */ + final public X4OLanguage createLanguage() { + return buildLanguage(getLanguageVersionDefault()); + } + + /* * Creates the X4OLanguageContext for the default language version. * @return The created X4OLanguageContext. - */ + * final public X4OLanguageContext createLanguageContext() { return createLanguageContext(getLanguageVersionDefault()); } - /** + * * Creates the X4OLanguageContext for the specified version. * @param version The language version to create the context for. * @return The created X4OLanguageContext. - */ + * final public X4OLanguageContext createLanguageContext(String version) { - return createLanguage(version).createLanguageContext(this); - } + return createLanguage(version).createLanguageContext(); + }*/ } diff --git a/x4o-driver/src/main/java/org/x4o/xml/el/X4OExpressionFactory.java b/x4o-driver/src/main/java/org/x4o/xml/el/X4OExpressionFactory.java index 7abb1a6..d83b310 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/el/X4OExpressionFactory.java +++ b/x4o-driver/src/main/java/org/x4o/xml/el/X4OExpressionFactory.java @@ -26,8 +26,6 @@ import javax.el.ELContext; import javax.el.ExpressionFactory; import org.x4o.xml.lang.X4OLanguageClassLoader; -import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguageProperty; /** * X4OExpressionFactory finds and loads the needed impl. @@ -40,11 +38,8 @@ public class X4OExpressionFactory { static public final String EL_FACTORY_IMPL_APACHE = "org.apache.el.ExpressionFactoryImpl"; static public final String EL_FACTORY_IMPL_ODYSSEUS = "de.odysseus.el.ExpressionFactoryImpl"; - static public ExpressionFactory createExpressionFactory(X4OLanguageContext languageContext) { - ExpressionFactory result = (ExpressionFactory)languageContext.getLanguageProperty(X4OLanguageProperty.EL_FACTORY_INSTANCE); - if (result!=null) { - return result; - } + static public ExpressionFactory createExpressionFactory() { + ExpressionFactory result = null; try { Class expressionFactoryClass = X4OLanguageClassLoader.loadClass(EL_FACTORY_IMPL_APACHE); result = (ExpressionFactory) expressionFactoryClass.newInstance(); @@ -59,13 +54,10 @@ public class X4OExpressionFactory { return result; } - static public ELContext createELContext(X4OLanguageContext languageContext) { - ELContext result = (ELContext)languageContext.getLanguageProperty(X4OLanguageProperty.EL_CONTEXT_INSTANCE); - if (result!=null) { - return result; - } + static public ELContext createELContext(Class elContextClass) { + ELContext result = null; try { - result = (ELContext)X4OLanguageClassLoader.newInstance(languageContext.getLanguage().getLanguageConfiguration().getDefaultExpressionLanguageContext()); + result = (ELContext)X4OLanguageClassLoader.newInstance(elContextClass); } catch (Exception e) { throw new RuntimeException("Could not create instance of ELContext: "+e.getMessage(),e); } diff --git a/x4o-driver/src/main/java/org/x4o/xml/eld/EldModuleLoader.java b/x4o-driver/src/main/java/org/x4o/xml/eld/EldModuleLoader.java index 1735faa..41f000f 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/eld/EldModuleLoader.java +++ b/x4o-driver/src/main/java/org/x4o/xml/eld/EldModuleLoader.java @@ -25,11 +25,13 @@ package org.x4o.xml.eld; import java.io.IOException; import java.util.logging.Logger; +import javax.el.ValueExpression; + import org.x4o.xml.X4ODriver; import org.x4o.xml.X4ODriverManager; -import org.x4o.xml.io.DefaultX4OReader; import org.x4o.xml.io.X4OConnectionException; import org.x4o.xml.io.X4OReader; +import org.x4o.xml.lang.X4OLanguage; import org.x4o.xml.lang.X4OLanguageModule; import org.x4o.xml.lang.X4OLanguageContext; import org.x4o.xml.lang.X4OLanguageModuleLoader; @@ -38,7 +40,7 @@ import org.x4o.xml.lang.X4OLanguageLocal; import org.xml.sax.SAXException; /** - * De default X4OElementConfigurator. + * EldModuleLoader loads the child eld language and proxies the parent language into the child so to the parent langauge is configured. * * @author Willem Cazander * @version 1.0 Aug 17, 2005 @@ -49,11 +51,8 @@ public class EldModuleLoader implements X4OLanguageModuleLoader { private String eldResource = null; private boolean isEldCore = false; - /** The EL key to access the parent language configuration. */ - public static final String EL_PARENT_LANGUAGE_CONFIGURATION = "parentLanguageConfiguration"; - /** The EL key to access the parent language module. */ - public static final String EL_PARENT_ELEMENT_LANGUAGE_MODULE = "parentElementLanguageModule"; + public static final String EL_PARENT_LANGUAGE_MODULE = "parentLanguageModule"; /** The EL key to access the parent language element langauge. */ public static final String EL_PARENT_LANGUAGE = "parentLanguage"; @@ -79,11 +78,9 @@ public class EldModuleLoader implements X4OLanguageModuleLoader { * @throws X4OLanguageModuleLoaderException When eld language could not be loaded. * @see org.x4o.xml.lang.X4OLanguageModuleLoader#loadLanguageModule(org.x4o.xml.lang.X4OLanguageLocal, org.x4o.xml.lang.X4OLanguageModule) */ - public void loadLanguageModule(X4OLanguageLocal language,X4OLanguageModule elementLanguageModule) throws X4OLanguageModuleLoaderException { + public void loadLanguageModule(X4OLanguageLocal language,X4OLanguageModule languageModule) throws X4OLanguageModuleLoaderException { logger.fine("Loading name eld file from resource: "+eldResource); try { - //EldDriver parser = new EldDriver(elementLanguage,elementLanguageModule,isEldCore); - X4ODriver driver = null; if (isEldCore) { driver = X4ODriverManager.getX4ODriver(CelDriver.LANGUAGE_NAME); @@ -91,12 +88,13 @@ public class EldModuleLoader implements X4OLanguageModuleLoader { driver = X4ODriverManager.getX4ODriver(EldDriver.LANGUAGE_NAME); } - X4OLanguageContext eldLang = driver.createLanguageContext(driver.getLanguageVersionDefault()); - X4OReader reader = new DefaultX4OReader(eldLang); + X4OReader reader = driver.createReader(); + + //X4OLanguageContext eldLang = driver.createLanguageContext(driver.getLanguageVersionDefault()); + //X4OReader reader = new DefaultX4OReader(eldLang); - reader.addELBeanInstance(EL_PARENT_LANGUAGE_CONFIGURATION, language.getLanguageConfiguration()); reader.addELBeanInstance(EL_PARENT_LANGUAGE, language); - reader.addELBeanInstance(EL_PARENT_ELEMENT_LANGUAGE_MODULE, elementLanguageModule); + reader.addELBeanInstance(EL_PARENT_LANGUAGE_MODULE, languageModule); //TODO: if (language.getLanguageConfiguration().getLanguagePropertyBoolean(X4OLanguageProperty.DEBUG_OUTPUT_ELD_PARSER)) { // eldLang.setX4ODebugWriter(elementLanguage.getLanguageConfiguration().getX4ODebugWriter()); @@ -111,4 +109,14 @@ public class EldModuleLoader implements X4OLanguageModuleLoader { throw new X4OLanguageModuleLoaderException(this,e.getMessage()+" while parsing: "+eldResource,e); } } + + public static X4OLanguage getLanguage(X4OLanguageContext context) { + ValueExpression ee = context.getExpressionLanguageFactory().createValueExpression(context.getExpressionLanguageContext(),"${"+EL_PARENT_LANGUAGE+"}", X4OLanguage.class); + return (X4OLanguage)ee.getValue(context.getExpressionLanguageContext()); + } + + public static X4OLanguageModule getLanguageModule(X4OLanguageContext context) { + ValueExpression ee = context.getExpressionLanguageFactory().createValueExpression(context.getExpressionLanguageContext(),"${"+EL_PARENT_LANGUAGE_MODULE+"}", X4OLanguageModule.class); + return (X4OLanguageModule)ee.getValue(context.getExpressionLanguageContext()); + } } diff --git a/x4o-driver/src/main/java/org/x4o/xml/eld/lang/ElementModuleBindingHandler.java b/x4o-driver/src/main/java/org/x4o/xml/eld/lang/ElementModuleBindingHandler.java index 80a3698..67a37c2 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/eld/lang/ElementModuleBindingHandler.java +++ b/x4o-driver/src/main/java/org/x4o/xml/eld/lang/ElementModuleBindingHandler.java @@ -22,8 +22,6 @@ */ package org.x4o.xml.eld.lang; -import java.util.Map; - import org.x4o.xml.eld.EldModuleLoader; import org.x4o.xml.element.AbstractElementBindingHandler; import org.x4o.xml.element.Element; @@ -38,7 +36,6 @@ import org.x4o.xml.element.ElementNamespaceInstanceProviderException; import org.x4o.xml.lang.X4OLanguageModule; import org.x4o.xml.lang.X4OLanguage; import org.x4o.xml.lang.X4OLanguageClassLoader; -import org.x4o.xml.lang.X4OLanguageProperty; /** * An ParentLanguageElementConfigurator. @@ -78,13 +75,7 @@ public class ElementModuleBindingHandler extends AbstractElementBindingHandler< */ public void bindChild(Element childElement,X4OLanguageModule languageModule, Object childObject) throws ElementBindingHandlerException { - @SuppressWarnings("rawtypes") - Map m = (Map)childElement.getLanguageContext().getLanguageProperty(X4OLanguageProperty.EL_BEAN_INSTANCE_MAP); - if (m==null) { - return; - } - X4OLanguage x4oParsingContext = (X4OLanguage)m.get(EldModuleLoader.EL_PARENT_LANGUAGE); - //ElementLanguageModule elementLanguageModule = (ElementLanguageModule)m.get(EldParser.PARENT_ELEMENT_LANGUAGE_MODULE); + X4OLanguage x4oParsingContext = EldModuleLoader.getLanguage(childElement.getLanguageContext()); if (x4oParsingContext==null) { return; } diff --git a/x4o-driver/src/main/java/org/x4o/xml/eld/lang/ModuleElement.java b/x4o-driver/src/main/java/org/x4o/xml/eld/lang/ModuleElement.java index 6b64036..ebf2b7c 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/eld/lang/ModuleElement.java +++ b/x4o-driver/src/main/java/org/x4o/xml/eld/lang/ModuleElement.java @@ -22,13 +22,10 @@ */ package org.x4o.xml.eld.lang; -import java.util.Map; - import org.x4o.xml.eld.EldModuleLoader; import org.x4o.xml.element.AbstractElement; import org.x4o.xml.element.ElementException; import org.x4o.xml.lang.X4OLanguageModule; -import org.x4o.xml.lang.X4OLanguageProperty; /** * ModuleElement put in an instance from parent language module. @@ -48,12 +45,7 @@ public class ModuleElement extends AbstractElement { if (getParent()!=null) { throw new ElementException("Need to be root tag"); } - @SuppressWarnings("rawtypes") - Map m = (Map)getLanguageContext().getLanguageProperty(X4OLanguageProperty.EL_BEAN_INSTANCE_MAP); - if (m==null) { - return; - } - X4OLanguageModule elementLanguageModule = (X4OLanguageModule)m.get(EldModuleLoader.EL_PARENT_ELEMENT_LANGUAGE_MODULE); + X4OLanguageModule elementLanguageModule = EldModuleLoader.getLanguageModule(getLanguageContext()); setElementObject(elementLanguageModule); } } diff --git a/x4o-driver/src/main/java/org/x4o/xml/eld/xsd/EldXsdXmlGenerator.java b/x4o-driver/src/main/java/org/x4o/xml/eld/xsd/EldXsdXmlGenerator.java index 1a77ed0..7d13e45 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/eld/xsd/EldXsdXmlGenerator.java +++ b/x4o-driver/src/main/java/org/x4o/xml/eld/xsd/EldXsdXmlGenerator.java @@ -30,12 +30,12 @@ import java.io.Writer; import org.x4o.xml.element.ElementClass; import org.x4o.xml.element.ElementException; import org.x4o.xml.element.ElementNamespaceContext; -import org.x4o.xml.io.XMLConstants; +import org.x4o.xml.io.DefaultX4OSchemaWriter; +import org.x4o.xml.io.sax.ext.ContentWriterXml; import org.x4o.xml.io.sax.ext.ContentWriterXsd; -import org.x4o.xml.lang.X4OLanguageContext; +import org.x4o.xml.io.sax.ext.PropertyConfig; import org.x4o.xml.lang.X4OLanguageModule; import org.x4o.xml.lang.X4OLanguage; -import org.x4o.xml.lang.X4OLanguageProperty; import org.xml.sax.SAXException; /** @@ -46,12 +46,12 @@ import org.xml.sax.SAXException; */ public class EldXsdXmlGenerator { - private X4OLanguage language = null; - private X4OLanguageContext languageContext = null; + private final X4OLanguage language; + private final PropertyConfig propertyConfig; - public EldXsdXmlGenerator(X4OLanguageContext languageContext) { - this.languageContext=languageContext; - this.language=languageContext.getLanguage(); + public EldXsdXmlGenerator(X4OLanguage language,PropertyConfig propertyConfig) { + this.language=language; + this.propertyConfig=propertyConfig; } private void checkNamespace(ElementNamespaceContext ns) { @@ -64,16 +64,11 @@ public class EldXsdXmlGenerator { } public void writeSchema(String namespace) throws ElementException { - File basePath = (File)languageContext.getLanguageProperty(X4OLanguageProperty.SCHEMA_WRITER_OUTPUT_PATH); - String encoding = languageContext.getLanguagePropertyString(X4OLanguageProperty.SCHEMA_WRITER_OUTPUT_ENCODING); - String charNew = languageContext.getLanguagePropertyString(X4OLanguageProperty.SCHEMA_WRITER_OUTPUT_CHAR_NEWLINE); - String charTab = languageContext.getLanguagePropertyString(X4OLanguageProperty.SCHEMA_WRITER_OUTPUT_CHAR_TAB); + File basePath = (File)propertyConfig.getProperty(DefaultX4OSchemaWriter.OUTPUT_PATH); + String encoding = propertyConfig.getPropertyString(ContentWriterXml.OUTPUT_ENCODING); if (basePath==null) { throw new ElementException("Can't write schema to null output path."); } - if (encoding==null) { encoding = XMLConstants.XML_DEFAULT_ENCODING; } - if (charNew==null) { charNew = XMLConstants.CHAR_NEWLINE+""; } - if (charTab==null) { charTab = XMLConstants.CHAR_TAB+""; } try { @@ -86,7 +81,8 @@ public class EldXsdXmlGenerator { File outputFile = new File(basePath.getAbsolutePath()+File.separatorChar+ns.getSchemaResource()); Writer wr = new OutputStreamWriter(new FileOutputStream(outputFile), encoding); try { - ContentWriterXsd out = new ContentWriterXsd(wr,encoding,charNew,charTab); + ContentWriterXsd out = new ContentWriterXsd(wr,encoding); + out.getPropertyConfig().copyParentProperties(propertyConfig); generateSchema(ns.getUri(), out); } finally { wr.close(); @@ -99,7 +95,8 @@ public class EldXsdXmlGenerator { File outputFile = new File(basePath.getAbsolutePath()+File.separatorChar+ns.getSchemaResource()); Writer wr = new OutputStreamWriter(new FileOutputStream(outputFile), encoding); try { - ContentWriterXsd out = new ContentWriterXsd(wr,encoding,charNew,charTab); + ContentWriterXsd out = new ContentWriterXsd(wr,encoding); + out.getPropertyConfig().copyParentProperties(propertyConfig); generateSchema(ns.getUri(), out); } finally { wr.close(); diff --git a/x4o-driver/src/main/java/org/x4o/xml/element/AbstractElement.java b/x4o-driver/src/main/java/org/x4o/xml/element/AbstractElement.java index f6e87e2..2d67429 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/element/AbstractElement.java +++ b/x4o-driver/src/main/java/org/x4o/xml/element/AbstractElement.java @@ -43,7 +43,7 @@ public abstract class AbstractElement implements Element { /** The config object */ private Object elementObject = null; /** The language parsing context */ - private X4OLanguageContext elementLanguage = null; + private X4OLanguageContext languageContext = null; /** The ElementClass */ private ElementClass elementClass = null; /** The attributes */ @@ -116,15 +116,15 @@ public abstract class AbstractElement implements Element { /** * @see Element#setLanguageContext(X4OLanguageContext) */ - public void setLanguageContext(X4OLanguageContext elementLanguage) { - this.elementLanguage=elementLanguage; + public void setLanguageContext(X4OLanguageContext languageContext) { + this.languageContext=languageContext; } /** * @see Element#getLanguageContext() */ public X4OLanguageContext getLanguageContext() { - return elementLanguage; + return languageContext; } /** diff --git a/x4o-driver/src/main/java/org/x4o/xml/element/ElementNamespaceContext.java b/x4o-driver/src/main/java/org/x4o/xml/element/ElementNamespaceContext.java index bb8fe87..283a29b 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/element/ElementNamespaceContext.java +++ b/x4o-driver/src/main/java/org/x4o/xml/element/ElementNamespaceContext.java @@ -31,12 +31,6 @@ import java.util.List; * @version 1.0 Oct 28, 2009 */ public interface ElementNamespaceContext extends ElementMetaBase { - - //void init(ElementLanguageModuleLoader elementProvider,String language); - - //String getNamespace(); - //String getNamespaceResourceFile(); - //String getNamespaceLanguage(); /** * Sets the prefix mapping. diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OConnection.java b/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OConnection.java index aa3147b..12822f6 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OConnection.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OConnection.java @@ -22,8 +22,12 @@ */ package org.x4o.xml.io; -import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguageProperty; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.x4o.xml.io.sax.ext.PropertyConfig; +import org.x4o.xml.lang.X4OLanguage; /** * AbstractX4OConnection is the read/write interface for the classes. @@ -33,49 +37,43 @@ import org.x4o.xml.lang.X4OLanguageProperty; */ public abstract class AbstractX4OConnection implements X4OConnection { - private X4OLanguageContext languageContext = null; + private final X4OLanguage language; + protected String phaseStop = null; + protected List phaseSkip = null; - /** - * Creates a AbstractX4OConnection. - * @param languageContext The language context of this connection. - */ - public AbstractX4OConnection(X4OLanguageContext languageContext) { - this.languageContext=languageContext; + public AbstractX4OConnection(X4OLanguage language) { + this.language=language; + this.phaseSkip = new ArrayList(2); } - /** - * @return Returns the language context. - */ - protected X4OLanguageContext getLanguageContext() { - return languageContext; + protected X4OLanguage getLanguage() { + return language; } - + + abstract PropertyConfig getPropertyConfig(); + /** * Sets an X4O Language property. * @param key The key of the property to set. * @param value The vlue of the property to set. */ public void setProperty(String key,Object value) { - String[] keyLimits = getPropertyKeySet(); - for (int i=0;i getPropertyKeys() { + return getPropertyConfig().getPropertyKeys(); + } + + public void setPhaseStop(String phaseId) { + phaseStop = phaseId; + } + + public void addPhaseSkip(String phaseId) { + phaseSkip.add( phaseId ); } } diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OReader.java b/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OReader.java index ed2588c..5d30ba2 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OReader.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OReader.java @@ -28,8 +28,7 @@ import java.io.IOException; import java.io.InputStream; import java.net.URL; -import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguagePropertyKeys; +import org.x4o.xml.lang.X4OLanguage; import org.xml.sax.SAXException; /** @@ -41,15 +40,8 @@ import org.xml.sax.SAXException; @SuppressWarnings("unchecked") abstract public class AbstractX4OReader extends AbstractX4OReaderContext implements X4OReader { - public AbstractX4OReader(X4OLanguageContext elementLanguage) { - super(elementLanguage); - } - - /** - * @see org.x4o.xml.io.X4OConnection#getPropertyKeySet() - */ - public String[] getPropertyKeySet() { - return X4OLanguagePropertyKeys.DEFAULT_X4O_READER_KEYS; + public AbstractX4OReader(X4OLanguage language) { + super(language); } public T read(InputStream input, String systemId, URL basePath) throws X4OConnectionException,SAXException,IOException { diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OReaderContext.java b/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OReaderContext.java index 9a9923f..1d38643 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OReaderContext.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OReaderContext.java @@ -30,9 +30,9 @@ import java.io.IOException; import java.io.InputStream; import java.net.URL; +import org.x4o.xml.lang.X4OLanguage; import org.x4o.xml.lang.X4OLanguageClassLoader; import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguageProperty; import org.xml.sax.SAXException; /** @@ -44,8 +44,8 @@ import org.xml.sax.SAXException; */ abstract public class AbstractX4OReaderContext extends AbstractX4OConnection implements X4OReaderContext { - public AbstractX4OReaderContext(X4OLanguageContext languageContext) { - super(languageContext); + public AbstractX4OReaderContext(X4OLanguage language) { + super(language); } /** @@ -135,7 +135,7 @@ abstract public class AbstractX4OReaderContext extends AbstractX4OConnection throw new NullPointerException("Can't read null xml string."); } URL basePath = new File(System.getProperty("user.dir")).toURI().toURL(); - String encoding = getLanguageContext().getLanguagePropertyString(X4OLanguageProperty.READER_INPUT_ENCODING); + String encoding = (String)getProperty(DefaultX4OReader.INPUT_ENCODING); return readContext(new ByteArrayInputStream(xmlString.getBytes(encoding)),"inline-xml",basePath); } diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OWriter.java b/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OWriter.java index 0e0fff4..7e47905 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OWriter.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OWriter.java @@ -28,8 +28,8 @@ import java.io.IOException; import java.io.OutputStream; import org.x4o.xml.element.Element; +import org.x4o.xml.lang.X4OLanguage; import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguagePropertyKeys; import org.xml.sax.SAXException; /** @@ -40,16 +40,11 @@ import org.xml.sax.SAXException; */ public abstract class AbstractX4OWriter extends AbstractX4OWriterContext implements X4OWriter { - public AbstractX4OWriter(X4OLanguageContext elementLanguage) { - super(elementLanguage); + public AbstractX4OWriter(X4OLanguage language) { + super(language); } - /** - * @see org.x4o.xml.io.X4OConnection#getPropertyKeySet() - */ - public String[] getPropertyKeySet() { - return X4OLanguagePropertyKeys.DEFAULT_X4O_WRITER_KEYS; - } + abstract X4OLanguageContext getLanguageContext(); private X4OLanguageContext toObjectContext(T object) throws SAXException { X4OLanguageContext context = getLanguageContext(); @@ -62,6 +57,7 @@ public abstract class AbstractX4OWriter extends AbstractX4OWriterContext i throw new SAXException(e); } rootElement.setElementObject(object); + rootElement.setLanguageContext(context); context.setRootElement(rootElement); return context; } diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OWriterContext.java b/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OWriterContext.java index 844c397..28b6140 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OWriterContext.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/AbstractX4OWriterContext.java @@ -28,8 +28,9 @@ import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; +import org.x4o.xml.io.sax.ext.ContentWriterXml; +import org.x4o.xml.lang.X4OLanguage; import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguageProperty; import org.xml.sax.SAXException; /** @@ -40,8 +41,8 @@ import org.xml.sax.SAXException; */ public abstract class AbstractX4OWriterContext extends AbstractX4OConnection implements X4OWriterContext { - public AbstractX4OWriterContext(X4OLanguageContext elementLanguage) { - super(elementLanguage); + public AbstractX4OWriterContext(X4OLanguage language) { + super(language); } public void writeFileContext(X4OLanguageContext context,String fileName) throws X4OConnectionException,SAXException,IOException { @@ -66,7 +67,7 @@ public abstract class AbstractX4OWriterContext extends AbstractX4OConnection public String writeStringContext(X4OLanguageContext context) throws X4OConnectionException,SAXException,IOException { ByteArrayOutputStream out = new ByteArrayOutputStream(4096); writeContext(context, out); - String encoding = context.getLanguagePropertyString(X4OLanguageProperty.WRITER_OUTPUT_ENCODING); + String encoding = (String)getProperty(ContentWriterXml.OUTPUT_ENCODING); return out.toString(encoding); } } diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/DefaultX4OReader.java b/x4o-driver/src/main/java/org/x4o/xml/io/DefaultX4OReader.java index ff30e50..20b4446 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/DefaultX4OReader.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/DefaultX4OReader.java @@ -22,27 +22,32 @@ */ package org.x4o.xml.io; +import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.PrintWriter; import java.io.StringWriter; import java.net.URL; -import java.util.HashMap; -import java.util.Map; import java.util.logging.Logger; +import javax.el.ValueExpression; import javax.xml.parsers.ParserConfigurationException; +import org.x4o.xml.io.sax.X4OContentParser; import org.x4o.xml.io.sax.X4ODebugWriter; import org.x4o.xml.io.sax.ext.ContentWriter; import org.x4o.xml.io.sax.ext.ContentWriterXml; +import org.x4o.xml.io.sax.ext.PropertyConfig; +import org.x4o.xml.io.sax.ext.PropertyConfig.PropertyConfigItem; +import org.x4o.xml.lang.X4OLanguage; import org.x4o.xml.lang.X4OLanguageContext; import org.x4o.xml.lang.X4OLanguageContextLocal; -import org.x4o.xml.lang.X4OLanguageProperty; -import org.x4o.xml.lang.X4OLanguagePropertyKeys; import org.x4o.xml.lang.phase.X4OPhaseException; import org.x4o.xml.lang.phase.X4OPhaseType; +import org.xml.sax.EntityResolver; +import org.xml.sax.ErrorHandler; +import org.xml.sax.InputSource; import org.xml.sax.SAXException; import org.xml.sax.helpers.AttributesImpl; @@ -53,25 +58,82 @@ import org.xml.sax.helpers.AttributesImpl; * @version 1.0 Aug 9, 2012 */ public class DefaultX4OReader extends AbstractX4OReader { - /** The logger to log to. */ private Logger logger = null; - public DefaultX4OReader(X4OLanguageContext elementLanguage) { - super(elementLanguage); + private X4OLanguageContext languageContext = null; + + private PropertyConfig propertyConfig; + + private final static String PROPERTY_CONTEXT_PREFIX = PropertyConfig.X4O_PROPERTIES_PREFIX+PropertyConfig.X4O_PROPERTIES_READER; + private final static String PROPERTY_SAX_ERROR_HANDLER = "sax/error-handler"; + private final static String PROPERTY_SAX_ENTITY_RESOLVER = "sax/entity-resolver"; + private final static String PROPERTY_DOC_EMPTY_NAMESPACE_URI = "doc/empty-namespace-uri"; + private final static String PROPERTY_DOC_BUFFER_SIZE = "doc/buffer-size"; + private final static String PROPERTY_INPUT_STREAM = "input/stream"; + private final static String PROPERTY_INPUT_ENCODING = "input/encoding"; + private final static String PROPERTY_INPUT_SOURCE = "input/source"; + private final static String PROPERTY_INPUT_SYSTEM_ID = "input/system-id"; + private final static String PROPERTY_INPUT_BASE_PATH = "input/base-path"; + private final static String PROPERTY_VALIDATION_SCHEMA_AUTO_WRITE = "validation/schema-auto-write"; + private final static String PROPERTY_VALIDATION_SCHEMA_PATH = "validation/schema-path"; + private final static String PROPERTY_VALIDATION_INPUT_DOC = "validation/input-doc"; + private final static String PROPERTY_VALIDATION_INPUT_SCHEMA = "validation/input-schema"; + + public final static PropertyConfig DEFAULT_PROPERTY_CONFIG; + public final static String SAX_ERROR_HANDLER = PROPERTY_CONTEXT_PREFIX+PROPERTY_SAX_ERROR_HANDLER; + public final static String SAX_ENTITY_RESOLVER = PROPERTY_CONTEXT_PREFIX+PROPERTY_SAX_ENTITY_RESOLVER; + public final static String DOC_EMPTY_NAMESPACE_URI = PROPERTY_CONTEXT_PREFIX+PROPERTY_DOC_EMPTY_NAMESPACE_URI; + public final static String DOC_BUFFER_SIZE = PROPERTY_CONTEXT_PREFIX+PROPERTY_DOC_BUFFER_SIZE; + public final static String INPUT_STREAM = PROPERTY_CONTEXT_PREFIX+PROPERTY_INPUT_STREAM; + public final static String INPUT_ENCODING = PROPERTY_CONTEXT_PREFIX+PROPERTY_INPUT_ENCODING; + public final static String INPUT_SOURCE = PROPERTY_CONTEXT_PREFIX+PROPERTY_INPUT_SOURCE; + public final static String INPUT_SYSTEM_ID = PROPERTY_CONTEXT_PREFIX+PROPERTY_INPUT_SYSTEM_ID; + public final static String INPUT_BASE_PATH = PROPERTY_CONTEXT_PREFIX+PROPERTY_INPUT_BASE_PATH; + public final static String VALIDATION_SCHEMA_AUTO_WRITE = PROPERTY_CONTEXT_PREFIX+PROPERTY_VALIDATION_SCHEMA_AUTO_WRITE; + public final static String VALIDATION_SCHEMA_PATH = PROPERTY_CONTEXT_PREFIX+PROPERTY_VALIDATION_SCHEMA_PATH; + public final static String VALIDATION_INPUT_DOC = PROPERTY_CONTEXT_PREFIX+PROPERTY_VALIDATION_INPUT_DOC; + public final static String VALIDATION_INPUT_SCHEMA = PROPERTY_CONTEXT_PREFIX+PROPERTY_VALIDATION_INPUT_SCHEMA; + + static { + DEFAULT_PROPERTY_CONFIG = new PropertyConfig(true,null,PROPERTY_CONTEXT_PREFIX, + new PropertyConfigItem(PROPERTY_SAX_ERROR_HANDLER,ErrorHandler.class), + new PropertyConfigItem(PROPERTY_SAX_ENTITY_RESOLVER,EntityResolver.class), + new PropertyConfigItem(PROPERTY_DOC_EMPTY_NAMESPACE_URI,String.class), + new PropertyConfigItem(PROPERTY_DOC_BUFFER_SIZE,Integer.class,4096*2), + new PropertyConfigItem(PROPERTY_INPUT_STREAM,InputStream.class), + new PropertyConfigItem(PROPERTY_INPUT_ENCODING,String.class,XMLConstants.XML_DEFAULT_ENCODING), + new PropertyConfigItem(PROPERTY_INPUT_SOURCE,InputSource.class), + new PropertyConfigItem(PROPERTY_INPUT_SYSTEM_ID,String.class), + new PropertyConfigItem(PROPERTY_INPUT_BASE_PATH,URL.class), + new PropertyConfigItem(PROPERTY_VALIDATION_SCHEMA_AUTO_WRITE,Boolean.class,true), + new PropertyConfigItem(PROPERTY_VALIDATION_SCHEMA_PATH,File.class), + new PropertyConfigItem(PROPERTY_VALIDATION_INPUT_DOC,Boolean.class,false), + new PropertyConfigItem(PROPERTY_VALIDATION_INPUT_SCHEMA,Boolean.class,false) + ); + } + + public DefaultX4OReader(X4OLanguage language) { + super(language); logger = Logger.getLogger(DefaultX4OReader.class.getName()); + languageContext = language.createLanguageContext(); + propertyConfig = new PropertyConfig(DEFAULT_PROPERTY_CONFIG,PROPERTY_CONTEXT_PREFIX); + } + + @Override + PropertyConfig getPropertyConfig() { + return propertyConfig; } public X4OLanguageContext readContext(InputStream input, String systemId, URL basePath) throws X4OConnectionException, SAXException, IOException { - setProperty(X4OLanguagePropertyKeys.READER_INPUT_STREAM, input); - setProperty(X4OLanguagePropertyKeys.READER_INPUT_SYSTEM_ID, systemId); - setProperty(X4OLanguagePropertyKeys.READER_INPUT_BASE_PATH, basePath); + setProperty(INPUT_STREAM, input); + setProperty(INPUT_SYSTEM_ID, systemId); + setProperty(INPUT_BASE_PATH, basePath); read(); - return getLanguageContext(); + return languageContext; } - - @SuppressWarnings({ "unchecked", "rawtypes" }) + public void addELBeanInstance(String name,Object bean) { if (name==null) { throw new NullPointerException("Can't add null name."); @@ -82,28 +144,33 @@ public class DefaultX4OReader extends AbstractX4OReader { if (bean==null) { throw new NullPointerException("Can't add null bean."); } - Map map = (Map)getProperty(X4OLanguagePropertyKeys.EL_BEAN_INSTANCE_MAP); - if (map==null) { - map = new HashMap(20); - setProperty(X4OLanguagePropertyKeys.EL_BEAN_INSTANCE_MAP, map); - } - logger.finer("Adding el bean: "+name+" type: "+bean.getClass()); - map.put(name,bean); + ValueExpression ve = languageContext.getExpressionLanguageFactory().createValueExpression(languageContext.getExpressionLanguageContext(),"${"+name+"}", bean.getClass()); + ve.setValue(languageContext.getExpressionLanguageContext(), bean); } /** * Parses the input stream as a X4O document. */ protected void read() throws X4OConnectionException,SAXException,IOException { - X4OLanguageContext languageContext = getLanguageContext(); if (languageContext.getLanguage()==null) { throw new X4OConnectionException("languageContext is broken getLanguage() returns null."); } + + if (languageContext instanceof X4OLanguageContextLocal) { + X4OLanguageContextLocal ll = (X4OLanguageContextLocal)languageContext; + if (phaseStop!=null) { + ll.setPhaseStop(phaseStop); + } + for (String phaseId:phaseSkip) { + ll.addPhaseSkip(phaseId); + } + } + // init debugWriter if enabled boolean startedDebugWriter = false; - Object debugOutputHandler = languageContext.getLanguageProperty(X4OLanguageProperty.DEBUG_OUTPUT_HANDLER); - Object debugOutputStream = languageContext.getLanguageProperty(X4OLanguageProperty.DEBUG_OUTPUT_STREAM); + Object debugOutputHandler = null; //TODO: getProperty(X4OLanguageProperty.DEBUG_OUTPUT_HANDLER.name()); + Object debugOutputStream = null; //getProperty(X4OLanguageProperty.DEBUG_OUTPUT_STREAM.name()); if (languageContext.getX4ODebugWriter()==null) { ContentWriter xmlDebugWriter = null; if (debugOutputHandler instanceof ContentWriter) { @@ -131,7 +198,10 @@ public class DefaultX4OReader extends AbstractX4OReader { // start parsing language try { - getLanguageContext().getLanguage().getPhaseManager().runPhases(getLanguageContext(), X4OPhaseType.XML_READ); + X4OContentParser parser = new X4OContentParser(propertyConfig); + parser.parse(languageContext); + + getLanguage().getPhaseManager().runPhases(languageContext, X4OPhaseType.XML_READ); } catch (Exception e) { // also debug exceptions diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/DefaultX4OSchemaWriter.java b/x4o-driver/src/main/java/org/x4o/xml/io/DefaultX4OSchemaWriter.java index 1bf94ce..636f15b 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/DefaultX4OSchemaWriter.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/DefaultX4OSchemaWriter.java @@ -26,8 +26,10 @@ import java.io.File; import org.x4o.xml.eld.xsd.EldXsdXmlGenerator; import org.x4o.xml.element.ElementException; -import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguagePropertyKeys; +import org.x4o.xml.io.sax.ext.ContentWriterXml; +import org.x4o.xml.io.sax.ext.PropertyConfig; +import org.x4o.xml.io.sax.ext.PropertyConfig.PropertyConfigItem; +import org.x4o.xml.lang.X4OLanguage; /** * DefaultX4OSchemaWriter can write the schema of a x4o language. @@ -37,15 +39,28 @@ import org.x4o.xml.lang.X4OLanguagePropertyKeys; */ public class DefaultX4OSchemaWriter extends AbstractX4OConnection implements X4OSchemaWriter { - public DefaultX4OSchemaWriter(X4OLanguageContext languageContext) { - super(languageContext); + private PropertyConfig propertyConfig; + + private final static String PROPERTY_CONTEXT_PREFIX = PropertyConfig.X4O_PROPERTIES_PREFIX+PropertyConfig.X4O_PROPERTIES_WRITER; + private final static String PROPERTY_OUTPUT_PATH = "output/path"; + + public final static PropertyConfig DEFAULT_PROPERTY_CONFIG; + public final static String OUTPUT_PATH = PROPERTY_CONTEXT_PREFIX+PROPERTY_OUTPUT_PATH; + + static { + DEFAULT_PROPERTY_CONFIG = new PropertyConfig(true,ContentWriterXml.DEFAULT_PROPERTY_CONFIG,PROPERTY_CONTEXT_PREFIX, + new PropertyConfigItem(PROPERTY_OUTPUT_PATH,File.class) + ); } - /** - * @see org.x4o.xml.io.X4OConnection#getPropertyKeySet() - */ - public String[] getPropertyKeySet() { - return X4OLanguagePropertyKeys.DEFAULT_X4O_SCHEMA_WRITER_KEYS; + public DefaultX4OSchemaWriter(X4OLanguage language) { + super(language); + propertyConfig = new PropertyConfig(DEFAULT_PROPERTY_CONFIG,PROPERTY_CONTEXT_PREFIX); + } + + @Override + PropertyConfig getPropertyConfig() { + return propertyConfig; } /** @@ -54,13 +69,14 @@ public class DefaultX4OSchemaWriter extends AbstractX4OConnection implements X4O public void writeSchema(File basePath) throws ElementException { writeSchema(basePath, null); } - + /** * @see org.x4o.xml.io.X4OSchemaWriter#writeSchema(java.io.File, java.lang.String) */ public void writeSchema(File basePath, String namespace) throws ElementException { - setProperty(X4OLanguagePropertyKeys.SCHEMA_WRITER_OUTPUT_PATH, basePath); - EldXsdXmlGenerator xsd = new EldXsdXmlGenerator(getLanguageContext()); + setProperty(OUTPUT_PATH, basePath); + // TODO: fix create context + EldXsdXmlGenerator xsd = new EldXsdXmlGenerator(getLanguage().createLanguageContext().getLanguage(),getPropertyConfig()); xsd.writeSchema(namespace); // Start xsd generator } } diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/DefaultX4OWriter.java b/x4o-driver/src/main/java/org/x4o/xml/io/DefaultX4OWriter.java index acf178d..ca037ce 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/DefaultX4OWriter.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/DefaultX4OWriter.java @@ -24,12 +24,32 @@ package org.x4o.xml.io; import java.io.IOException; import java.io.OutputStream; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.x4o.xml.element.Element; +import org.x4o.xml.element.ElementClass; +import org.x4o.xml.element.ElementClassAttribute; +import org.x4o.xml.element.ElementInterface; +import org.x4o.xml.element.ElementNamespaceContext; +import org.x4o.xml.element.ElementObjectPropertyValueException; +import org.x4o.xml.io.sax.ext.PropertyConfig; +import org.x4o.xml.io.sax.ext.ContentWriterXml; +import org.x4o.xml.io.sax.ext.PropertyConfig.PropertyConfigItem; +import org.x4o.xml.lang.X4OLanguage; import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguagePropertyKeys; +import org.x4o.xml.lang.X4OLanguageModule; +import org.x4o.xml.lang.phase.X4OPhase; import org.x4o.xml.lang.phase.X4OPhaseException; import org.x4o.xml.lang.phase.X4OPhaseType; import org.xml.sax.SAXException; +import org.xml.sax.helpers.AttributesImpl; /** * DefaultX4OWriter can write the xml language. @@ -39,23 +59,278 @@ import org.xml.sax.SAXException; */ public class DefaultX4OWriter extends AbstractX4OWriter { + private PropertyConfig propertyConfig; + + private final static String PROPERTY_CONTEXT_PREFIX = PropertyConfig.X4O_PROPERTIES_PREFIX+PropertyConfig.X4O_PROPERTIES_WRITER; + private final static String PROPERTY_OUTPUT_STREAM = "output/stream"; + private final static String PROPERTY_SCHEMA_PRINT = "schema/print"; + private final static String PROPERTY_SCHEMA_ROOT_URI = "schema/root-uri"; + + public final static PropertyConfig DEFAULT_PROPERTY_CONFIG; + public final static String OUTPUT_STREAM = PROPERTY_CONTEXT_PREFIX+PROPERTY_OUTPUT_STREAM; + public final static String SCHEMA_PRINT = PROPERTY_CONTEXT_PREFIX+PROPERTY_SCHEMA_PRINT; + public final static String SCHEMA_ROOT_URI = PROPERTY_CONTEXT_PREFIX+PROPERTY_SCHEMA_ROOT_URI; + + static { + DEFAULT_PROPERTY_CONFIG = new PropertyConfig(true,ContentWriterXml.DEFAULT_PROPERTY_CONFIG,PROPERTY_CONTEXT_PREFIX, + new PropertyConfigItem(PROPERTY_OUTPUT_STREAM,OutputStream.class), + new PropertyConfigItem(PROPERTY_SCHEMA_PRINT,Boolean.class,true), + new PropertyConfigItem(PROPERTY_SCHEMA_ROOT_URI,String.class) + ); + } + /** * Default constructor. * @param languageContext The language context for this writer. */ - public DefaultX4OWriter(X4OLanguageContext languageContext) { - super(languageContext); + public DefaultX4OWriter(X4OLanguage language) { + super(language); + propertyConfig = new PropertyConfig(DEFAULT_PROPERTY_CONFIG,PROPERTY_CONTEXT_PREFIX); + } + + /** + * @see org.x4o.xml.lang.X4OLanguageContext#getPropertyConfig() + */ + public PropertyConfig getPropertyConfig() { + return propertyConfig; + } + + X4OLanguageContext getLanguageContext() { + return getLanguage().createLanguageContext(); } /** * @see org.x4o.xml.io.X4OWriterContext#writeContext(org.x4o.xml.lang.X4OLanguageContext, java.io.OutputStream) */ public void writeContext(X4OLanguageContext languageContext,OutputStream output) throws X4OConnectionException,SAXException,IOException { - languageContext.setLanguageProperty(X4OLanguagePropertyKeys.WRITER_OUTPUT_STREAM, output); + setProperty(OUTPUT_STREAM, output); + addPhaseSkip(X4OPhase.WRITE_RELEASE); try { languageContext.getLanguage().getPhaseManager().runPhases(languageContext, X4OPhaseType.XML_WRITE); } catch (X4OPhaseException e) { throw new X4OConnectionException(e); } + runWrite(languageContext); + } + + private AttributeEntryComparator attributeEntryComparator = new AttributeEntryComparator(); + private boolean schemaUriPrint; + private String schemaUriRoot; + + private void runWrite(X4OLanguageContext languageContext) throws X4OConnectionException { + OutputStream out = (OutputStream)getProperty(OUTPUT_STREAM); + try { + String encoding = getPropertyConfig().getPropertyString(ContentWriterXml.OUTPUT_ENCODING); + schemaUriPrint = getPropertyConfig().getPropertyBoolean(SCHEMA_PRINT); + schemaUriRoot = getPropertyConfig().getPropertyString(SCHEMA_ROOT_URI); + if (encoding==null) { encoding = XMLConstants.XML_DEFAULT_ENCODING; } + + Element root = languageContext.getRootElement(); + if (schemaUriRoot==null) { + String rootUri = findElementUri(root); + ElementNamespaceContext ns = languageContext.getLanguage().findElementNamespaceContext(rootUri); + if (ns!=null) { + schemaUriRoot = ns.getSchemaUri(); + } + } + + ContentWriterXml writer = new ContentWriterXml(out,encoding); + writer.getPropertyConfig().copyParentProperties(getPropertyConfig()); + + writer.startDocument(); + + Map prefixes = new HashMap(); + startPrefixTree(root,prefixes); + for (String uri:prefixes.keySet()) { + String prefix = prefixes.get(uri); + writer.startPrefixMapping(prefix, uri); + } + try { + writeTree(writer,root,true); + } catch (ElementObjectPropertyValueException e) { + throw new SAXException(e); + } + writer.endDocument(); + out.flush(); + + } catch (Exception e) { + throw new X4OConnectionException(e); + } finally { + if (out!=null) { + try { + out.close(); + } catch (IOException e) { + //logger.warning(e.getMessage()); + } + } + } + } + + private void startPrefixTree(Element element,Map result) throws SAXException { + String elementUri = findElementUri(element); + if (result.containsKey(elementUri)==false) { + String elementUriPrefix = findNamespacePrefix(element,elementUri); + result.put(elementUri, elementUriPrefix); + } + for (Element e:element.getChilderen()) { + startPrefixTree(e,result); + } + } + + private List getProperties(Class objectClass) { + List result = new ArrayList(); + for (Method m:objectClass.getMethods()) { + Class[] types = m.getParameterTypes(); + if (types.length != 0) { + continue; + } + if (m.getName().equals("getClass")) { + continue; + } + if (m.getName().startsWith("get")==false) { + continue; + } + String name = m.getName().substring(3,4).toLowerCase()+m.getName().substring(4); + result.add(name); + + } + return result; + } + class AttributeEntry { + String id; + String value; + Integer writeOrder; + } + class AttributeEntryComparator implements Comparator { + public int compare(AttributeEntry o1, AttributeEntry o2) { + return o1.writeOrder.compareTo(o2.writeOrder); + } + } + private void writeTree(ContentWriterXml writer,Element element,boolean isRoot) throws SAXException, ElementObjectPropertyValueException { + List attr = new ArrayList(20); + if (element.getElementClass().getAutoAttributes()!=null && element.getElementClass().getAutoAttributes()==false) { + for (ElementClassAttribute eca:element.getElementClass().getElementClassAttributes()) { + if (eca.getRunBeanValue()!=null && eca.getRunBeanValue()==false) { + continue; + } + + Object value = element.getLanguageContext().getElementObjectPropertyValue().getProperty(element.getElementObject(),eca.getId()); + if (value==null) { + continue; + } + AttributeEntry e = new AttributeEntry(); + e.id = eca.getId(); + e.value = ""+value; + e.writeOrder = calcOrderNumber(e.id,eca.getWriteOrder()); + attr.add(e); + } + + } else { + for (String p:getProperties(element.getElementObject().getClass())) { + Integer writeOrder = null; + ElementClassAttribute eca = element.getElementClass().getElementClassAttributeByName(p); + if (eca!=null) { + writeOrder = eca.getWriteOrder(); + } + if (eca!=null && eca.getRunBeanValue()!=null && eca.getRunBeanValue()) { + continue; + } + boolean writeValue = true; + for (ElementInterface ei:element.getLanguageContext().getLanguage().findElementInterfaces(element.getElementObject().getClass())) { + eca = ei.getElementClassAttributeByName(p); + if (eca!=null && writeOrder==null) { + writeOrder = eca.getWriteOrder(); // add interface but allow override local + } + if (eca!=null && eca.getRunBeanValue()!=null && eca.getRunBeanValue()==false) { + writeValue = false; + break; + } + } + if (writeValue==false) { + continue; + } + + // TODO: check attr see reader + Object value = element.getLanguageContext().getElementObjectPropertyValue().getProperty(element.getElementObject(),p); + if (value==null) { + continue; + } + if (value instanceof List || value instanceof Collection) { + continue; // TODO; filter on type of childeren + } + AttributeEntry e = new AttributeEntry(); + e.id = p; + e.value = ""+value; + e.writeOrder = calcOrderNumber(e.id,writeOrder); + attr.add(e); + } + } + + // Create atts to write and append schema first. + AttributesImpl atts = new AttributesImpl(); + if (isRoot && schemaUriPrint) { + String rootUri = findElementUri(element); + writer.startPrefixMapping("xsi", XMLConstants.XML_SCHEMA_INSTANCE_NS_URI); + atts.addAttribute ("xsi", "schemaLocation", "", "", rootUri+" "+schemaUriRoot); + } + + // Sort attributes in natural order of localName and add to attributes + Collections.sort(attr, attributeEntryComparator); + for (int i=0;i3) { + return (name.charAt(0) * 1000) + (name.charAt(1) * 100) + (name.charAt(2) * 10) + (name.charAt(3) * 1); + } + throw new IllegalArgumentException("Can't calculate order of empty name."); + } + + private String findElementUri(Element e) { + for (X4OLanguageModule mod:e.getLanguageContext().getLanguage().getLanguageModules()) { + for (ElementNamespaceContext c:mod.getElementNamespaceContexts()) { + ElementClass ec = c.getElementClass(e.getElementClass().getId()); + if (ec!=null) { + return c.getUri(); + } + } + } + return null; + } + + private String findNamespacePrefix(Element e,String uri) { + ElementNamespaceContext ns = e.getLanguageContext().getLanguage().findElementNamespaceContext(uri); + if (ns.getPrefixMapping()!=null) { + return ns.getPrefixMapping(); + } + return ns.getId(); } } diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/X4OConnection.java b/x4o-driver/src/main/java/org/x4o/xml/io/X4OConnection.java index a1006f6..5973a32 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/X4OConnection.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/X4OConnection.java @@ -22,6 +22,8 @@ */ package org.x4o.xml.io; +import java.util.Collection; + /** * X4OConnection interface for config the io drivers. * @@ -37,15 +39,11 @@ public interface X4OConnection { */ void setProperty(String key,Object value); - /** - * Returns the value an X4O Language property. - * @param key The key of the property to get the value for. - * @return Returns null or the value of the property. - */ - Object getProperty(String key); + public Object getProperty(String key); - /** - * @return Returns the propery keys which can be set. - */ - String[] getPropertyKeySet(); + public Collection getPropertyKeys(); + + public void setPhaseStop(String phaseId); + + public void addPhaseSkip(String phaseId); } diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OContentHandler.java b/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OContentHandler.java index 8b384a6..7e36b34 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OContentHandler.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OContentHandler.java @@ -27,9 +27,10 @@ import org.x4o.xml.element.Element.ElementType; import org.x4o.xml.element.ElementException; import org.x4o.xml.element.ElementNamespaceContext; import org.x4o.xml.element.ElementNamespaceInstanceProvider; +import org.x4o.xml.io.DefaultX4OReader; import org.x4o.xml.io.sax.ext.AttributeMap; +import org.x4o.xml.io.sax.ext.PropertyConfig; import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguageProperty; import org.xml.sax.Attributes; import org.xml.sax.Locator; import org.xml.sax.SAXException; @@ -67,16 +68,19 @@ public class X4OContentHandler extends DefaultHandler2 { /** Store the override element handler */ private DefaultHandler2 overrideSaxHandler = null; - + + private final PropertyConfig propertyConfig; + /** * Creates an X4OTagHandler * which can receice sax xml events and converts them into the Element* interfaces events. */ - public X4OContentHandler(X4OLanguageContext elementLanguage) { + public X4OContentHandler(X4OLanguageContext elementLanguage,PropertyConfig propertyConfig) { logger = Logger.getLogger(X4OContentHandler.class.getName()); loggerFinest = logger.isLoggable(Level.FINEST); elementStack = new Stack(); this.elementLanguage = elementLanguage; + this.propertyConfig = propertyConfig; } /** @@ -124,7 +128,7 @@ public class X4OContentHandler extends DefaultHandler2 { ElementNamespaceContext enc = elementLanguage.getLanguage().findElementNamespaceContext(namespaceUri); if (enc==null) { if ("".equals(namespaceUri)) { - String configEmptryUri = (String)elementLanguage.getLanguageProperty(X4OLanguageProperty.READER_EMPTY_NAMESPACE_URI); + String configEmptryUri = propertyConfig.getPropertyString(DefaultX4OReader.DOC_EMPTY_NAMESPACE_URI); if (configEmptryUri!=null) { namespaceUri = configEmptryUri; enc = elementLanguage.getLanguage().findElementNamespaceContext(namespaceUri); diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OContentParser.java b/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OContentParser.java index 3da28cf..0ed630b 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OContentParser.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OContentParser.java @@ -22,9 +22,11 @@ */ package org.x4o.xml.io.sax; +import org.x4o.xml.eld.EldDriver; import org.x4o.xml.element.ElementException; +import org.x4o.xml.io.DefaultX4OReader; +import org.x4o.xml.io.sax.ext.PropertyConfig; import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguageProperty; import org.xml.sax.InputSource; import org.xml.sax.SAXException; import org.xml.sax.XMLReader; @@ -32,6 +34,8 @@ import org.xml.sax.helpers.XMLReaderFactory; import java.io.IOException; import java.io.InputStream; +import java.util.ArrayList; +import java.util.HashMap; import java.util.List; import java.util.Map; @@ -43,6 +47,16 @@ import java.util.Map; */ public class X4OContentParser { + private final PropertyConfig propertyConfig; + + public X4OContentParser(PropertyConfig propertyConfig) { + this.propertyConfig=propertyConfig; + } + + private PropertyConfig getPropertyConfig() { + return propertyConfig; + } + public void parse(X4OLanguageContext languageContext) throws SAXException, IOException { // If xsd caching is needed this should be the way @@ -51,23 +65,23 @@ public class X4OContentParser { //SAXParser parser = new SAXParser(config); // Create Sax parser with x4o tag handler - X4OContentHandler xth = new X4OContentHandler(languageContext); + X4OContentHandler xth = new X4OContentHandler(languageContext,getPropertyConfig()); XMLReader saxParser = XMLReaderFactory.createXMLReader(); - saxParser.setErrorHandler(new X4OErrorHandler(languageContext)); - saxParser.setEntityResolver(new X4OEntityResolver(languageContext)); + saxParser.setErrorHandler(new X4OErrorHandler(languageContext,getPropertyConfig())); + saxParser.setEntityResolver(new X4OEntityResolver(languageContext,getPropertyConfig())); saxParser.setContentHandler(xth); saxParser.setProperty("http://xml.org/sax/properties/lexical-handler", xth); saxParser.setProperty("http://xml.org/sax/properties/declaration-handler",xth); // Set properties and optional - Map saxParserProperties = languageContext.getLanguage().getLanguageConfiguration().getSAXParserProperties(languageContext); + Map saxParserProperties = getSAXParserProperties(languageContext); for (Map.Entry entry:saxParserProperties.entrySet()) { String name = entry.getKey(); Object value= entry.getValue(); saxParser.setProperty(name, value); debugMessage("Set SAX property: "+name+" to: "+value,languageContext); } - Map saxParserPropertiesOptional = languageContext.getLanguage().getLanguageConfiguration().getSAXParserPropertiesOptional(languageContext); + Map saxParserPropertiesOptional = getSAXParserPropertiesOptional(languageContext); for (Map.Entry entry:saxParserPropertiesOptional.entrySet()) { String name = entry.getKey(); Object value= entry.getValue(); @@ -80,13 +94,13 @@ public class X4OContentParser { } // Set sax features and optional - Map features = languageContext.getLanguage().getLanguageConfiguration().getSAXParserFeatures(languageContext); + Map features = getSAXParserFeatures(languageContext); for (String key:features.keySet()) { Boolean value=features.get(key); saxParser.setFeature(key, value); debugMessage("Set SAX feature: "+key+" to: "+value,languageContext); } - Map featuresOptional = languageContext.getLanguage().getLanguageConfiguration().getSAXParserFeaturesOptional(languageContext); + Map featuresOptional = getSAXParserFeaturesOptional(languageContext); for (String key:featuresOptional.keySet()) { Boolean value=featuresOptional.get(key); try { @@ -98,7 +112,7 @@ public class X4OContentParser { } // check for required features - List requiredFeatures = languageContext.getLanguage().getLanguageConfiguration().getSAXParserFeaturesRequired(languageContext); + List requiredFeatures = getSAXParserFeaturesRequired(languageContext); for (String requiredFeature:requiredFeatures) { debugMessage("Checking required SAX feature: "+requiredFeature,languageContext); if (saxParser.getFeature(requiredFeature)==false) { @@ -107,21 +121,21 @@ public class X4OContentParser { } // Finally start parsing the xml input stream - Object requestInputSource = languageContext.getLanguageProperty(X4OLanguageProperty.READER_INPUT_SOURCE); + Object requestInputSource = getPropertyConfig().getProperty(DefaultX4OReader.INPUT_SOURCE); InputSource input = null; InputStream inputStream = null; if (requestInputSource instanceof InputSource) { input = (InputSource)requestInputSource; } else { - inputStream = (InputStream)languageContext.getLanguageProperty(X4OLanguageProperty.READER_INPUT_STREAM); + inputStream = (InputStream)getPropertyConfig().getProperty(DefaultX4OReader.INPUT_STREAM); input = new InputSource(inputStream); } - Object requestInputEncoding = languageContext.getLanguageProperty(X4OLanguageProperty.READER_INPUT_ENCODING); + Object requestInputEncoding = getPropertyConfig().getProperty(DefaultX4OReader.INPUT_ENCODING); if (requestInputEncoding!=null && requestInputEncoding instanceof String) { input.setEncoding(requestInputEncoding.toString()); } - Object requestSystemId = languageContext.getLanguageProperty(X4OLanguageProperty.READER_INPUT_SYSTEM_ID); + Object requestSystemId = getPropertyConfig().getProperty(DefaultX4OReader.INPUT_SYSTEM_ID); if (requestSystemId!=null && requestSystemId instanceof String) { input.setSystemId(requestSystemId.toString()); } @@ -144,4 +158,105 @@ public class X4OContentParser { } } } + + /** + * @see org.x4o.xml.lang.X4OLanguageConfiguration#getSAXParserProperties(org.x4o.xml.lang.X4OLanguageContext) + */ + public Map getSAXParserProperties(X4OLanguageContext elementContext) { + Map saxParserProperties = new HashMap(1); + return saxParserProperties; + } + + /** + * @see org.x4o.xml.lang.X4OLanguageConfiguration#getSAXParserPropertiesOptional(org.x4o.xml.lang.X4OLanguageContext) + */ + public Map getSAXParserPropertiesOptional(X4OLanguageContext elementContext) { + Map saxParserProperties = new HashMap(1); + saxParserProperties.put("http://apache.org/xml/properties/input-buffer-size",getPropertyConfig().getProperty(DefaultX4OReader.DOC_BUFFER_SIZE)); // Increase buffer to 8KB + return saxParserProperties; + } + + /** + * @see org.x4o.xml.lang.X4OLanguageConfiguration#getSAXParserFeatures(org.x4o.xml.lang.X4OLanguageContext) + */ + public Map getSAXParserFeatures(X4OLanguageContext elementContext) { + + // see example: http://xerces.apache.org/xerces2-j/features.html + Map saxParserFeatures = new HashMap(20); + + // Tune Sax Parser + saxParserFeatures.put("http://xml.org/sax/features/namespaces", true); // Perform namespace processing + saxParserFeatures.put("http://xml.org/sax/features/use-entity-resolver2", true); // Use EntityResolver2 interface + saxParserFeatures.put("http://xml.org/sax/features/lexical-handler/parameter-entities", true); // Report parameter entities to a the LexicalHandler. + + saxParserFeatures.put("http://xml.org/sax/features/xmlns-uris", false); // Namespace declaration attributes are reported as having no namespace. + saxParserFeatures.put("http://xml.org/sax/features/namespace-prefixes", false); // Do not report attributes used for Namespace declarations + + saxParserFeatures.put("http://xml.org/sax/features/external-general-entities", false); // Never include the external general entries. + saxParserFeatures.put("http://xml.org/sax/features/external-parameter-entities", false); // Never include the external parameter or DTD subset. + + saxParserFeatures.put("http://apache.org/xml/features/xinclude", true); // Perform XInclude processing + saxParserFeatures.put("http://apache.org/xml/features/xinclude/fixup-base-uris", false); + saxParserFeatures.put("http://apache.org/xml/features/xinclude/fixup-language", false); + + boolean validation = false; + boolean validationXsd = false; + if (EldDriver.LANGUAGE_NAME.equals(elementContext.getLanguage().getLanguageName())) { + validation = false; //TODO: elementContext.getLanguagePropertyBoolean(X4OLanguageProperty.VALIDATION_ELD); + validationXsd = false; //elementContext.getLanguagePropertyBoolean(X4OLanguageProperty.VALIDATION_ELD_XSD); + } else { + validation = getPropertyConfig().getPropertyBoolean(DefaultX4OReader.VALIDATION_INPUT_DOC); + validationXsd = getPropertyConfig().getPropertyBoolean(DefaultX4OReader.VALIDATION_INPUT_SCHEMA); + } + if (validation) { + saxParserFeatures.put("http://xml.org/sax/features/validation", true); // Validate the document and report validity errors. + saxParserFeatures.put("http://apache.org/xml/features/validation/schema", true); // Insert an XML Schema validator into the pipeline. + } else { + saxParserFeatures.put("http://xml.org/sax/features/validation", false); + saxParserFeatures.put("http://apache.org/xml/features/validation/schema", false); + } + if (validation && validationXsd) { + saxParserFeatures.put("http://apache.org/xml/features/validation/schema-full-checking", true); // Enable validation of the schema grammar itself for errors. + } else { + saxParserFeatures.put("http://apache.org/xml/features/validation/schema-full-checking", false); // Disable validation of the schema grammar itself for errors. + } + + + return saxParserFeatures; + } + + /** + * @see org.x4o.xml.lang.X4OLanguageConfiguration#getSAXParserFeaturesOptional(org.x4o.xml.lang.X4OLanguageContext) + */ + public Map getSAXParserFeaturesOptional(X4OLanguageContext elementContext) { + Map saxParserFeatures = new HashMap(20); + + // Make Sax Impl more strict. + saxParserFeatures.put("http://apache.org/xml/features/disallow-doctype-decl", true); // Throws error if document contains a DOCTYPE declaration. + saxParserFeatures.put("http://apache.org/xml/features/validation/schema/normalized-value", true); // Expose normalized values for attributes and elements. + saxParserFeatures.put("http://apache.org/xml/features/validation/warn-on-duplicate-attdef", true); // Report a warning when a duplicate attribute is re-declared. + saxParserFeatures.put("http://apache.org/xml/features/warn-on-duplicate-entitydef", true); // Report a warning for duplicate entity declaration. + saxParserFeatures.put("http://apache.org/xml/features/validation/dynamic", false); // Validation is determined by the state of the validation feature. + saxParserFeatures.put("http://apache.org/xml/features/nonvalidating/load-dtd-grammar", false); // Do not use the default DTD grammer + saxParserFeatures.put("http://apache.org/xml/features/nonvalidating/load-external-dtd", false); // Ignore the external DTD completely. + + // need newer version + //saxParserFeatures.put("http://apache.org/xml/features/standard-uri-conformant", true); // Requires that a URI has to be provided where a URI is expected. + //saxParserFeatures.put("http://apache.org/xml/features/validation/warn-on-undeclared-elemdef", true); // Report a warning if an element referenced in a content model is not declared. + //saxParserFeatures.put("http://apache.org/xml/features/validation/balance-syntax-trees", false); // No optimize DTD content models. + //saxParserFeatures.put("http://apache.org/xml/features/validation/unparsed-entity-checking", false); // Do not check that each value of type ENTITY in DTD. + + return saxParserFeatures; + } + + /** + * @see org.x4o.xml.lang.X4OLanguageConfiguration#getSAXParserFeaturesRequired(org.x4o.xml.lang.X4OLanguageContext) + */ + public List getSAXParserFeaturesRequired(X4OLanguageContext elementContext) { + List result = new ArrayList(5); + result.add("http://xml.org/sax/features/use-attributes2"); // Attributes objects passed by the parser are ext.Attributes2 interface. + result.add("http://xml.org/sax/features/use-locator2"); // Locator objects passed by the parser are org.xml.sax.ext.Locator2 interface. + result.add("http://xml.org/sax/features/xml-1.1"); // The parser supports both XML 1.0 and XML 1.1. + return result; + } } diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4ODebugWriter.java b/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4ODebugWriter.java index ebba198..764b467 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4ODebugWriter.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4ODebugWriter.java @@ -44,7 +44,6 @@ import org.x4o.xml.io.sax.ext.ContentWriter; import org.x4o.xml.lang.X4OLanguageModule; import org.x4o.xml.lang.X4OLanguageContext; import org.x4o.xml.lang.X4OLanguageConfiguration; -import org.x4o.xml.lang.X4OLanguageProperty; import org.x4o.xml.lang.phase.X4OPhase; import org.x4o.xml.lang.phase.X4OPhaseException; import org.x4o.xml.lang.phase.X4OPhaseListener; @@ -114,6 +113,7 @@ public class X4ODebugWriter { } } + /* public void debugLanguageProperties(X4OLanguageContext ec) throws ElementException { try { AttributesImpl atts = new AttributesImpl(); @@ -134,6 +134,7 @@ public class X4ODebugWriter { throw new ElementException(e); } } + */ public void debugLanguageDefaultClasses(X4OLanguageContext ec) throws ElementException { try { @@ -428,7 +429,7 @@ public class X4ODebugWriter { atts.addAttribute ("", "language", "", "", elementLanguage.getLanguage().getLanguageName()); atts.addAttribute ("", "languageVersion", "", "", elementLanguage.getLanguage().getLanguageVersion()); atts.addAttribute ("", "className", "", "", elementLanguage.getClass().getName()+""); - atts.addAttribute ("", "currentX4OPhase", "", "", elementLanguage.getCurrentPhase().getId()); + atts.addAttribute ("", "currentX4OPhase", "", "", elementLanguage.getPhaseCurrent().getId()); contentWriter.startElement (DEBUG_URI, "printElementLanguage", "", atts); contentWriter.endElement(DEBUG_URI, "printElementLanguage", ""); } diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OEntityResolver.java b/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OEntityResolver.java index 450cc23..e8ffc37 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OEntityResolver.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OEntityResolver.java @@ -31,10 +31,11 @@ import java.util.Map; import java.util.logging.Logger; import org.x4o.xml.element.ElementNamespaceContext; +import org.x4o.xml.io.DefaultX4OReader; +import org.x4o.xml.io.sax.ext.PropertyConfig; import org.x4o.xml.lang.X4OLanguageModule; import org.x4o.xml.lang.X4OLanguageContext; import org.x4o.xml.lang.X4OLanguageClassLoader; -import org.x4o.xml.lang.X4OLanguageProperty; import org.xml.sax.EntityResolver; import org.xml.sax.InputSource; import org.xml.sax.SAXException; @@ -55,21 +56,21 @@ public class X4OEntityResolver implements EntityResolver { private Logger logger = null; private URL basePath = null; - private X4OLanguageContext elementContext = null; private Map schemaResources = null; private Map schemaPathResources = null; + private final PropertyConfig propertyConfig; /** * Creates an X4OEntityResolver for a language. * @param elementContext The x4o language to resolve entities for. */ - public X4OEntityResolver(X4OLanguageContext elementContext) { + public X4OEntityResolver(X4OLanguageContext elementContext,PropertyConfig propertyConfig) { if (elementContext==null) { throw new NullPointerException("Can't provide entities with null elementContext."); } this.logger=Logger.getLogger(X4OEntityResolver.class.getName()); - this.elementContext=elementContext; - this.basePath=(URL)elementContext.getLanguageProperty(X4OLanguageProperty.READER_INPUT_BASE_PATH); + this.propertyConfig=propertyConfig; + this.basePath=(URL)propertyConfig.getProperty(DefaultX4OReader.INPUT_BASE_PATH); this.schemaResources=new HashMap(20); this.schemaPathResources=new HashMap(20); for (X4OLanguageModule mod:elementContext.getLanguage().getLanguageModules()) { @@ -111,7 +112,7 @@ public class X4OEntityResolver implements EntityResolver { logger.finer("Fetch sysId: "+systemId+" pubId: "+publicId); // Check if other resolver has resource - EntityResolver resolver = (EntityResolver)elementContext.getLanguageProperty(X4OLanguageProperty.READER_ENTITY_RESOLVER); + EntityResolver resolver = (EntityResolver)propertyConfig.getProperty(DefaultX4OReader.SAX_ENTITY_RESOLVER); if (resolver!=null) { InputSource result = resolver.resolveEntity(publicId, systemId); if (result!=null) { @@ -121,7 +122,7 @@ public class X4OEntityResolver implements EntityResolver { // Check if we have it on user defined schema base path if (schemaPathResources.containsKey(systemId)) { - File schemaBasePath = (File)elementContext.getLanguageProperty(X4OLanguageProperty.READER_VALIDATION_SCHEMA_PATH); + File schemaBasePath = (File)propertyConfig.getProperty(DefaultX4OReader.VALIDATION_SCHEMA_PATH); if (schemaBasePath!=null && schemaBasePath.exists()) { String schemeResource = schemaResources.get(systemId); File schemaFile = new File(schemaBasePath.getAbsolutePath()+File.separatorChar+schemeResource); diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OErrorHandler.java b/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OErrorHandler.java index 8e28cd4..85ff1a2 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OErrorHandler.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/sax/X4OErrorHandler.java @@ -23,8 +23,9 @@ package org.x4o.xml.io.sax; import org.x4o.xml.element.ElementException; +import org.x4o.xml.io.DefaultX4OReader; +import org.x4o.xml.io.sax.ext.PropertyConfig; import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguageProperty; import org.xml.sax.ErrorHandler; import org.xml.sax.SAXException; import org.xml.sax.SAXParseException; @@ -44,12 +45,12 @@ public class X4OErrorHandler implements ErrorHandler { * Construct a new SAXErrorPrinter * @param languageContext The language to get errors to. */ - public X4OErrorHandler(X4OLanguageContext languageContext) { + public X4OErrorHandler(X4OLanguageContext languageContext,PropertyConfig propertyConfig) { if (languageContext==null) { throw new NullPointerException("Can't debug and proxy errors with null languageContext."); } this.languageContext=languageContext; - this.errorHandler=(ErrorHandler)languageContext.getLanguageProperty(X4OLanguageProperty.READER_ERROR_HANDLER); + this.errorHandler=(ErrorHandler)propertyConfig.getProperty(DefaultX4OReader.SAX_ERROR_HANDLER); } /** diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/AbstractContentWriter.java b/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/AbstractContentWriter.java index 8fff353..23d5453 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/AbstractContentWriter.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/AbstractContentWriter.java @@ -35,8 +35,8 @@ import org.xml.sax.SAXException; */ public abstract class AbstractContentWriter extends AbstractContentWriterLexical implements ContentWriter { - public AbstractContentWriter(Writer out, String encoding,String charNewLine, String charTab) { - super(out, encoding, charNewLine, charTab); + public AbstractContentWriter(Writer out) { + super(out); } /** diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/AbstractContentWriterHandler.java b/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/AbstractContentWriterHandler.java index 7d78ef0..17b34f0 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/AbstractContentWriterHandler.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/AbstractContentWriterHandler.java @@ -32,6 +32,7 @@ import java.util.Set; import java.util.Stack; import org.x4o.xml.io.XMLConstants; +import org.x4o.xml.io.sax.ext.PropertyConfig.PropertyConfigItem; import org.xml.sax.Attributes; import org.xml.sax.ContentHandler; import org.xml.sax.Locator; @@ -47,9 +48,7 @@ import org.xml.sax.helpers.AttributesImpl; public class AbstractContentWriterHandler implements ContentHandler { protected final Attributes EMPTY_ATTRIBUTES = new AttributesImpl(); - protected String encoding = null; - private String charNewline = null; - private String charTab = null; + private final PropertyConfig propertyConfig; private Writer out = null; private int indent = 0; private Map prefixMapping = null; @@ -59,38 +58,41 @@ public class AbstractContentWriterHandler implements ContentHandler { private String lastElement = null; private Stack elements = null; + private final static String PROPERTY_CONTEXT_PREFIX = PropertyConfig.X4O_PROPERTIES_PREFIX+PropertyConfig.X4O_PROPERTIES_WRITER_XML; + private final static String PROPERTY_ENCODING = "output/encoding"; + private final static String PROPERTY_CHAR_TAB = "output/charTab"; + private final static String PROPERTY_CHAR_NEWLINE = "output/newLine"; + + public final static PropertyConfig DEFAULT_PROPERTY_CONFIG; + public final static String OUTPUT_ENCODING = PROPERTY_CONTEXT_PREFIX+PROPERTY_ENCODING; + public final static String OUTPUT_CHAR_TAB = PROPERTY_CONTEXT_PREFIX+PROPERTY_CHAR_TAB; + public final static String OUTPUT_CHAR_NEWLINE = PROPERTY_CONTEXT_PREFIX+PROPERTY_CHAR_NEWLINE; + + static { + DEFAULT_PROPERTY_CONFIG = new PropertyConfig(true,null,PROPERTY_CONTEXT_PREFIX, + new PropertyConfigItem(PROPERTY_ENCODING,String.class,XMLConstants.XML_DEFAULT_ENCODING), + new PropertyConfigItem(PROPERTY_CHAR_TAB,String.class,XMLConstants.CHAR_TAB+""), + new PropertyConfigItem(PROPERTY_CHAR_NEWLINE,String.class,XMLConstants.CHAR_NEWLINE+"") + ); + } + /** * Creates XmlWriter which prints to the Writer interface. * @param out The writer to print the xml to. */ - public AbstractContentWriterHandler(Writer out,String encoding,String charNewLine,String charTab) { + public AbstractContentWriterHandler(Writer out) { if (out==null) { throw new NullPointerException("Can't write on null writer."); } - if (encoding==null) { - encoding = XMLConstants.XML_DEFAULT_ENCODING; - } - if (charNewLine==null) { - charNewLine = XMLConstants.CHAR_NEWLINE+""; - } - if (charTab==null) { - charTab = XMLConstants.CHAR_TAB+""; - } this.out = out; - this.encoding = encoding; - this.charNewline = charNewLine; - this.charTab = charTab; prefixMapping = new HashMap(15); printedMappings = new ArrayList(15); elements = new Stack(); - /* - ContentConfig conf = new ContentConfig( - new ContentConfigItem("writer/output/encoding",String.class,XMLConstants.XML_DEFAULT_ENCODING), - new ContentConfigItem("content/writer/output/charTab",String.class) - ); - conf.getPropertyString(""); - */ - + propertyConfig = new PropertyConfig(DEFAULT_PROPERTY_CONFIG,PROPERTY_CONTEXT_PREFIX); + } + + public PropertyConfig getPropertyConfig() { + return propertyConfig; } // TODO: check location of this. (add to api?) @@ -114,7 +116,7 @@ public class AbstractContentWriterHandler implements ContentHandler { */ public void startDocument() throws SAXException { indent = 0; - write(XMLConstants.getDocumentDeclaration(encoding)); + write(XMLConstants.getDocumentDeclaration(getPropertyConfig().getPropertyString(OUTPUT_ENCODING))); } /** @@ -143,9 +145,9 @@ public class AbstractContentWriterHandler implements ContentHandler { } autoCloseStartElement(); startElement = new StringBuffer(200); - startElement.append(charNewline); + startElement.append(getPropertyConfig().getPropertyString(OUTPUT_CHAR_NEWLINE)); for (int i = 0; i < indent; i++) { - startElement.append(charTab); + startElement.append(getPropertyConfig().getPropertyString(OUTPUT_CHAR_TAB)); } startElement.append(XMLConstants.TAG_OPEN); @@ -208,7 +210,7 @@ public class AbstractContentWriterHandler implements ContentHandler { printedMappings.add(uri2); if (first) { - startElement.append(charNewline); + startElement.append(getPropertyConfig().getPropertyString(OUTPUT_CHAR_NEWLINE)); first = false; } @@ -221,7 +223,7 @@ public class AbstractContentWriterHandler implements ContentHandler { startElement.append("=\""); startElement.append(uri2); startElement.append('"'); - startElement.append(charNewline); + startElement.append(getPropertyConfig().getPropertyString(OUTPUT_CHAR_NEWLINE)); } } } @@ -251,7 +253,7 @@ public class AbstractContentWriterHandler implements ContentHandler { if (printNewLine) { startElement.append(XMLConstants.CHAR_NEWLINE); for (int ii = 0; ii < indent+1; ii++) { - startElement.append(charTab); + startElement.append(getPropertyConfig().getPropertyString(OUTPUT_CHAR_TAB)); } } } @@ -281,7 +283,7 @@ public class AbstractContentWriterHandler implements ContentHandler { indent--; if (printReturn || !localName.equals(lastElement)) { - write(charNewline); + write(getPropertyConfig().getPropertyString(OUTPUT_CHAR_NEWLINE)); writeIndent(); } else { printReturn = true; @@ -433,7 +435,7 @@ public class AbstractContentWriterHandler implements ContentHandler { throw new SAXException("Processing instruction data is invalid char; '"+data+"'"); } autoCloseStartElement(); - write(charNewline); + write(getPropertyConfig().getPropertyString(OUTPUT_CHAR_NEWLINE)); writeIndent(); write(XMLConstants.PROCESS_START); write(target); @@ -487,11 +489,11 @@ public class AbstractContentWriterHandler implements ContentHandler { } autoCloseStartElement(); checkPrintedReturn(text); - write(charNewline); + write(getPropertyConfig().getPropertyString(OUTPUT_CHAR_NEWLINE)); writeIndent(); write(XMLConstants.COMMENT_START); write(" "); - write(XMLConstants.escapeCharactersComment(text,charTab,indent)); + write(XMLConstants.escapeCharactersComment(text,getPropertyConfig().getPropertyString(OUTPUT_CHAR_TAB),indent)); write(" "); write(XMLConstants.COMMENT_END); printReturn = true; @@ -528,7 +530,7 @@ public class AbstractContentWriterHandler implements ContentHandler { */ private void writeIndent() throws SAXException { for (int i = 0; i < indent; i++) { - write(charTab); + write(getPropertyConfig().getPropertyString(OUTPUT_CHAR_TAB)); } } diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/AbstractContentWriterLexical.java b/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/AbstractContentWriterLexical.java index 902b43a..397f47d 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/AbstractContentWriterLexical.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/AbstractContentWriterLexical.java @@ -42,8 +42,8 @@ public abstract class AbstractContentWriterLexical extends AbstractContentWriter * Creates XmlWriter which prints to the Writer interface. * @param out The writer to print the xml to. */ - public AbstractContentWriterLexical(Writer out,String encoding,String charNewLine,String charTab) { - super(out, encoding, charNewLine, charTab); + public AbstractContentWriterLexical(Writer out) { + super(out); } /** diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/ContentConfig.java b/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/ContentConfig.java deleted file mode 100644 index bea1743..0000000 --- a/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/ContentConfig.java +++ /dev/null @@ -1,158 +0,0 @@ -/* - * Copyright (c) 2004-2013, Willem Cazander - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without modification, are permitted provided - * that the following conditions are met: - * - * * Redistributions of source code must retain the above copyright notice, this list of conditions and the - * following disclaimer. - * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and - * the following disclaimer in the documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL - * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT - * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR - * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -package org.x4o.xml.io.sax.ext; - -import java.util.HashMap; -import java.util.Map; - -/** - * ContentConfig Defines checked config options. - * - * @author Willem Cazander - * @version 1.0 May 1, 2013 - */ -public final class ContentConfig { - - private final ContentConfigItem[] items; - private final Map itemKeys; - - public ContentConfig(ContentConfigItem...items) { - this.items=items; - itemKeys = new HashMap(items.length); - for (int i=0;i valueType = null; - private Object defaultValue = null; - private Object value = null; - - public ContentConfigItem(String key,Class valueType) { - this(key,valueType,null); - } - public ContentConfigItem(String key,Class valueType,Object defaultValue) { - setKey(key); - setValueType(valueType); - setDefaultValue(defaultValue); - } - /** - * @return the key - */ - public String getKey() { - return key; - } - /** - * @param key the key to set - */ - public void setKey(String key) { - this.key = key; - } - /** - * @return the valueType - */ - public Class getValueType() { - return valueType; - } - /** - * @param valueType the valueType to set - */ - public void setValueType(Class valueType) { - this.valueType = valueType; - } - /** - * @return the defaultValue - */ - public Object getDefaultValue() { - return defaultValue; - } - /** - * @param defaultValue the defaultValue to set - */ - public void setDefaultValue(Object defaultValue) { - this.defaultValue = defaultValue; - } - /** - * @return the value - */ - public Object getValue() { - return value; - } - /** - * @param value the value to set - */ - public void setValue(Object value) { - this.value = value; - } - } - - private final ContentConfigItem getContentConfigItem(String key) { - Integer keyIdx = itemKeys.get(key); - if (keyIdx==null) { - throw new IllegalArgumentException("Could not find config item for: "+key); - } - ContentConfigItem item = items[keyIdx]; - return item; - } - - public final void setProperty(String key,Object value) { - ContentConfigItem item = getContentConfigItem(key); - item.setValue(value); - } - - public final Object getProperty(String key) { - ContentConfigItem item = getContentConfigItem(key); - return item.getValue(); - } - - public final boolean getPropertyBoolean(String key) { - ContentConfigItem item = getContentConfigItem(key); - Object value = item.getValue(); - if (value instanceof Boolean) { - return (Boolean)value; - } - - return (Boolean)item.getDefaultValue(); - } - - public final int getPropertyInteger(String key) { - ContentConfigItem item = getContentConfigItem(key); - Object value = item.getValue(); - if (value instanceof Integer) { - return (Integer)value; - } - return (Integer)item.getDefaultValue(); - } - - public final String getPropertyString(String key) { - ContentConfigItem item = getContentConfigItem(key); - Object value = item.getValue(); - if (value instanceof String) { - return (String)value; - } - return (String)item.getDefaultValue(); - } -} diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/ContentWriterHtml.java b/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/ContentWriterHtml.java index 6c8daaa..46aa3cb 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/ContentWriterHtml.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/ContentWriterHtml.java @@ -36,8 +36,8 @@ import org.xml.sax.helpers.AttributesImpl; */ public class ContentWriterHtml extends ContentWriterXmlTag { - public ContentWriterHtml(Writer out,String encoding,String charNewLine,String charTab) { - super(out,encoding,charNewLine,charTab); + public ContentWriterHtml(Writer out,String encoding) { + super(out,encoding); } public void printDocType(DocType doc) throws SAXException { @@ -69,7 +69,7 @@ public class ContentWriterHtml extends ContentWriterXmlTag> extends ContentWriterXml implements ContentWriterTag { - public ContentWriterXmlTag(Writer out,String encoding,String charNewLine,String charTab) { - super(out, encoding, charNewLine, charTab); + public ContentWriterXmlTag(Writer out,String encoding) { + super(out, encoding); } public String getTagNamespaceUri() { diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/ContentWriterXsd.java b/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/ContentWriterXsd.java index ac3a3e0..c1cc671 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/ContentWriterXsd.java +++ b/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/ContentWriterXsd.java @@ -36,8 +36,8 @@ import org.xml.sax.helpers.AttributesImpl; */ public class ContentWriterXsd extends ContentWriterXmlTag { - public ContentWriterXsd(Writer out,String encoding,String charNewLine,String charTab) { - super(out,encoding,charNewLine,charTab); + public ContentWriterXsd(Writer out,String encoding) { + super(out,encoding); } public String getTagNamespaceUri() { diff --git a/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/PropertyConfig.java b/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/PropertyConfig.java new file mode 100644 index 0000000..a5a2c2c --- /dev/null +++ b/x4o-driver/src/main/java/org/x4o/xml/io/sax/ext/PropertyConfig.java @@ -0,0 +1,248 @@ +/* + * Copyright (c) 2004-2013, Willem Cazander + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted provided + * that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT + * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.x4o.xml.io.sax.ext; + +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +/** + * ContentConfig Defines checked config options. + * + * @author Willem Cazander + * @version 1.0 May 1, 2013 + */ +public final class PropertyConfig { + + private final Map items; + private final boolean readOnly; + + // TODO: move to ? + public final static String X4O_PROPERTIES_PREFIX = "http://language.x4o.org/xml/properties/"; + public final static String X4O_PROPERTIES_READER = "reader/x4o/"; + public final static String X4O_PROPERTIES_READER_DTD = "reader/dtd/"; + public final static String X4O_PROPERTIES_WRITER = "writer/x4o/"; + public final static String X4O_PROPERTIES_WRITER_XML = "writer/xml/"; + public final static String X4O_PROPERTIES_WRITER_XSD = "writer/xsd/"; + public final static String X4O_PROPERTIES_WRITER_DTD = "writer/dtd/"; + public final static String X4O_PROPERTIES_WRITER_HTML = "writer/html/"; + + public PropertyConfig(String prefix,PropertyConfigItem...items) { + this(false,null,prefix,items); + } + + public PropertyConfig(PropertyConfig parentPropertyConfig,String prefix,PropertyConfigItem...items) { + this(false,parentPropertyConfig,prefix,items); + } + + public PropertyConfig(boolean readOnly,PropertyConfig parentPropertyConfig,String prefix,PropertyConfigItem...itemConfig) { + if (prefix==null) { + throw new NullPointerException("Can't create PropertyConfig with null prefix."); + } + this.readOnly=readOnly; + Map fillItems = new HashMap(itemConfig.length); + fillPropertyConfigItems(fillItems,appendSlashIfMissing(prefix),itemConfig); + copyParentPropertyConfig(fillItems,parentPropertyConfig); + if (fillItems.isEmpty()) { + throw new IllegalArgumentException("Can't create PropertyConfig with zero PropertyConfigItems."); + } + for (String key:fillItems.keySet()) { + fillItems.put(key,fillItems.get(key).clone()); + } + items = Collections.unmodifiableMap(fillItems); + } + + private final String appendSlashIfMissing(String prefix) { + if (prefix.endsWith("/")==false) { + prefix += "/"; + } + return prefix; + } + + private final void fillPropertyConfigItems(Map fillItems,String prefix,PropertyConfigItem...itemConfig) { + for (int i=0;i fillItems,PropertyConfig parentPropertyConfig) { + if (parentPropertyConfig==null) { + return; + } + for (String key:parentPropertyConfig.getPropertyKeys()) { + fillItems.put(key, parentPropertyConfig.getPropertyConfigItem(key)); + } + } + + public static final class PropertyConfigItem implements Cloneable { + private final String valueKey; + private final Class valueType; + private final Object valueDefault; + private final boolean valueLock; // TODO: check if possible + private Object value = null; + + public PropertyConfigItem(String valueKey,Class valueType) { + this(valueKey,valueType,null,false); + } + + public PropertyConfigItem(String valueKey,Class valueType,Object valueDefault) { + this(valueKey,valueType,valueDefault,false); + } + + private PropertyConfigItem(String valueKey,Class valueType,Object valueDefault,boolean valueLock) { + this.valueKey=valueKey; + this.valueType=valueType; + this.valueLock=valueLock; + this.valueDefault=valueDefault; + } + + /** + * @return the value key. + */ + public String getValueKey() { + return valueKey; + } + + /** + * @return the valueType + */ + public Class getValueType() { + return valueType; + } + + /** + * @return the value default. + */ + public Object getValueDefault() { + return valueDefault; + } + + /** + * @return the valueLock + */ + public boolean isValueLock() { + return valueLock; + } + + /** + * @return the value + */ + public Object getValue() { + return value; + } + + /** + * @param value the value to set + */ + public void setValue(Object value) { + this.value = value; + } + + /** + * @see java.lang.Object#clone() + */ + @Override + protected PropertyConfigItem clone() { + PropertyConfigItem clone = new PropertyConfigItem(valueKey,valueType,valueDefault,valueLock); + clone.setValue(getValue()); + return clone; + } + } + + private final PropertyConfigItem getPropertyConfigItem(String key) { + if (key==null) { + throw new NullPointerException("Can't search with null key."); + } + PropertyConfigItem item = items.get(key); + if (item==null) { + throw new IllegalArgumentException("No config item found for key: "+key); + } + return item; + } + + public final Collection getPropertyKeys() { + return Collections.unmodifiableCollection(items.keySet()); + } + + public final void setProperty(String key,Object value) { + if (readOnly) { + throw new IllegalStateException("This property is readonly for key:"+key); + } + PropertyConfigItem item = getPropertyConfigItem(key); + item.setValue(value); + } + + public final Object getProperty(String key) { + PropertyConfigItem item = getPropertyConfigItem(key); + Object value = item.getValue(); + if (value==null) { + value = item.getValueDefault(); + } + return value; + } + + public final Boolean getPropertyBoolean(String key) { + Object value = getProperty(key); + if (value instanceof Boolean) { + return (Boolean)value; + } + if (value==null) { + return null; + } + throw new IllegalStateException("Wrong value type: "+value.getClass()+" for key: "+key); + } + + public final Integer getPropertyInteger(String key) { + Object value = getProperty(key); + if (value instanceof Integer) { + return (Integer)value; + } + if (value==null) { + return null; + } + throw new IllegalStateException("Wrong value type: "+value.getClass()+" for key: "+key); + } + + public final String getPropertyString(String key) { + Object value = getProperty(key); + if (value instanceof String) { + return (String)value; + } + if (value==null) { + return null; + } + throw new IllegalStateException("Wrong value type: "+value.getClass()+" for key: "+key); + } + + public final void copyParentProperties(PropertyConfig config) { + for (String key:getPropertyKeys()) { + Object value = config.getProperty(key); + if (value==null) { + continue; + } + setProperty(key, value); + } + } +} diff --git a/x4o-driver/src/main/java/org/x4o/xml/lang/AbstractX4OLanguageConfiguration.java b/x4o-driver/src/main/java/org/x4o/xml/lang/AbstractX4OLanguageConfiguration.java index 01dc959..ecb7f01 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/lang/AbstractX4OLanguageConfiguration.java +++ b/x4o-driver/src/main/java/org/x4o/xml/lang/AbstractX4OLanguageConfiguration.java @@ -56,13 +56,10 @@ public abstract class AbstractX4OLanguageConfiguration implements X4OLanguageCon private Class defaultLanguageLoader = null; private Class defaultExpressionLanguageContext = null; - private Map globalProperties = null; - /** * Default constructor. */ public AbstractX4OLanguageConfiguration() { - globalProperties = new HashMap(10); } /** @@ -328,25 +325,4 @@ public abstract class AbstractX4OLanguageConfiguration implements X4OLanguageCon Class defaultExpressionLanguageContext) { this.defaultExpressionLanguageContext = defaultExpressionLanguageContext; } - - /** - * @see org.x4o.xml.lang.X4OLanguageConfiguration#getGlobalPropertyKeys() - */ - public Collection getGlobalPropertyKeys() { - return globalProperties.keySet(); - } - - /** - * @see org.x4o.xml.lang.X4OLanguageConfiguration#getGlobalProperty(java.lang.String) - */ - public Object getGlobalProperty(String key) { - return globalProperties.get(key); - } - - /** - * @see org.x4o.xml.lang.X4OLanguageConfigurationLocal#setGlobalProperty(java.lang.String, java.lang.Object) - */ - public void setGlobalProperty(String key, Object value) { - globalProperties.put(key,value); - } } diff --git a/x4o-driver/src/main/java/org/x4o/xml/lang/AbstractX4OLanguageContext.java b/x4o-driver/src/main/java/org/x4o/xml/lang/AbstractX4OLanguageContext.java index 7a848d3..7e6a182 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/lang/AbstractX4OLanguageContext.java +++ b/x4o-driver/src/main/java/org/x4o/xml/lang/AbstractX4OLanguageContext.java @@ -22,6 +22,8 @@ */ package org.x4o.xml.lang; +import java.util.ArrayList; +import java.util.List; import java.util.Map; import java.util.HashMap; import java.util.logging.Logger; @@ -49,12 +51,13 @@ public abstract class AbstractX4OLanguageContext implements X4OLanguageContextLo private ELContext eLContext = null; private ElementAttributeValueParser elementAttributeValueParser = null; private ElementObjectPropertyValue elementObjectPropertyValue = null; - private X4OPhase currentX4OPhase = null; private Map dirtyElements = null; private Element rootElement = null; - private X4ODebugWriter debugWriter; - private Map languageProperties; - + private X4ODebugWriter debugWriter = null; + private X4OPhase phaseCurrent = null; + private String phaseStop = null; + private List phaseSkip = null; + /** * Creates a new empty language context. */ @@ -66,11 +69,9 @@ public abstract class AbstractX4OLanguageContext implements X4OLanguageContextLo logger.finest("Creating new ParsingContext"); this.language=language; dirtyElements = new HashMap(40); - languageProperties = new HashMap(20); - languageProperties.put(X4OLanguageProperty.LANGUAGE_NAME.toUri(), language.getLanguageName()); - languageProperties.put(X4OLanguageProperty.LANGUAGE_VERSION.toUri(), language.getLanguageVersion()); + phaseSkip = new ArrayList(5); } - + public X4OLanguage getLanguage() { return language; } @@ -81,7 +82,7 @@ public abstract class AbstractX4OLanguageContext implements X4OLanguageContextLo public ELContext getExpressionLanguageContext() { return eLContext; } - + /** * @see org.x4o.xml.lang.X4OLanguageContextLocal#setExpressionLanguageContext(javax.el.ELContext) */ @@ -91,14 +92,14 @@ public abstract class AbstractX4OLanguageContext implements X4OLanguageContextLo } eLContext = context; } - + /** * @see org.x4o.xml.lang.X4OLanguageContext#getExpressionLanguageFactory() */ public ExpressionFactory getExpressionLanguageFactory() { return expressionFactory; } - + /** * @see org.x4o.xml.lang.X4OLanguageContextLocal#setExpressionLanguageFactory(javax.el.ExpressionFactory) */ @@ -115,7 +116,7 @@ public abstract class AbstractX4OLanguageContext implements X4OLanguageContextLo public ElementAttributeValueParser getElementAttributeValueParser() { return elementAttributeValueParser; } - + /** * @param elementAttributeValueParser the elementAttributeValueParser to set */ @@ -125,14 +126,14 @@ public abstract class AbstractX4OLanguageContext implements X4OLanguageContextLo } this.elementAttributeValueParser = elementAttributeValueParser; } - + /** * @return the elementObjectPropertyValue */ public ElementObjectPropertyValue getElementObjectPropertyValue() { return elementObjectPropertyValue; } - + /** * @param elementObjectPropertyValue the elementObjectPropertyValue to set */ @@ -142,21 +143,7 @@ public abstract class AbstractX4OLanguageContext implements X4OLanguageContextLo } this.elementObjectPropertyValue = elementObjectPropertyValue; } - - /** - * @see org.x4o.xml.lang.X4OLanguageContext#getCurrentPhase() - */ - public X4OPhase getCurrentPhase() { - return currentX4OPhase; - } - - /** - * @see org.x4o.xml.lang.X4OLanguageContextLocal#setCurrentPhase(org.x4o.xml.lang.phase.X4OPhase) - */ - public void setCurrentPhase(X4OPhase currentX4OPhase) { - this.currentX4OPhase = currentX4OPhase; - } - + /** * @see org.x4o.xml.lang.X4OLanguageContext#addDirtyElement(org.x4o.xml.element.Element, org.x4o.xml.lang.phase.X4OPhase) */ @@ -166,21 +153,21 @@ public abstract class AbstractX4OLanguageContext implements X4OLanguageContextLo } dirtyElements.put(element,phase); } - + /** * @see org.x4o.xml.lang.X4OLanguageContext#getDirtyElements() */ public Map getDirtyElements() { return dirtyElements; } - + /** * @see org.x4o.xml.lang.X4OLanguageContext#getRootElement() */ public Element getRootElement() { return rootElement; } - + /** * @see org.x4o.xml.lang.X4OLanguageContext#setRootElement(org.x4o.xml.element.Element) */ @@ -188,86 +175,69 @@ public abstract class AbstractX4OLanguageContext implements X4OLanguageContextLo if (element==null) { throw new NullPointerException("May not set rootElement to null"); } - // allowed for reusing this context in multiple parse sessions. - //if (rootElement!=null) { - // throw new IllegalStateException("Can't set rootElement when it is already set."); - //} rootElement=element; } - public Object getLanguageProperty(String key) { - return languageProperties.get(key); - } - - public void setLanguageProperty(String key,Object value) { - languageProperties.put(key, value); - } - - /** - * - */ - public Object getLanguageProperty(X4OLanguageProperty property) { - return getLanguageProperty(property.toUri()); - } - - /** - * - */ - public void setLanguageProperty(X4OLanguageProperty property, Object value) { - if (property.isValueValid(value)==false) { - throw new IllegalArgumentException("Now allowed to set value: "+value+" in property: "+property.name()); - } - setLanguageProperty(property.toUri(), value); - } - - /** - * - */ - public boolean getLanguagePropertyBoolean(X4OLanguageProperty property) { - Object value = getLanguageProperty(property); - if (value instanceof Boolean) { - return (Boolean)value; - } - return (Boolean)property.getDefaultValue(); - } - - /** - * - */ - public int getLanguagePropertyInteger(X4OLanguageProperty property) { - Object value = getLanguageProperty(property); - if (value instanceof Integer) { - return (Integer)value; - } - return (Integer)property.getDefaultValue(); - } - - public String getLanguagePropertyString(X4OLanguageProperty property) { - Object value = getLanguageProperty(property); - if (value instanceof String) { - return (String)value; - } - return (String)property.getDefaultValue(); - } - /** * @see org.x4o.xml.lang.X4OLanguageContext#getX4ODebugWriter() */ public X4ODebugWriter getX4ODebugWriter() { return debugWriter; } - + /** * @see org.x4o.xml.lang.X4OLanguageContext#hasX4ODebugWriter() */ public boolean hasX4ODebugWriter() { return debugWriter!=null; } - + /** * @see org.x4o.xml.lang.X4OLanguageContextLocal#setX4ODebugWriter(org.x4o.xml.io.sax.X4ODebugWriter) */ public void setX4ODebugWriter(X4ODebugWriter debugWriter) { this.debugWriter=debugWriter; } + + /** + * @see org.x4o.xml.lang.X4OLanguageContext#getPhaseCurrent() + */ + public X4OPhase getPhaseCurrent() { + return phaseCurrent; + } + + /** + * @see org.x4o.xml.lang.X4OLanguageContextLocal#setPhaseCurrent(org.x4o.xml.lang.phase.X4OPhase) + */ + public void setPhaseCurrent(X4OPhase phaseCurrent) { + this.phaseCurrent = phaseCurrent; + } + + /** + * @see org.x4o.xml.lang.X4OLanguageContext#getPhaseStop() + */ + public String getPhaseStop() { + return phaseStop; + } + + /** + * @see org.x4o.xml.lang.X4OLanguageContext#getPhaseSkip() + */ + public List getPhaseSkip() { + return phaseSkip; + } + + /** + * @see org.x4o.xml.lang.X4OLanguageContextLocal#setPhaseStop(java.lang.String) + */ + public void setPhaseStop(String phaseId) { + this.phaseStop=phaseId; + } + + /** + * @see org.x4o.xml.lang.X4OLanguageContextLocal#addPhaseSkip(java.lang.String) + */ + public void addPhaseSkip(String phaseId) { + phaseSkip.add(phaseId); + } } diff --git a/x4o-driver/src/main/java/org/x4o/xml/lang/DefaultX4OLanguage.java b/x4o-driver/src/main/java/org/x4o/xml/lang/DefaultX4OLanguage.java index 0338f1a..db4195b 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/lang/DefaultX4OLanguage.java +++ b/x4o-driver/src/main/java/org/x4o/xml/lang/DefaultX4OLanguage.java @@ -26,7 +26,6 @@ import java.util.ArrayList; import java.util.List; import java.util.logging.Logger; -import org.x4o.xml.X4ODriver; import org.x4o.xml.el.X4OExpressionFactory; import org.x4o.xml.element.Element; import org.x4o.xml.element.ElementAttributeValueParser; @@ -119,8 +118,8 @@ public class DefaultX4OLanguage implements X4OLanguageLocal { * @throws X4OPhaseException * @see org.x4o.xml.lang.X4OLanguage#createLanguageContext(org.x4o.xml.X4ODriver) */ - public X4OLanguageContext createLanguageContext(X4ODriver driver){ - X4OLanguageContext result = buildElementLanguage(new DefaultX4OLanguageContext(this),driver); + public X4OLanguageContext createLanguageContext() { + X4OLanguageContext result = buildElementLanguage(new DefaultX4OLanguageContext(this)); try { getPhaseManager().runPhases(result, X4OPhaseType.INIT); } catch (X4OPhaseException e) { @@ -129,21 +128,17 @@ public class DefaultX4OLanguage implements X4OLanguageLocal { return result; } - protected X4OLanguageContext buildElementLanguage(X4OLanguageContext languageContext,X4ODriver driver) { + protected X4OLanguageContext buildElementLanguage(X4OLanguageContext languageContext) { if ((languageContext instanceof X4OLanguageContextLocal)==false) { throw new RuntimeException("Can't init X4OLanguageContext which has not X4OLanguageContextLocal interface obj: "+languageContext); } X4OLanguageContextLocal contextInit = (X4OLanguageContextLocal)languageContext; - for (String key:languageContext.getLanguage().getLanguageConfiguration().getGlobalPropertyKeys()) { - Object value = languageContext.getLanguage().getLanguageConfiguration().getGlobalProperty(key); - contextInit.setLanguageProperty(key, value); - } try { if (contextInit.getExpressionLanguageFactory()==null) { - contextInit.setExpressionLanguageFactory(X4OExpressionFactory.createExpressionFactory(contextInit)); + contextInit.setExpressionLanguageFactory(X4OExpressionFactory.createExpressionFactory()); } if (contextInit.getExpressionLanguageContext()==null) { - contextInit.setExpressionLanguageContext(X4OExpressionFactory.createELContext(contextInit)); + contextInit.setExpressionLanguageContext(X4OExpressionFactory.createELContext(contextInit.getLanguage().getLanguageConfiguration().getDefaultExpressionLanguageContext())); } if (contextInit.getElementAttributeValueParser()==null) { contextInit.setElementAttributeValueParser((ElementAttributeValueParser)X4OLanguageClassLoader.newInstance(getLanguageConfiguration().getDefaultElementAttributeValueParser())); diff --git a/x4o-driver/src/main/java/org/x4o/xml/lang/DefaultX4OLanguageConfiguration.java b/x4o-driver/src/main/java/org/x4o/xml/lang/DefaultX4OLanguageConfiguration.java index a97978d..da22604 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/lang/DefaultX4OLanguageConfiguration.java +++ b/x4o-driver/src/main/java/org/x4o/xml/lang/DefaultX4OLanguageConfiguration.java @@ -25,13 +25,8 @@ package org.x4o.xml.lang; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; import org.x4o.xml.el.X4OELContext; -import org.x4o.xml.eld.EldDriver; import org.x4o.xml.element.DefaultElement; import org.x4o.xml.element.DefaultElementAttributeValueParser; import org.x4o.xml.element.DefaultElementBodyCharacters; @@ -79,7 +74,7 @@ public class DefaultX4OLanguageConfiguration extends AbstractX4OLanguageConfigur if (getDefaultLanguageLoader()==null) { setDefaultLanguageLoader( DefaultX4OLanguageLoader.class); } if (getDefaultExpressionLanguageContext()==null) { setDefaultExpressionLanguageContext( X4OELContext.class); } } - + /** * @see org.x4o.xml.lang.X4OLanguageConfigurationLocal#createProxy() */ @@ -103,106 +98,4 @@ public class DefaultX4OLanguageConfiguration extends AbstractX4OLanguageConfigur }); return (X4OLanguageConfiguration)proxy; } - - /** - * @see org.x4o.xml.lang.X4OLanguageConfiguration#getSAXParserProperties(org.x4o.xml.lang.X4OLanguageContext) - */ - public Map getSAXParserProperties(X4OLanguageContext elementContext) { - Map saxParserProperties = new HashMap(1); - return saxParserProperties; - } - - /** - * @see org.x4o.xml.lang.X4OLanguageConfiguration#getSAXParserPropertiesOptional(org.x4o.xml.lang.X4OLanguageContext) - */ - public Map getSAXParserPropertiesOptional(X4OLanguageContext elementContext) { - Map saxParserProperties = new HashMap(1); - saxParserProperties.put("http://apache.org/xml/properties/input-buffer-size",elementContext.getLanguagePropertyInteger(X4OLanguageProperty.READER_BUFFER_SIZE)); // Increase buffer to 8KB - return saxParserProperties; - } - - /** - * @see org.x4o.xml.lang.X4OLanguageConfiguration#getSAXParserFeatures(org.x4o.xml.lang.X4OLanguageContext) - */ - public Map getSAXParserFeatures(X4OLanguageContext elementContext) { - - // see example: http://xerces.apache.org/xerces2-j/features.html - Map saxParserFeatures = new HashMap(20); - - // Tune Sax Parser - saxParserFeatures.put("http://xml.org/sax/features/namespaces", true); // Perform namespace processing - saxParserFeatures.put("http://xml.org/sax/features/use-entity-resolver2", true); // Use EntityResolver2 interface - saxParserFeatures.put("http://xml.org/sax/features/lexical-handler/parameter-entities", true); // Report parameter entities to a the LexicalHandler. - - saxParserFeatures.put("http://xml.org/sax/features/xmlns-uris", false); // Namespace declaration attributes are reported as having no namespace. - saxParserFeatures.put("http://xml.org/sax/features/namespace-prefixes", false); // Do not report attributes used for Namespace declarations - - saxParserFeatures.put("http://xml.org/sax/features/external-general-entities", false); // Never include the external general entries. - saxParserFeatures.put("http://xml.org/sax/features/external-parameter-entities", false); // Never include the external parameter or DTD subset. - - saxParserFeatures.put("http://apache.org/xml/features/xinclude", true); // Perform XInclude processing - saxParserFeatures.put("http://apache.org/xml/features/xinclude/fixup-base-uris", false); - saxParserFeatures.put("http://apache.org/xml/features/xinclude/fixup-language", false); - - boolean validation = false; - boolean validationXsd = false; - if (EldDriver.LANGUAGE_NAME.equals(elementContext.getLanguage().getLanguageName())) { - validation = false; //TODO: elementContext.getLanguagePropertyBoolean(X4OLanguageProperty.VALIDATION_ELD); - validationXsd = false; //elementContext.getLanguagePropertyBoolean(X4OLanguageProperty.VALIDATION_ELD_XSD); - } else { - validation = elementContext.getLanguagePropertyBoolean(X4OLanguageProperty.READER_VALIDATION_INPUT); - validationXsd = elementContext.getLanguagePropertyBoolean(X4OLanguageProperty.READER_VALIDATION_INPUT_XSD); - } - if (validation) { - saxParserFeatures.put("http://xml.org/sax/features/validation", true); // Validate the document and report validity errors. - saxParserFeatures.put("http://apache.org/xml/features/validation/schema", true); // Insert an XML Schema validator into the pipeline. - } else { - saxParserFeatures.put("http://xml.org/sax/features/validation", false); - saxParserFeatures.put("http://apache.org/xml/features/validation/schema", false); - } - if (validation && validationXsd) { - saxParserFeatures.put("http://apache.org/xml/features/validation/schema-full-checking", true); // Enable validation of the schema grammar itself for errors. - } else { - saxParserFeatures.put("http://apache.org/xml/features/validation/schema-full-checking", false); // Disable validation of the schema grammar itself for errors. - } - - - return saxParserFeatures; - } - - /** - * @see org.x4o.xml.lang.X4OLanguageConfiguration#getSAXParserFeaturesOptional(org.x4o.xml.lang.X4OLanguageContext) - */ - public Map getSAXParserFeaturesOptional(X4OLanguageContext elementContext) { - Map saxParserFeatures = new HashMap(20); - - // Make Sax Impl more strict. - saxParserFeatures.put("http://apache.org/xml/features/disallow-doctype-decl", true); // Throws error if document contains a DOCTYPE declaration. - saxParserFeatures.put("http://apache.org/xml/features/validation/schema/normalized-value", true); // Expose normalized values for attributes and elements. - saxParserFeatures.put("http://apache.org/xml/features/validation/warn-on-duplicate-attdef", true); // Report a warning when a duplicate attribute is re-declared. - saxParserFeatures.put("http://apache.org/xml/features/warn-on-duplicate-entitydef", true); // Report a warning for duplicate entity declaration. - saxParserFeatures.put("http://apache.org/xml/features/validation/dynamic", false); // Validation is determined by the state of the validation feature. - saxParserFeatures.put("http://apache.org/xml/features/nonvalidating/load-dtd-grammar", false); // Do not use the default DTD grammer - saxParserFeatures.put("http://apache.org/xml/features/nonvalidating/load-external-dtd", false); // Ignore the external DTD completely. - - // need newer version - //saxParserFeatures.put("http://apache.org/xml/features/standard-uri-conformant", true); // Requires that a URI has to be provided where a URI is expected. - //saxParserFeatures.put("http://apache.org/xml/features/validation/warn-on-undeclared-elemdef", true); // Report a warning if an element referenced in a content model is not declared. - //saxParserFeatures.put("http://apache.org/xml/features/validation/balance-syntax-trees", false); // No optimize DTD content models. - //saxParserFeatures.put("http://apache.org/xml/features/validation/unparsed-entity-checking", false); // Do not check that each value of type ENTITY in DTD. - - return saxParserFeatures; - } - - /** - * @see org.x4o.xml.lang.X4OLanguageConfiguration#getSAXParserFeaturesRequired(org.x4o.xml.lang.X4OLanguageContext) - */ - public List getSAXParserFeaturesRequired(X4OLanguageContext elementContext) { - List result = new ArrayList(5); - result.add("http://xml.org/sax/features/use-attributes2"); // Attributes objects passed by the parser are ext.Attributes2 interface. - result.add("http://xml.org/sax/features/use-locator2"); // Locator objects passed by the parser are org.xml.sax.ext.Locator2 interface. - result.add("http://xml.org/sax/features/xml-1.1"); // The parser supports both XML 1.0 and XML 1.1. - return result; - } - } diff --git a/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguage.java b/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguage.java index 0abd035..84e223c 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguage.java +++ b/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguage.java @@ -24,7 +24,6 @@ package org.x4o.xml.lang; import java.util.List; -import org.x4o.xml.X4ODriver; import org.x4o.xml.element.Element; import org.x4o.xml.element.ElementBindingHandler; import org.x4o.xml.element.ElementInterface; @@ -62,10 +61,9 @@ public interface X4OLanguage { /** * Creates and fills the initial element language used to store the language. - * @param driver The driver to create language context for. * @return The newly created ElementLanguage. */ - X4OLanguageContext createLanguageContext(X4ODriver driver); + X4OLanguageContext createLanguageContext(); /** * Search language for object and create element for it. diff --git a/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageConfiguration.java b/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageConfiguration.java index 7f966ae..715102a 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageConfiguration.java +++ b/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageConfiguration.java @@ -22,10 +22,6 @@ */ package org.x4o.xml.lang; -import java.util.Collection; -import java.util.List; -import java.util.Map; - /** * X4OLanguageConfiguration is base configuration of language used iin x4o parser. * @@ -76,38 +72,9 @@ public interface X4OLanguageConfiguration { * @return Returns the X4OLanguageLoader which loads languages into the element context. */ Class getDefaultLanguageLoader(); - + /** * @return Returns the Expression Language Context which holds the el objects. */ Class getDefaultExpressionLanguageContext(); - - Collection getGlobalPropertyKeys(); - Object getGlobalProperty(String key); - void setGlobalProperty(String key,Object value); - - /** - * @return Returns Map of SAX properties which are set. - */ - Map getSAXParserProperties(X4OLanguageContext elementContext); - - /** - * @return Returns Map of SAX properties which are optional set. - */ - Map getSAXParserPropertiesOptional(X4OLanguageContext elementContext); - - /** - * @return Returns Map of SAX features which are set on the xml parser. - */ - Map getSAXParserFeatures(X4OLanguageContext elementContext); - - /** - * @return Returns Map of SAX features which are optional set. - */ - Map getSAXParserFeaturesOptional(X4OLanguageContext elementContext); - - /** - * @return Returns List of SAX features which are required for xml parsing. - */ - List getSAXParserFeaturesRequired(X4OLanguageContext elementContext); } diff --git a/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageConfigurationLocal.java b/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageConfigurationLocal.java index ff7143f..c276990 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageConfigurationLocal.java +++ b/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageConfigurationLocal.java @@ -53,6 +53,4 @@ public interface X4OLanguageConfigurationLocal extends X4OLanguageConfiguration void setDefaultLanguageVersionFilter(Class value); void setDefaultLanguageLoader(Class value); void setDefaultExpressionLanguageContext(Class value); - - void setGlobalProperty(String key,Object value); } diff --git a/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageContext.java b/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageContext.java index ebfc6d6..12fb87b 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageContext.java +++ b/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageContext.java @@ -22,6 +22,7 @@ */ package org.x4o.xml.lang; +import java.util.List; import java.util.Map; import javax.el.ELContext; @@ -54,7 +55,7 @@ public interface X4OLanguageContext { * @return Returns the ExpressionFactory. */ ExpressionFactory getExpressionLanguageFactory(); - + /** * @return Returns the ElementAttributeValueParser. */ @@ -65,12 +66,6 @@ public interface X4OLanguageContext { */ ElementObjectPropertyValue getElementObjectPropertyValue(); - /** - * Returns the current X4OPhase of the parser. - * @return Returns the current phase. - */ - X4OPhase getCurrentPhase(); - /** * Marks an (new) Element as dirty and run the phases from this start phase. * @@ -108,12 +103,13 @@ public interface X4OLanguageContext { */ boolean hasX4ODebugWriter(); - Object getLanguageProperty(String key); - void setLanguageProperty(String key,Object value); + /** + * Returns the current X4OPhase of the parser. + * @return Returns the current phase. + */ + X4OPhase getPhaseCurrent(); - Object getLanguageProperty(X4OLanguageProperty property); - void setLanguageProperty(X4OLanguageProperty property,Object value); - boolean getLanguagePropertyBoolean(X4OLanguageProperty property); - int getLanguagePropertyInteger(X4OLanguageProperty property); - String getLanguagePropertyString(X4OLanguageProperty property); + public String getPhaseStop(); + + public List getPhaseSkip(); } diff --git a/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageContextLocal.java b/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageContextLocal.java index fa80901..a73340e 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageContextLocal.java +++ b/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageContextLocal.java @@ -60,14 +60,18 @@ public interface X4OLanguageContextLocal extends X4OLanguageContext { */ void setElementObjectPropertyValue(ElementObjectPropertyValue elementObjectPropertyValue); - /** - * Sets the phase of the context. - * @param phase The current phase to set. - */ - void setCurrentPhase(X4OPhase phase); - /** * @param debugWriter The debug writer to set */ void setX4ODebugWriter(X4ODebugWriter debugWriter); + + /** + * Sets the phase of the context. + * @param phase The current phase to set. + */ + void setPhaseCurrent(X4OPhase phase); + + void setPhaseStop(String phaseId); + + void addPhaseSkip(String phaseId); } diff --git a/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageProperty.java b/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageProperty.java deleted file mode 100644 index 427b1dc..0000000 --- a/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguageProperty.java +++ /dev/null @@ -1,318 +0,0 @@ -/* - * Copyright (c) 2004-2013, Willem Cazander - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without modification, are permitted provided - * that the following conditions are met: - * - * * Redistributions of source code must retain the above copyright notice, this list of conditions and the - * following disclaimer. - * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and - * the following disclaimer in the documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL - * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT - * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR - * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -package org.x4o.xml.lang; - -import java.io.File; -import java.io.InputStream; -import java.io.OutputStream; -import java.net.URL; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; - -import javax.el.ELContext; -import javax.el.ExpressionFactory; - -import org.x4o.xml.io.XMLConstants; -import org.xml.sax.EntityResolver; -import org.xml.sax.ErrorHandler; -import org.xml.sax.InputSource; -import org.xml.sax.ext.DefaultHandler2; - -/** - * X4OLanguageProperty holds the language connection properties keys - * - * @author Willem Cazander - * @version 1.0 6 Aug 2012 - */ -public enum X4OLanguageProperty { - - /** Read-Only property returning the language we are working with. */ - LANGUAGE_NAME(IO.GLOBAL,"language/name"), - - /** Read-Only property returning the version of the language. */ - LANGUAGE_VERSION(IO.GLOBAL,"language/version"), - - - - - - /** The input stream to parse, note is skipped when source is set. */ - READER_INPUT_STREAM(IO.READER,"reader/input/stream",InputStream.class), - - /** When set it overrides automatic encoding detection of sax parser. */ - READER_INPUT_ENCODING(IO.READER,"reader/input/encoding",String.class,XMLConstants.XML_DEFAULT_ENCODING), - - /** When set use this InputSource instance for parsing. */ - READER_INPUT_SOURCE(IO.READER,"reader/input/source",InputSource.class), - - /** Sets the system-id to the input source. */ - READER_INPUT_SYSTEM_ID(IO.READER,"reader/input/system-id",String.class), - - /** Sets the base path to resolve external input sources. */ - READER_INPUT_BASE_PATH(IO.READER,"reader/input/base-path",URL.class), - - - - /** SAX parser input buffer size: 512-16k defaults to 8k. */ - READER_BUFFER_SIZE(IO.READER,"reader/buffer-size",Integer.class,4096*2), - - /** When set it allows parsing of non-namespace aware documents. */ - READER_EMPTY_NAMESPACE_URI(IO.READER,"reader/empty-namespace-uri"), - - /** Set for custom handling of validation errors. */ - READER_ERROR_HANDLER(IO.READER,"reader/error-handler",ErrorHandler.class), - - /** Resolve more entities from local sources. */ - READER_ENTITY_RESOLVER(IO.READER,"reader/entity-resolver",EntityResolver.class), - - - - /** When set to true then input xml is validated. */ - READER_VALIDATION_SCHEMA_AUTO_WRITE(IO.READER,"reader/validation/schema-auto-write",Boolean.class,true), - - /** When set this path is searched for xsd schema files in the language sub directory. */ - READER_VALIDATION_SCHEMA_PATH(IO.READER,"reader/validation/schema-path",File.class), - - /** When set to true then input xml is validated. */ - READER_VALIDATION_INPUT(IO.READER,"reader/validation/input",Boolean.class,false), - - /** When set to true then input xsd xml grammer is validated. */ - READER_VALIDATION_INPUT_XSD(IO.READER,"reader/validation/input/xsd",Boolean.class,false), - - - - - - /** The writer output stream to write to. */ - WRITER_OUTPUT_STREAM(IO.WRITER,"writer/output/stream",OutputStream.class), - - /** The writer output encoding. */ - WRITER_OUTPUT_ENCODING(IO.WRITER,"writer/output/encoding",String.class,XMLConstants.XML_DEFAULT_ENCODING), - - /** The writer output newline. */ - WRITER_OUTPUT_CHAR_NEWLINE(IO.WRITER,"writer/output/char/newline",String.class), - - /** The writer output tab char. */ - WRITER_OUTPUT_CHAR_TAB(IO.WRITER,"writer/output/char/tab",String.class), - - /** When writing print schema uri. */ - WRITER_SCHEMA_URI_PRINT(IO.WRITER,"writer/schema/uri-print",Boolean.class,true), - - /** Override eld root schema uri. */ - WRITER_SCHEMA_URI_ROOT(IO.WRITER,"writer/schema/uri-root",String.class), - - - - - - /** The schema writer output path to write to. */ - SCHEMA_WRITER_OUTPUT_PATH(IO.SCHEMA_WRITER,"schema-writer/output/path",File.class), - - /** The schema writer output encoding. */ - SCHEMA_WRITER_OUTPUT_ENCODING(IO.SCHEMA_WRITER,"schema-writer/output/encoding",String.class,XMLConstants.XML_DEFAULT_ENCODING), - - /** The schema writer output newline. */ - SCHEMA_WRITER_OUTPUT_CHAR_NEWLINE(IO.SCHEMA_WRITER,"schema-writer/output/char/newline",String.class), - - /** The schema writer output tab char. */ - SCHEMA_WRITER_OUTPUT_CHAR_TAB(IO.SCHEMA_WRITER,"schema-writer/output/char/tab",String.class), - - - - - - /** When set to OutputStream xml debug is written to it. note: when output-handler is set this property is ignored. */ - DEBUG_OUTPUT_STREAM(IO.READER_WRITER,"debug/output-stream",OutputStream.class), - - /** When set to DefaultHandler2 xml debug events are fired to the object. */ - DEBUG_OUTPUT_HANDLER(IO.READER_WRITER,"debug/output-handler",DefaultHandler2.class), - - /* When set to true print also phases for parsing eld files. */ - //DEBUG_OUTPUT_ELD_PARSER(IO.READER_WRITER,"debug/output-eld-parser",Boolean.class,false), - - /* When set to true print full element tree per phase. */ - //DEBUG_OUTPUT_TREE_PER_PHASE("debug/output-tree-per-phase",Boolean.class), - - - - - - /** The beans in this map are set into the EL context for reference. */ - EL_BEAN_INSTANCE_MAP(IO.READER_WRITER,"el/bean-instance-map",Map.class), - - /** When set use this instance for the ELContext. */ - EL_CONTEXT_INSTANCE(IO.READER_WRITER,"el/context-instance",ELContext.class), - - /** When set use this instance as the ExpressionFactory. */ - EL_FACTORY_INSTANCE(IO.READER_WRITER,"el/factory-instance",ExpressionFactory.class), - - - - - - /** When set to an X4OPhase then parsing stops after completing the set phase. */ - PHASE_STOP_AFTER(IO.READER_WRITER,"phase/stop-after",String.class), - - /** When set to true skip the release phase. */ - PHASE_SKIP_RELEASE(IO.READER_WRITER,"phase/skip-release",Boolean.class,false), - - /** When set to true skip the run phase. */ - PHASE_SKIP_RUN(IO.READER_WRITER,"phase/skip-run",Boolean.class,false); - - - - - - // (temp) removed because init is now in driver manager - - /* When set to true skip the load siblings language phase. */ - //PHASE_SKIP_SIBLINGS(IO.READER,"phase/skip-siblings",Boolean.class,false); - - /* When set to true then eld xml is validated. */ - //VALIDATION_ELD(IO.INIT,"validation/eld",Boolean.class,false), - - /* When set to true than eld xsd xml grammer is also validated. */ - //VALIDATION_ELD_XSD(IO.INIT, "validation/eld/xsd",Boolean.class,false); - - public final static X4OLanguageProperty[] DEFAULT_X4O_READER_KEYS; - public final static X4OLanguageProperty[] DEFAULT_X4O_WRITER_KEYS; - public final static X4OLanguageProperty[] DEFAULT_X4O_SCHEMA_WRITER_KEYS; - - static { - List readerResultKeys = new ArrayList(); - List writerResultKeys = new ArrayList(); - List schemaWriterResultKeys = new ArrayList(); - X4OLanguageProperty[] keys = X4OLanguageProperty.values(); - for (int i=0;i[] classTypes; - private final Object defaultValue; - private final X4OLanguageProperty.IO type; - - private X4OLanguageProperty(X4OLanguageProperty.IO type,String uriName) { - this(type,uriName,String.class); - } - - private X4OLanguageProperty(X4OLanguageProperty.IO type,String uriName,Class classType) { - this(type,uriName,new Class[]{classType},null); - } - - private X4OLanguageProperty(X4OLanguageProperty.IO type,String uriName,Class classType,Object defaultValue) { - this(type,uriName,new Class[]{classType},defaultValue); - } - - private X4OLanguageProperty(X4OLanguageProperty.IO type,String uriName,Class[] classTypes,Object defaultValue) { - this.type=type; - this.uriName=URI_PREFIX+uriName; - this.classTypes=classTypes; - this.defaultValue=defaultValue; - } - - /** - * Returns the uri defined by this property. - * @return The uri defined by this property. - */ - public final String toUri() { - return uriName; - } - - /** - * Returns the default value for this property. - * @return The default value for this property. - */ - public final Object getDefaultValue() { - return defaultValue; - } - - /** - * Checks if the object is valid to set on this property. - * This is done by checking the allowed class types if they are assignable from the value class. - * @param value The object to check. - * @return Returns true when Object value is allowed to be set. - */ - public final boolean isValueValid(Object value) { - if (LANGUAGE_NAME.equals(this) | LANGUAGE_VERSION.equals(this)) { - return false; // read only are not valid to set. - } - if (value==null) { - return true; - } - Class valueClass = value.getClass(); - for (Class c:classTypes) { - if (c.isAssignableFrom(valueClass)) { - return true; - } - } - return false; - } - - /** - * Search the enum for the value defined by the given uri. - * @param uri The uri to search for. - * @return Return the property for the given uri. - * @throws IllegalArgumentException when uri is not found. - */ - public static final X4OLanguageProperty valueByUri(String uri) { - if (uri==null) { - throw new NullPointerException("Can't search null uri."); - } - if (uri.length()==0) { - throw new IllegalArgumentException("Can't search empty uri."); - } - if (uri.startsWith(URI_PREFIX)==false) { - throw new IllegalArgumentException("Can't search for other name local prefix: "+URI_PREFIX+" found: "+uri); - } - for (X4OLanguageProperty p:values()) { - if (uri.equals(p.toUri())) { - return p; - } - } - throw new IllegalArgumentException("Could not find language property for uri key: "+uri); - } -} diff --git a/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguagePropertyKeys.java b/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguagePropertyKeys.java deleted file mode 100644 index 2aef06e..0000000 --- a/x4o-driver/src/main/java/org/x4o/xml/lang/X4OLanguagePropertyKeys.java +++ /dev/null @@ -1,99 +0,0 @@ -/* - * Copyright (c) 2004-2013, Willem Cazander - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without modification, are permitted provided - * that the following conditions are met: - * - * * Redistributions of source code must retain the above copyright notice, this list of conditions and the - * following disclaimer. - * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and - * the following disclaimer in the documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL - * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT - * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR - * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -package org.x4o.xml.lang; - -/** - * X4OLanguagePropertyKeys is shortcut to the the properties by uri. - * - * @author Willem Cazander - * @version 1.0 6 Aug 2012 - */ -public class X4OLanguagePropertyKeys { - - public static final String LANGUAGE_NAME = X4OLanguageProperty.LANGUAGE_NAME.toUri(); - public static final String LANGUAGE_VERSION = X4OLanguageProperty.LANGUAGE_VERSION.toUri(); - - public static final String READER_INPUT_STREAM = X4OLanguageProperty.READER_INPUT_STREAM.toUri(); - public static final String READER_INPUT_ENCODING = X4OLanguageProperty.READER_INPUT_ENCODING.toUri(); - public static final String READER_INPUT_SOURCE = X4OLanguageProperty.READER_INPUT_SOURCE.toUri(); - public static final String READER_INPUT_SYSTEM_ID = X4OLanguageProperty.READER_INPUT_SYSTEM_ID.toUri(); - public static final String READER_INPUT_BASE_PATH = X4OLanguageProperty.READER_INPUT_BASE_PATH.toUri(); - public static final String READER_BUFFER_SIZE = X4OLanguageProperty.READER_BUFFER_SIZE.toUri(); - public static final String READER_EMPTY_NAMESPACE_URI = X4OLanguageProperty.READER_EMPTY_NAMESPACE_URI.toUri(); - public static final String READER_ERROR_HANDLER = X4OLanguageProperty.READER_ERROR_HANDLER.toUri(); - public static final String READER_ENTITY_RESOLVER = X4OLanguageProperty.READER_ENTITY_RESOLVER.toUri(); - public static final String READER_VALIDATION_SCHEMA_AUTO_WRITE = X4OLanguageProperty.READER_VALIDATION_SCHEMA_AUTO_WRITE.toUri(); - public static final String READER_VALIDATION_SCHEMA_PATH = X4OLanguageProperty.READER_VALIDATION_SCHEMA_PATH.toUri(); - public static final String READER_VALIDATION_INPUT = X4OLanguageProperty.READER_VALIDATION_INPUT.toUri(); - public static final String READER_VALIDATION_INPUT_XSD = X4OLanguageProperty.READER_VALIDATION_INPUT_XSD.toUri(); - - public static final String WRITER_OUTPUT_STREAM = X4OLanguageProperty.WRITER_OUTPUT_STREAM.toUri(); - public static final String WRITER_OUTPUT_ENCODING = X4OLanguageProperty.WRITER_OUTPUT_ENCODING.toUri(); - public static final String WRITER_OUTPUT_CHAR_NEWLINE = X4OLanguageProperty.WRITER_OUTPUT_CHAR_NEWLINE.toUri(); - public static final String WRITER_OUTPUT_CHAR_TAB = X4OLanguageProperty.WRITER_OUTPUT_CHAR_TAB.toUri(); - public static final String WRITER_SCHEMA_URI_PRINT = X4OLanguageProperty.WRITER_SCHEMA_URI_PRINT.toUri(); - public static final String WRITER_SCHEMA_URI_ROOT = X4OLanguageProperty.WRITER_SCHEMA_URI_ROOT.toUri(); - - public static final String SCHEMA_WRITER_OUTPUT_PATH = X4OLanguageProperty.SCHEMA_WRITER_OUTPUT_PATH.toUri(); - public static final String SCHEMA_WRITER_OUTPUT_ENCODING = X4OLanguageProperty.SCHEMA_WRITER_OUTPUT_ENCODING.toUri(); - public static final String SCHEMA_WRITER_OUTPUT_CHAR_NEWLINE = X4OLanguageProperty.SCHEMA_WRITER_OUTPUT_CHAR_NEWLINE.toUri(); - public static final String SCHEMA_WRITER_OUTPUT_CHAR_TAB = X4OLanguageProperty.SCHEMA_WRITER_OUTPUT_CHAR_TAB.toUri(); - - public static final String DEBUG_OUTPUT_STREAM = X4OLanguageProperty.DEBUG_OUTPUT_STREAM.toUri(); - public static final String DEBUG_OUTPUT_HANDLER = X4OLanguageProperty.DEBUG_OUTPUT_HANDLER.toUri(); - - public static final String EL_BEAN_INSTANCE_MAP = X4OLanguageProperty.EL_BEAN_INSTANCE_MAP.toUri(); - public static final String EL_FACTORY_INSTANCE = X4OLanguageProperty.EL_FACTORY_INSTANCE.toUri(); - - public static final String PHASE_STOP_AFTER = X4OLanguageProperty.PHASE_STOP_AFTER.toUri(); - public static final String PHASE_SKIP_RELEASE = X4OLanguageProperty.PHASE_SKIP_RELEASE.toUri(); - public static final String PHASE_SKIP_RUN = X4OLanguageProperty.PHASE_SKIP_RUN.toUri(); - - - public final static String[] DEFAULT_X4O_READER_KEYS; - public final static String[] DEFAULT_X4O_WRITER_KEYS; - public final static String[] DEFAULT_X4O_SCHEMA_WRITER_KEYS; - - static { - X4OLanguageProperty[] readerKeys = X4OLanguageProperty.DEFAULT_X4O_READER_KEYS; - String[] readerResultKeys = new String[readerKeys.length]; - for (int i=0;i x4oPhasesOrder = getOrderedPhases(type); - /* - System.out.println("------ phases type: "+type+" for: "+languageContext.getLanguage().getLanguageName()); - for (X4OPhase p:x4oPhasesOrder) { - System.out.print("Exec phase; "+p.getId()+" deps: ["); - for (String dep:p.getPhaseDependencies()) { - System.out.print(dep+","); - } - System.out.println("]"); - } - */ - // debug output if (languageContext.getX4ODebugWriter()!=null) { languageContext.getX4ODebugWriter().debugPhaseOrder(x4oPhases); } - boolean skipReleasePhase = languageContext.getLanguagePropertyBoolean(X4OLanguageProperty.PHASE_SKIP_RELEASE); - boolean skipRunPhase = languageContext.getLanguagePropertyBoolean(X4OLanguageProperty.PHASE_SKIP_RUN); - //boolean skipSiblingsPhase = languageContext.getLanguagePropertyBoolean(X4OLanguageProperty.PHASE_SKIP_SIBLINGS); - String stopPhase = languageContext.getLanguagePropertyString(X4OLanguageProperty.PHASE_STOP_AFTER); + List phaseSkip = languageContext.getPhaseSkip(); + String phaseStop = languageContext.getPhaseStop(); // run the phases in ordered order for (X4OPhase phase:x4oPhasesOrder) { - - if (skipReleasePhase && phase.getId().equals("X4O_RELEASE")) { - continue; // skip always release phase when requested by property + + if (phaseSkip.contains(phase.getId())) { + continue; // skip phase when requested by context } - if (skipRunPhase && phase.getId().equals("READ_RUN")) { - continue; // skip run phase on request - } - // if (skipSiblingsPhase && phase.getId().equals("INIT_LANG_SIB")) { - // continue; // skip loading sibling languages - // } // debug output - ((X4OLanguageContextLocal)languageContext).setCurrentPhase(phase); - + ((X4OLanguageContextLocal)languageContext).setPhaseCurrent(phase); + // run listeners for (X4OPhaseListener l:phase.getPhaseListeners()) { l.preRunPhase(phase, languageContext); @@ -186,7 +160,7 @@ PHASE_ORDER = { *startupX4OPhase, } } - if (stopPhase!=null && stopPhase.equals(phase.getId())) { + if (phaseStop!=null && phaseStop.equals(phase.getId())) { return; // we are done } } @@ -200,8 +174,8 @@ PHASE_ORDER = { *startupX4OPhase, */ public void runPhasesForElement(Element e,X4OPhaseType type,X4OPhase p) throws X4OPhaseException { X4OLanguageContext languageContext = e.getLanguageContext(); - boolean skipRunPhase = languageContext.getLanguagePropertyBoolean(X4OLanguageProperty.PHASE_SKIP_RUN); - String stopPhase = languageContext.getLanguagePropertyString(X4OLanguageProperty.PHASE_STOP_AFTER); + List phaseSkip = languageContext.getPhaseSkip(); + String phaseStop = languageContext.getPhaseStop(); // sort for the order List x4oPhasesOrder = getOrderedPhases(type); @@ -209,15 +183,12 @@ PHASE_ORDER = { *startupX4OPhase, if (phase.getId().equals(p.getId())==false) { continue; // we start running all phases from specified phase } - if (phase.getId().equals("RELEASE")) { - continue; // skip always release phase in dirty extra runs. - } - if (skipRunPhase && phase.getId().equals("READ_RUN")) { - continue; // skip run phase on request + if (phaseSkip.contains(phase.getId())) { + continue; // skip phase when requested by context } // set phase - ((X4OLanguageContextLocal)languageContext).setCurrentPhase(phase); + ((X4OLanguageContextLocal)languageContext).setPhaseCurrent(phase); // do the run interface phase.runPhase(languageContext); @@ -225,7 +196,7 @@ PHASE_ORDER = { *startupX4OPhase, // run the element phase if possible executePhaseRoot(languageContext,phase); - if (stopPhase!=null && stopPhase.equals(phase.getId())) { + if (phaseStop!=null && phaseStop.equals(phase.getId())) { return; // we are done } } @@ -236,8 +207,15 @@ PHASE_ORDER = { *startupX4OPhase, * @throws X4OPhaseException When a running handlers throws one. */ public void doReleasePhaseManual(X4OLanguageContext languageContext) throws X4OPhaseException { - boolean skipReleasePhase = languageContext.getLanguagePropertyBoolean(X4OLanguageProperty.PHASE_SKIP_RELEASE); - if (skipReleasePhase==false) { + List phaseSkip = languageContext.getPhaseSkip(); + String releaseRequested = null; + if (phaseSkip.contains(X4OPhase.READ_RELEASE)) { + releaseRequested = X4OPhase.READ_RELEASE; + } + if (phaseSkip.contains(X4OPhase.WRITE_RELEASE)) { + releaseRequested = X4OPhase.WRITE_RELEASE; + } + if (releaseRequested==null) { throw new IllegalStateException("No manual release requested."); } if (languageContext.getRootElement()==null) { @@ -249,7 +227,7 @@ PHASE_ORDER = { *startupX4OPhase, X4OPhase h = null; for (X4OPhase phase:x4oPhases) { - if (phase.getId().equals("X4O_RELEASE")) { + if (phase.getId().equals(releaseRequested)) { h = phase; break; } @@ -259,7 +237,7 @@ PHASE_ORDER = { *startupX4OPhase, } // set phase - ((X4OLanguageContextLocal)languageContext).setCurrentPhase(h); + ((X4OLanguageContextLocal)languageContext).setPhaseCurrent(h); // do the run interface h.runPhase(languageContext); diff --git a/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhase.java b/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhase.java index 817ca1b..f5f5176 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhase.java +++ b/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhase.java @@ -36,6 +36,17 @@ import org.x4o.xml.lang.X4OLanguageContext; */ public interface X4OPhase { + public final static String INIT_BEGIN = "INIT_BEGIN"; + public final static String INIT_END = "INIT_END"; + + public final static String READ_BEGIN = "READ_BEGIN"; + public final static String READ_END = "READ_END"; + public final static String READ_RELEASE = "READ_RELEASE"; + + public final static String WRITE_BEGIN = "WRITE_BEGIN"; + public final static String WRITE_END = "WRITE_END"; + public final static String WRITE_RELEASE = "WRITE_RELEASE"; + X4OPhaseType getType(); /** diff --git a/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhaseLanguageRead.java b/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhaseLanguageRead.java index 4092cdf..182f6bd 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhaseLanguageRead.java +++ b/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhaseLanguageRead.java @@ -29,10 +29,7 @@ import java.util.List; import java.util.Map; import java.util.logging.Logger; -import javax.el.ValueExpression; - import org.x4o.xml.conv.ObjectConverterException; - import org.x4o.xml.element.Element; import org.x4o.xml.element.ElementAttributeHandler; import org.x4o.xml.element.ElementAttributeValueParser; @@ -44,14 +41,11 @@ import org.x4o.xml.element.ElementConfiguratorGlobal; import org.x4o.xml.element.ElementException; import org.x4o.xml.element.ElementInterface; import org.x4o.xml.element.ElementNamespaceContext; -import org.x4o.xml.io.sax.X4OContentParser; import org.x4o.xml.io.sax.X4ODebugWriter; import org.x4o.xml.io.sax.ext.ContentWriter; import org.x4o.xml.lang.X4OLanguageModule; import org.x4o.xml.lang.X4OLanguageContext; import org.x4o.xml.lang.X4OLanguageClassLoader; -import org.x4o.xml.lang.X4OLanguageProperty; - import org.xml.sax.SAXException; import org.xml.sax.helpers.AttributesImpl; @@ -71,11 +65,7 @@ public class X4OPhaseLanguageRead { public void createPhases(DefaultX4OPhaseManager manager) { - manager.addX4OPhase(new X4OPhaseReadStart()); - manager.addX4OPhase(new X4OPhaseReadXml()); - - manager.addX4OPhase(new X4OPhaseReadConfigELBeans()); -// if (languageContext.hasX4ODebugWriter()) {manager.addX4OPhaseHandler(factory.debugPhase());} + manager.addX4OPhase(new X4OPhaseReadBegin()); // meta start point // manager.addX4OPhase(factory.startX4OPhase()); @@ -141,12 +131,12 @@ public class X4OPhaseLanguageRead { /** * Creates the startX4OPhase which is a empty meta phase. */ - class X4OPhaseReadStart extends AbstractX4OPhase { + class X4OPhaseReadBegin extends AbstractX4OPhase { public X4OPhaseType getType() { return X4OPhaseType.XML_READ; } public String getId() { - return "READ_START"; + return X4OPhase.READ_BEGIN; } public String[] getPhaseDependencies() { return new String[]{}; @@ -161,7 +151,7 @@ public class X4OPhaseLanguageRead { // print the properties and classes for this language/config if (languageContext.hasX4ODebugWriter()) { try { - languageContext.getX4ODebugWriter().debugLanguageProperties(languageContext); + //languageContext.getX4ODebugWriter().debugLanguageProperties(languageContext); languageContext.getX4ODebugWriter().debugLanguageDefaultClasses(languageContext); } catch (ElementException e) { throw new X4OPhaseException(this,e); @@ -170,72 +160,6 @@ public class X4OPhaseLanguageRead { } }; - /** - * Parses the xml resource(s) and creates an Element tree. - */ - class X4OPhaseReadXml extends AbstractX4OPhase { - public X4OPhaseType getType() { - return X4OPhaseType.XML_READ; - } - public String getId() { - return "READ_XML"; - } - public String[] getPhaseDependencies() { - return new String[]{"READ_START"}; - } - public boolean isElementPhase() { - return false; - } - public void runElementPhase(Element element) throws X4OPhaseException { - } - public void runPhase(X4OLanguageContext languageContext) throws X4OPhaseException { - try { - X4OContentParser parser = new X4OContentParser(); - parser.parse(languageContext); - } catch (Exception e) { - throw new X4OPhaseException(this,e); - } - } - }; - - /** - * Creates the configGlobalElBeansPhase which adds beans to the el context. - */ - class X4OPhaseReadConfigELBeans extends AbstractX4OPhase { - public X4OPhaseType getType() { - return X4OPhaseType.XML_RW; - } - public String getId() { - return "READ_CONFIG_EL_BEANS"; - } - public String[] getPhaseDependencies() { - return new String[] {"READ_XML"}; - } - public boolean isElementPhase() { - return false; - } - public void runElementPhase(Element element) throws X4OPhaseException { - // not used. - } - @SuppressWarnings("rawtypes") - public void runPhase(X4OLanguageContext languageContext) throws X4OPhaseException { - try { - Map beanMap = (Map)languageContext.getLanguageProperty(X4OLanguageProperty.EL_BEAN_INSTANCE_MAP); - if (beanMap==null) { - return; - } - for (Object elName:beanMap.keySet()) { - Object o = beanMap.get(elName); - ValueExpression ve = languageContext.getExpressionLanguageFactory().createValueExpression(languageContext.getExpressionLanguageContext(),"${"+elName+"}", o.getClass()); - ve.setValue(languageContext.getExpressionLanguageContext(), o); - debugPhaseMessage("Setting el bean: ${"+elName+"} to: "+o.getClass().getName(),this,languageContext); - } - } catch (Exception e) { - throw new X4OPhaseException(this,e); - } - } - }; - /** * X4OPhaseReadConfigElement */ @@ -251,7 +175,7 @@ public class X4OPhaseLanguageRead { return "READ_CONFIG_ELEMENT"; } public String[] getPhaseDependencies() { - return new String[] {"READ_CONFIG_EL_BEANS"}; + return new String[] {X4OPhase.READ_BEGIN}; } public void runElementPhase(Element element) throws X4OPhaseException { @@ -292,7 +216,7 @@ public class X4OPhaseLanguageRead { return "READ_CONFIG_ELEMENT_INTERFACE"; } public String[] getPhaseDependencies() { - return new String[] {"READ_CONFIG_EL_BEANS"}; + return new String[] {"READ_CONFIG_ELEMENT"}; } public void runElementPhase(Element element) throws X4OPhaseException { if (element.getElementObject()==null) { @@ -709,7 +633,7 @@ public class X4OPhaseLanguageRead { return X4OPhaseType.XML_READ; } public String getId() { - return "READ_END"; + return X4OPhase.READ_END; } public String[] getPhaseDependencies() { return new String[]{"READ_RUN_CONFIGURATOR"}; @@ -724,7 +648,7 @@ public class X4OPhaseLanguageRead { // print the properties and classes for this language/config if (languageContext.hasX4ODebugWriter()) { try { - languageContext.getX4ODebugWriter().debugLanguageProperties(languageContext); + //languageContext.getX4ODebugWriter().debugLanguageProperties(languageContext); languageContext.getX4ODebugWriter().debugLanguageDefaultClasses(languageContext); } catch (ElementException e) { throw new X4OPhaseException(this,e); @@ -773,13 +697,13 @@ public class X4OPhaseLanguageRead { final ReleasePhaseListener releaseCounter = new ReleasePhaseListener(); X4OPhase result = new AbstractX4OPhase() { public X4OPhaseType getType() { - return X4OPhaseType.XML_RW; + return X4OPhaseType.XML_READ; } public String getId() { - return "X4O_RELEASE"; + return X4OPhase.READ_RELEASE; } public String[] getPhaseDependencies() { - return new String[] {"READ_END"}; + return new String[] {X4OPhase.READ_END}; } public void runPhase(X4OLanguageContext languageContext) throws X4OPhaseException { } @@ -804,7 +728,7 @@ public class X4OPhaseLanguageRead { public X4OPhase debugPhase(final X4OPhase afterPhase) { X4OPhase result = new AbstractX4OPhase() { public X4OPhaseType getType() { - return X4OPhaseType.XML_RW; + return X4OPhaseType.XML_READ; } public String getId() { return "X4O_DEBUG_"+afterPhase.getId(); diff --git a/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhaseLanguageWrite.java b/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhaseLanguageWrite.java index e52ff58..1d08d0b 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhaseLanguageWrite.java +++ b/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhaseLanguageWrite.java @@ -22,34 +22,17 @@ */ package org.x4o.xml.lang.phase; -import java.io.IOException; -import java.io.OutputStream; -import java.lang.reflect.Method; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.Comparator; -import java.util.HashMap; -import java.util.List; -import java.util.Map; import java.util.logging.Logger; import org.x4o.xml.element.Element; import org.x4o.xml.element.ElementBindingHandler; import org.x4o.xml.element.ElementBindingHandlerException; import org.x4o.xml.element.ElementClass; -import org.x4o.xml.element.ElementClassAttribute; -import org.x4o.xml.element.ElementInterface; +import org.x4o.xml.element.ElementException; import org.x4o.xml.element.ElementNamespaceContext; import org.x4o.xml.element.ElementNamespaceInstanceProviderException; -import org.x4o.xml.element.ElementObjectPropertyValueException; -import org.x4o.xml.io.XMLConstants; -import org.x4o.xml.io.sax.ext.ContentWriterXml; import org.x4o.xml.lang.X4OLanguageModule; import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguageProperty; -import org.xml.sax.SAXException; -import org.xml.sax.helpers.AttributesImpl; /** * X4OPhaseLanguageWrite defines all phases to write the language. @@ -66,21 +49,21 @@ public class X4OPhaseLanguageWrite { } public void createPhases(DefaultX4OPhaseManager manager) { - manager.addX4OPhase(new X4OPhaseWriteStart()); + manager.addX4OPhase(new X4OPhaseWriteBegin()); manager.addX4OPhase(new X4OPhaseWriteFillTree()); - manager.addX4OPhase(new X4OPhaseWriteXml()); manager.addX4OPhase(new X4OPhaseWriteEnd()); + //manager.addX4OPhase(new X4OPhaseWriteRelease()); } /** - * Creates the X4OPhaseWriteStart which is a empty meta phase. + * Creates the X4OPhaseWriteBegin which is a empty meta phase. */ - class X4OPhaseWriteStart extends AbstractX4OPhase { + class X4OPhaseWriteBegin extends AbstractX4OPhase { public X4OPhaseType getType() { return X4OPhaseType.XML_WRITE; } public String getId() { - return "WRITE_START"; + return X4OPhase.WRITE_BEGIN; } public String[] getPhaseDependencies() { return new String[]{}; @@ -91,7 +74,7 @@ public class X4OPhaseLanguageWrite { public void runElementPhase(Element element) throws X4OPhaseException { } public void runPhase(X4OLanguageContext languageContext) throws X4OPhaseException { - logger.finest("Run init start phase"); + logger.finest("Run init begin phase"); } }; @@ -106,7 +89,7 @@ public class X4OPhaseLanguageWrite { return "WRITE_FILL_TREE"; } public String[] getPhaseDependencies() { - return new String[]{"WRITE_START"}; + return new String[]{X4OPhase.WRITE_BEGIN}; } public boolean isElementPhase() { return false; @@ -173,249 +156,6 @@ public class X4OPhaseLanguageWrite { } }; - /** - * Write xml to output. - */ - class X4OPhaseWriteXml extends AbstractX4OPhase { - public X4OPhaseType getType() { - return X4OPhaseType.XML_WRITE; - } - public String getId() { - return "WRITE_XML"; - } - public String[] getPhaseDependencies() { - return new String[] {"WRITE_FILL_TREE"}; - } - public boolean isElementPhase() { - return false; - } - public void runElementPhase(Element element) throws X4OPhaseException { - } - - private AttributeEntryComparator attributeEntryComparator = new AttributeEntryComparator(); - private boolean schemaUriPrint; - private String schemaUriRoot; - - public void runPhase(X4OLanguageContext languageContext) throws X4OPhaseException { - OutputStream out = (OutputStream)languageContext.getLanguageProperty(X4OLanguageProperty.WRITER_OUTPUT_STREAM); - try { - String encoding = languageContext.getLanguagePropertyString(X4OLanguageProperty.WRITER_OUTPUT_ENCODING); - String charNew = languageContext.getLanguagePropertyString(X4OLanguageProperty.WRITER_OUTPUT_CHAR_NEWLINE); - String charTab = languageContext.getLanguagePropertyString(X4OLanguageProperty.WRITER_OUTPUT_CHAR_TAB); - schemaUriPrint = languageContext.getLanguagePropertyBoolean(X4OLanguageProperty.WRITER_SCHEMA_URI_PRINT); - schemaUriRoot = languageContext.getLanguagePropertyString(X4OLanguageProperty.WRITER_SCHEMA_URI_ROOT); - if (encoding==null) { encoding = XMLConstants.XML_DEFAULT_ENCODING; } - if (charNew==null) { charNew = XMLConstants.CHAR_NEWLINE+""; } - if (charTab==null) { charTab = XMLConstants.CHAR_TAB+""; } - - Element root = languageContext.getRootElement(); - if (schemaUriRoot==null) { - String rootUri = findElementUri(root); - ElementNamespaceContext ns = languageContext.getLanguage().findElementNamespaceContext(rootUri); - if (ns!=null) { - schemaUriRoot = ns.getSchemaUri(); - } - } - - ContentWriterXml writer = new ContentWriterXml(out,encoding,charNew,charTab); - writer.startDocument(); - - Map prefixes = new HashMap(); - startPrefixTree(root,prefixes); - for (String uri:prefixes.keySet()) { - String prefix = prefixes.get(uri); - writer.startPrefixMapping(prefix, uri); - } - try { - writeTree(writer,root,true); - } catch (ElementObjectPropertyValueException e) { - throw new SAXException(e); - } - writer.endDocument(); - out.flush(); - - } catch (Exception e) { - throw new X4OPhaseException(this,e); - } finally { - if (out!=null) { - try { - out.close(); - } catch (IOException e) { - logger.warning(e.getMessage()); - } - } - } - } - - private void startPrefixTree(Element element,Map result) throws SAXException { - String elementUri = findElementUri(element); - if (result.containsKey(elementUri)==false) { - String elementUriPrefix = findNamespacePrefix(element,elementUri); - result.put(elementUri, elementUriPrefix); - } - for (Element e:element.getChilderen()) { - startPrefixTree(e,result); - } - } - - private List getProperties(Class objectClass) { - List result = new ArrayList(); - for (Method m:objectClass.getMethods()) { - Class[] types = m.getParameterTypes(); - if (types.length != 0) { - continue; - } - if (m.getName().equals("getClass")) { - continue; - } - if (m.getName().startsWith("get")==false) { - continue; - } - String name = m.getName().substring(3,4).toLowerCase()+m.getName().substring(4); - result.add(name); - - } - return result; - } - class AttributeEntry { - String id; - String value; - Integer writeOrder; - } - class AttributeEntryComparator implements Comparator { - public int compare(AttributeEntry o1, AttributeEntry o2) { - return o1.writeOrder.compareTo(o2.writeOrder); - } - } - private void writeTree(ContentWriterXml writer,Element element,boolean isRoot) throws SAXException, ElementObjectPropertyValueException { - List attr = new ArrayList(20); - if (element.getElementClass().getAutoAttributes()!=null && element.getElementClass().getAutoAttributes()==false) { - for (ElementClassAttribute eca:element.getElementClass().getElementClassAttributes()) { - if (eca.getRunBeanValue()!=null && eca.getRunBeanValue()==false) { - continue; - } - - Object value = element.getLanguageContext().getElementObjectPropertyValue().getProperty(element.getElementObject(),eca.getId()); - if (value==null) { - continue; - } - AttributeEntry e = new AttributeEntry(); - e.id = eca.getId(); - e.value = ""+value; - e.writeOrder = calcOrderNumber(e.id,eca.getWriteOrder()); - attr.add(e); - } - - } else { - for (String p:getProperties(element.getElementObject().getClass())) { - Integer writeOrder = null; - ElementClassAttribute eca = element.getElementClass().getElementClassAttributeByName(p); - if (eca!=null) { - writeOrder = eca.getWriteOrder(); - } - if (eca!=null && eca.getRunBeanValue()!=null && eca.getRunBeanValue()) { - continue; - } - boolean writeValue = true; - for (ElementInterface ei:element.getLanguageContext().getLanguage().findElementInterfaces(element.getElementObject().getClass())) { - eca = ei.getElementClassAttributeByName(p); - if (eca!=null && writeOrder==null) { - writeOrder = eca.getWriteOrder(); // add interface but allow override local - } - if (eca!=null && eca.getRunBeanValue()!=null && eca.getRunBeanValue()==false) { - writeValue = false; - break; - } - } - if (writeValue==false) { - continue; - } - - // TODO: check attr see reader - Object value = element.getLanguageContext().getElementObjectPropertyValue().getProperty(element.getElementObject(),p); - if (value==null) { - continue; - } - if (value instanceof List || value instanceof Collection) { - continue; // TODO; filter on type of childeren - } - AttributeEntry e = new AttributeEntry(); - e.id = p; - e.value = ""+value; - e.writeOrder = calcOrderNumber(e.id,writeOrder); - attr.add(e); - } - } - - // Create atts to write and append schema first. - AttributesImpl atts = new AttributesImpl(); - if (isRoot && schemaUriPrint) { - String rootUri = findElementUri(element); - writer.startPrefixMapping("xsi", XMLConstants.XML_SCHEMA_INSTANCE_NS_URI); - atts.addAttribute ("xsi", "schemaLocation", "", "", rootUri+" "+schemaUriRoot); - } - - // Sort attributes in natural order of localName and add to attributes - Collections.sort(attr, attributeEntryComparator); - for (int i=0;i3) { - return (name.charAt(0) * 1000) + (name.charAt(1) * 100) + (name.charAt(2) * 10) + (name.charAt(3) * 1); - } - throw new IllegalArgumentException("Can't calculate order of empty name."); - } - - private String findElementUri(Element e) { - for (X4OLanguageModule mod:e.getLanguageContext().getLanguage().getLanguageModules()) { - for (ElementNamespaceContext c:mod.getElementNamespaceContexts()) { - ElementClass ec = c.getElementClass(e.getElementClass().getId()); - if (ec!=null) { - return c.getUri(); - } - } - } - return null; - } - - private String findNamespacePrefix(Element e,String uri) { - ElementNamespaceContext ns = e.getLanguageContext().getLanguage().findElementNamespaceContext(uri); - if (ns.getPrefixMapping()!=null) { - return ns.getPrefixMapping(); - } - return ns.getId(); - } - }; - /** * Creates the X4OPhaseWriteEnd which is a empty meta phase. */ @@ -424,10 +164,10 @@ public class X4OPhaseLanguageWrite { return X4OPhaseType.XML_WRITE; } public String getId() { - return "WRITE_END"; + return X4OPhase.WRITE_END; } public String[] getPhaseDependencies() { - return new String[]{"WRITE_XML"}; + return new String[]{"WRITE_FILL_TREE"}; } public boolean isElementPhase() { return false; @@ -438,4 +178,27 @@ public class X4OPhaseLanguageWrite { logger.finest("Run init end phase"); } }; + + class X4OPhaseWriteRelease extends AbstractX4OPhase { + public X4OPhaseType getType() { + return X4OPhaseType.XML_WRITE; + } + public String getId() { + return X4OPhase.WRITE_RELEASE; + } + public String[] getPhaseDependencies() { + return new String[] {X4OPhase.WRITE_END}; + } + public void runPhase(X4OLanguageContext languageContext) throws X4OPhaseException { + } + public void runElementPhase(Element element) throws X4OPhaseException { + try { + element.release(); + } catch (ElementException e) { + throw new X4OPhaseException(this,e); + }/* finally { + releaseCounter.addReleasedElement(); + }*/ + } + } } diff --git a/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhaseType.java b/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhaseType.java index 5323b8c..e799aab 100644 --- a/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhaseType.java +++ b/x4o-driver/src/main/java/org/x4o/xml/lang/phase/X4OPhaseType.java @@ -33,15 +33,9 @@ public enum X4OPhaseType { /** Language init. */ INIT, - /** Read/Write xml.(not used) */ - XML_RW, - /** XML Reading. */ XML_READ, /** XML Writing. */ - XML_WRITE, - - /** XML Schema writing. */ - XML_WRITE_SCHEMA + XML_WRITE; } diff --git a/x4o-driver/src/main/resources/META-INF/eld/eld-lang.eld b/x4o-driver/src/main/resources/META-INF/eld/eld-lang.eld index e0520e2..f00a9be 100644 --- a/x4o-driver/src/main/resources/META-INF/eld/eld-lang.eld +++ b/x4o-driver/src/main/resources/META-INF/eld/eld-lang.eld @@ -52,7 +52,7 @@ id="eld-root" > Single root namespace so xsd schema generation works correct. - + The module root element. The module id. @@ -77,13 +77,13 @@ Some basic language definitions and some helper tags. - + Defines an namespace for the language. The namespace id. - + The xml element. @@ -98,7 +98,7 @@ - + Config element objects by java interface. The interface id. @@ -108,7 +108,7 @@ - + XML Element Attribute tag. diff --git a/x4o-driver/src/test/java/org/x4o/xml/X4ODriverManagerTest.java b/x4o-driver/src/test/java/org/x4o/xml/X4ODriverManagerTest.java index e550e6f..45854ed 100644 --- a/x4o-driver/src/test/java/org/x4o/xml/X4ODriverManagerTest.java +++ b/x4o-driver/src/test/java/org/x4o/xml/X4ODriverManagerTest.java @@ -86,7 +86,7 @@ public class X4ODriverManagerTest extends TestCase { Throwable e = null; try { X4ODriver driver = X4ODriverManager.getX4ODriver(language); - driver.createLanguageContext(version); + driver.createLanguage(version).createLanguageContext(); } catch (Throwable catchE) { e = catchE; } diff --git a/x4o-driver/src/test/java/org/x4o/xml/core/EmptyXmlTest.java b/x4o-driver/src/test/java/org/x4o/xml/core/EmptyXmlTest.java index 76b547d..4ef9db4 100644 --- a/x4o-driver/src/test/java/org/x4o/xml/core/EmptyXmlTest.java +++ b/x4o-driver/src/test/java/org/x4o/xml/core/EmptyXmlTest.java @@ -69,7 +69,7 @@ public class EmptyXmlTest extends TestCase { X4OReader reader = driver.createReader(); try { reader.readResource("tests/empty-xml/empty-test.xml"); - } catch (SAXParseException e) { + } catch (SAXException e) { assertEquals("No ElementNamespaceContext found for empty namespace.", e.getMessage()); return; } diff --git a/x4o-driver/src/test/java/org/x4o/xml/core/NamespaceUriTest.java b/x4o-driver/src/test/java/org/x4o/xml/core/NamespaceUriTest.java index cb7e238..d51d57c 100644 --- a/x4o-driver/src/test/java/org/x4o/xml/core/NamespaceUriTest.java +++ b/x4o-driver/src/test/java/org/x4o/xml/core/NamespaceUriTest.java @@ -22,9 +22,10 @@ */ package org.x4o.xml.core; +import org.x4o.xml.io.DefaultX4OReader; import org.x4o.xml.io.X4OReaderContext; import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguagePropertyKeys; +import org.x4o.xml.lang.phase.X4OPhase; import org.x4o.xml.test.TestDriver; import org.x4o.xml.test.models.TestObjectRoot; @@ -42,7 +43,7 @@ public class NamespaceUriTest extends TestCase { X4OLanguageContext context = null; TestDriver driver = TestDriver.getInstance(); X4OReaderContext reader = driver.createReaderContext(); - reader.setProperty(X4OLanguagePropertyKeys.PHASE_SKIP_RELEASE, true); + reader.addPhaseSkip(X4OPhase.READ_RELEASE); try { context = reader.readResourceContext("tests/namespace/uri-simple.xml"); assertEquals(true,context.getRootElement().getChilderen().size()==1); @@ -55,8 +56,8 @@ public class NamespaceUriTest extends TestCase { X4OLanguageContext context = null; TestDriver driver = TestDriver.getInstance(); X4OReaderContext reader = driver.createReaderContext(); - reader.setProperty(X4OLanguagePropertyKeys.PHASE_SKIP_RELEASE, true); - reader.setProperty(X4OLanguagePropertyKeys.READER_EMPTY_NAMESPACE_URI, "http://test.x4o.org/xml/ns/test-lang"); + reader.addPhaseSkip(X4OPhase.READ_RELEASE); + reader.setProperty(DefaultX4OReader.DOC_EMPTY_NAMESPACE_URI, "http://test.x4o.org/xml/ns/test-lang"); try { context = reader.readResourceContext("tests/namespace/uri-empty.xml"); assertEquals(true,context.getRootElement().getChilderen().size()==1); @@ -69,7 +70,7 @@ public class NamespaceUriTest extends TestCase { X4OLanguageContext context = null; TestDriver driver = TestDriver.getInstance(); X4OReaderContext reader = driver.createReaderContext(); - reader.setProperty(X4OLanguagePropertyKeys.PHASE_SKIP_RELEASE, true); + reader.addPhaseSkip(X4OPhase.READ_RELEASE); try { context = reader.readResourceContext("tests/namespace/uri-schema.xml"); assertEquals(true,context.getRootElement().getChilderen().size()==1); diff --git a/x4o-driver/src/test/java/org/x4o/xml/core/X4ODebugWriterTest.java b/x4o-driver/src/test/java/org/x4o/xml/core/X4ODebugWriterTest.java index 84c115f..6bad78f 100644 --- a/x4o-driver/src/test/java/org/x4o/xml/core/X4ODebugWriterTest.java +++ b/x4o-driver/src/test/java/org/x4o/xml/core/X4ODebugWriterTest.java @@ -23,12 +23,10 @@ package org.x4o.xml.core; import java.io.File; -import java.io.FileOutputStream; import java.io.IOException; import org.x4o.xml.X4ODriver; import org.x4o.xml.io.X4OReader; -import org.x4o.xml.lang.X4OLanguagePropertyKeys; import org.x4o.xml.test.TestDriver; import org.x4o.xml.test.models.TestObjectRoot; @@ -53,7 +51,7 @@ public class X4ODebugWriterTest extends TestCase { File debugFile = createDebugFile(); X4ODriver driver = TestDriver.getInstance(); X4OReader reader = driver.createReader(); - reader.setProperty(X4OLanguagePropertyKeys.DEBUG_OUTPUT_STREAM, new FileOutputStream(debugFile)); + //reader.setProperty(X4OLanguagePropertyKeys.DEBUG_OUTPUT_STREAM, new FileOutputStream(debugFile)); reader.readResource("tests/attributes/test-bean.xml"); assertTrue("Debug file does not exists.",debugFile.exists()); @@ -64,7 +62,7 @@ public class X4ODebugWriterTest extends TestCase { File debugFile = createDebugFile(); X4ODriver driver = TestDriver.getInstance(); X4OReader reader = driver.createReader(); - reader.setProperty(X4OLanguagePropertyKeys.DEBUG_OUTPUT_STREAM, new FileOutputStream(debugFile)); + //reader.setProperty(X4OLanguagePropertyKeys.DEBUG_OUTPUT_STREAM, new FileOutputStream(debugFile)); //reader.setProperty(X4OLanguagePropertyKeys.DEBUG_OUTPUT_ELD_PARSER, true); reader.readResource("tests/attributes/test-bean.xml"); diff --git a/x4o-driver/src/test/java/org/x4o/xml/core/X4OEntityResolverTest.java b/x4o-driver/src/test/java/org/x4o/xml/core/X4OEntityResolverTest.java index 068a1ea..c1faa80 100644 --- a/x4o-driver/src/test/java/org/x4o/xml/core/X4OEntityResolverTest.java +++ b/x4o-driver/src/test/java/org/x4o/xml/core/X4OEntityResolverTest.java @@ -26,9 +26,10 @@ import java.io.IOException; import org.x4o.xml.X4ODriver; import org.x4o.xml.eld.CelDriver; +import org.x4o.xml.io.DefaultX4OReader; import org.x4o.xml.io.sax.X4OEntityResolver; +import org.x4o.xml.io.sax.ext.PropertyConfig; import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguageProperty; import org.x4o.xml.test.TestDriver; import org.x4o.xml.test.models.TestObjectRoot; import org.xml.sax.EntityResolver; @@ -48,7 +49,7 @@ public class X4OEntityResolverTest extends TestCase { public void testElementLangugeNull() throws Exception { Exception e = null; try { - new X4OEntityResolver(null); + new X4OEntityResolver(null,null); } catch (Exception catchE) { e = catchE; } @@ -59,14 +60,14 @@ public class X4OEntityResolverTest extends TestCase { public void testResolve() throws Exception { X4ODriver driver = new CelDriver(); - X4OEntityResolver resolver = new X4OEntityResolver(driver.createLanguageContext()); + X4OEntityResolver resolver = new X4OEntityResolver(driver.createLanguage().createLanguageContext(),DefaultX4OReader.DEFAULT_PROPERTY_CONFIG); InputSource input = resolver.resolveEntity("","http://cel.x4o.org/xml/ns/cel-root-1.0.xsd"); assertNotNull(input); } public void testResolveMissing() throws Exception { X4ODriver driver = new TestDriver(); - X4OEntityResolver resolver = new X4OEntityResolver(driver.createLanguageContext()); + X4OEntityResolver resolver = new X4OEntityResolver(driver.createLanguage().createLanguageContext(),DefaultX4OReader.DEFAULT_PROPERTY_CONFIG); Exception e = null; try { resolver.resolveEntity("","http://cel.x4o.org/xml/ns/cel-root-1.0.xsd-missing-resource"); @@ -80,9 +81,10 @@ public class X4OEntityResolverTest extends TestCase { public void testResolveProperty() throws Exception { X4ODriver driver = new TestDriver(); - X4OLanguageContext language = driver.createLanguageContext(); - language.setLanguageProperty(X4OLanguageProperty.READER_ENTITY_RESOLVER, new TestEntityResolver()); - X4OEntityResolver resolver = new X4OEntityResolver(language); + X4OLanguageContext language = driver.createLanguage().createLanguageContext(); + PropertyConfig conf = new PropertyConfig(DefaultX4OReader.DEFAULT_PROPERTY_CONFIG,PropertyConfig.X4O_PROPERTIES_PREFIX+PropertyConfig.X4O_PROPERTIES_READER); + conf.setProperty(DefaultX4OReader.SAX_ENTITY_RESOLVER, new TestEntityResolver()); + X4OEntityResolver resolver = new X4OEntityResolver(language,conf); Exception e = null; InputSource input = null; try { @@ -96,9 +98,10 @@ public class X4OEntityResolverTest extends TestCase { public void testResolvePropertyNull() throws Exception { X4ODriver driver = new TestDriver(); - X4OLanguageContext language = driver.createLanguageContext(); - language.setLanguageProperty(X4OLanguageProperty.READER_ENTITY_RESOLVER, new TestEntityResolver()); - X4OEntityResolver resolver = new X4OEntityResolver(language); + X4OLanguageContext language = driver.createLanguage().createLanguageContext(); + PropertyConfig conf = new PropertyConfig(DefaultX4OReader.DEFAULT_PROPERTY_CONFIG,PropertyConfig.X4O_PROPERTIES_PREFIX+PropertyConfig.X4O_PROPERTIES_READER); + conf.setProperty(DefaultX4OReader.SAX_ENTITY_RESOLVER, new TestEntityResolver()); + X4OEntityResolver resolver = new X4OEntityResolver(language,conf); Exception e = null; try { resolver.resolveEntity("","http://cel.x4o.org/xml/ns/cel-root-1.0.xsd-null"); diff --git a/x4o-driver/src/test/java/org/x4o/xml/core/X4OParserConfigurationTest.java b/x4o-driver/src/test/java/org/x4o/xml/core/X4OParserConfigurationTest.java index 8d34007..9c77c14 100644 --- a/x4o-driver/src/test/java/org/x4o/xml/core/X4OParserConfigurationTest.java +++ b/x4o-driver/src/test/java/org/x4o/xml/core/X4OParserConfigurationTest.java @@ -43,7 +43,7 @@ public class X4OParserConfigurationTest extends TestCase { public void setUp() throws Exception { driver = TestDriver.getInstance(); - config = driver.createLanguageContext().getLanguage().getLanguageConfiguration(); + config = driver.createLanguage().getLanguageConfiguration(); } public void testParserConfigurationLanguage() { diff --git a/x4o-driver/src/test/java/org/x4o/xml/core/X4OPhaseManagerTest.java b/x4o-driver/src/test/java/org/x4o/xml/core/X4OPhaseManagerTest.java index 3b01e85..c568dcc 100644 --- a/x4o-driver/src/test/java/org/x4o/xml/core/X4OPhaseManagerTest.java +++ b/x4o-driver/src/test/java/org/x4o/xml/core/X4OPhaseManagerTest.java @@ -50,7 +50,7 @@ public class X4OPhaseManagerTest extends TestCase { public void testPhases() throws Exception { TestDriver driver = TestDriver.getInstance(); - X4OLanguageContext context = driver.createLanguageContext(); + X4OLanguageContext context = driver.createLanguage().createLanguageContext(); X4OPhaseManager manager = context.getLanguage().getPhaseManager(); Collection phasesAll = manager.getAllPhases(); List phases = manager.getOrderedPhases(X4OPhaseType.XML_READ); diff --git a/x4o-driver/src/test/java/org/x4o/xml/eld/EldParserTest.java b/x4o-driver/src/test/java/org/x4o/xml/eld/EldParserTest.java index 08643dd..9ab661f 100644 --- a/x4o-driver/src/test/java/org/x4o/xml/eld/EldParserTest.java +++ b/x4o-driver/src/test/java/org/x4o/xml/eld/EldParserTest.java @@ -111,9 +111,8 @@ public class EldParserTest extends TestCase { X4OLanguage language = driver.createLanguage(driver.getLanguageVersionDefault()); X4OLanguageModule mod = new DefaultX4OLanguageModule(); - reader.addELBeanInstance(EldModuleLoader.EL_PARENT_LANGUAGE_CONFIGURATION, language.getLanguageConfiguration()); reader.addELBeanInstance(EldModuleLoader.EL_PARENT_LANGUAGE, language); - reader.addELBeanInstance(EldModuleLoader.EL_PARENT_ELEMENT_LANGUAGE_MODULE, mod); + reader.addELBeanInstance(EldModuleLoader.EL_PARENT_LANGUAGE_MODULE, mod); X4OLanguageModule modNew = reader.readResource("META-INF/test/test-lang.eld"); diff --git a/x4o-driver/src/test/java/org/x4o/xml/eld/EldValidatingTest.java b/x4o-driver/src/test/java/org/x4o/xml/eld/EldValidatingTest.java index 08bb96e..45d8676 100644 --- a/x4o-driver/src/test/java/org/x4o/xml/eld/EldValidatingTest.java +++ b/x4o-driver/src/test/java/org/x4o/xml/eld/EldValidatingTest.java @@ -23,9 +23,8 @@ package org.x4o.xml.eld; import org.x4o.xml.X4ODriver; -import org.x4o.xml.eld.EldDriver; +import org.x4o.xml.io.DefaultX4OReader; import org.x4o.xml.io.X4OReader; -import org.x4o.xml.lang.X4OLanguagePropertyKeys; import org.x4o.xml.test.TestDriver; import org.x4o.xml.test.models.TestObjectRoot; @@ -42,13 +41,12 @@ public class EldValidatingTest extends TestCase { public void testValidation() throws Exception { X4ODriver driver = TestDriver.getInstance(); X4OReader reader = driver.createReader(); - reader.setProperty(X4OLanguagePropertyKeys.PHASE_SKIP_RELEASE, true); - reader.setProperty(X4OLanguagePropertyKeys.READER_VALIDATION_INPUT, true); - //parser.setProperty(X4OLanguagePropertyKeys.VALIDATION_SCHEMA_PATH, "/tmp"); + //reader.getContentConfig().setProperty("",true); + reader.setProperty(DefaultX4OReader.VALIDATION_INPUT_DOC, true); + //parser.setProperty(DefaultX4OReader.VALIDATION_SCHEMA_PATH, "/tmp"); try { // TODO: reader.readResource("META-INF/eld/eld-lang.eld"); } finally { - } } } diff --git a/x4o-driver/src/test/java/org/x4o/xml/io/X4OConnectionTest.java b/x4o-driver/src/test/java/org/x4o/xml/io/X4OConnectionTest.java index 26707fa..3e7ea56 100644 --- a/x4o-driver/src/test/java/org/x4o/xml/io/X4OConnectionTest.java +++ b/x4o-driver/src/test/java/org/x4o/xml/io/X4OConnectionTest.java @@ -24,7 +24,6 @@ package org.x4o.xml.io; import org.x4o.xml.X4ODriver; import org.x4o.xml.io.X4OReader; -import org.x4o.xml.lang.X4OLanguagePropertyKeys; import org.x4o.xml.test.TestDriver; import org.x4o.xml.test.models.TestObjectRoot; @@ -38,19 +37,34 @@ import junit.framework.TestCase; */ public class X4OConnectionTest extends TestCase { - public void testReaderPropertyFail() throws Exception { + public void testReaderPropertyFailRead() throws Exception { Exception e = null; try { X4ODriver driver = TestDriver.getInstance(); X4OReader reader = driver.createReader(); - reader.setProperty(X4OLanguagePropertyKeys.WRITER_OUTPUT_ENCODING, "test"); + reader.getProperty("test"); } catch (Exception catchE) { e = catchE; } assertNotNull("No exception",e); assertEquals("Wrong exception class",IllegalArgumentException.class, e.getClass()); assertTrue("Wrong exception message",e.getMessage().contains("key")); - assertTrue("Wrong exception message",e.getMessage().contains("protected")); + assertTrue("Wrong exception message",e.getMessage().contains("No")); + } + + public void testReaderPropertyFail() throws Exception { + Exception e = null; + try { + X4ODriver driver = TestDriver.getInstance(); + X4OReader reader = driver.createReader(); + reader.setProperty("test", "test"); + } catch (Exception catchE) { + e = catchE; + } + assertNotNull("No exception",e); + assertEquals("Wrong exception class",IllegalArgumentException.class, e.getClass()); + assertTrue("Wrong exception message",e.getMessage().contains("key")); + assertTrue("Wrong exception message",e.getMessage().contains("No")); } public void testWriterPropertyFail() throws Exception { @@ -58,14 +72,14 @@ public class X4OConnectionTest extends TestCase { try { X4ODriver driver = TestDriver.getInstance(); X4OWriter writer = driver.createWriter(); - writer.setProperty(X4OLanguagePropertyKeys.READER_INPUT_ENCODING, "test"); + writer.setProperty("test", "test"); } catch (Exception catchE) { e = catchE; } assertNotNull("No exception",e); assertEquals("Wrong exception class",IllegalArgumentException.class, e.getClass()); assertTrue("Wrong exception message",e.getMessage().contains("key")); - assertTrue("Wrong exception message",e.getMessage().contains("protected")); + assertTrue("Wrong exception message",e.getMessage().contains("No")); } public void testSchemaWriterPropertyFail() throws Exception { @@ -73,13 +87,13 @@ public class X4OConnectionTest extends TestCase { try { X4ODriver driver = TestDriver.getInstance(); X4OSchemaWriter schemaWriter = driver.createSchemaWriter(); - schemaWriter.setProperty(X4OLanguagePropertyKeys.WRITER_OUTPUT_ENCODING, "test"); + schemaWriter.setProperty("test", "test"); } catch (Exception catchE) { e = catchE; } assertNotNull("No exception",e); assertEquals("Wrong exception class",IllegalArgumentException.class, e.getClass()); assertTrue("Wrong exception message",e.getMessage().contains("key")); - assertTrue("Wrong exception message",e.getMessage().contains("protected")); + assertTrue("Wrong exception message",e.getMessage().contains("No")); } } diff --git a/x4o-driver/src/test/java/org/x4o/xml/io/X4OWriterContextTest.java b/x4o-driver/src/test/java/org/x4o/xml/io/X4OWriterContextTest.java index 1efc787..f546bcd 100644 --- a/x4o-driver/src/test/java/org/x4o/xml/io/X4OWriterContextTest.java +++ b/x4o-driver/src/test/java/org/x4o/xml/io/X4OWriterContextTest.java @@ -55,7 +55,7 @@ public class X4OWriterContextTest extends TestCase { X4ODriver driver = TestDriver.getInstance(); X4OReader reader = driver.createReader(); TestObjectRoot root = reader.readResource("tests/attributes/test-bean.xml"); - X4OLanguageContext context = driver.createLanguageContext(); + X4OLanguageContext context = driver.createLanguage().createLanguageContext(); Element rootElement = null; try { rootElement = (Element)context.getLanguage().getLanguageConfiguration().getDefaultElement().newInstance(); diff --git a/x4o-driver/src/test/java/org/x4o/xml/lang/DefaultX4OLanguageLoaderTest.java b/x4o-driver/src/test/java/org/x4o/xml/lang/DefaultX4OLanguageLoaderTest.java index 2a66fe2..501e0a6 100644 --- a/x4o-driver/src/test/java/org/x4o/xml/lang/DefaultX4OLanguageLoaderTest.java +++ b/x4o-driver/src/test/java/org/x4o/xml/lang/DefaultX4OLanguageLoaderTest.java @@ -46,7 +46,7 @@ public class DefaultX4OLanguageLoaderTest extends TestCase { X4ODriver driver = TestDriver.getInstance(); //X4OReader reader = driver.createReader(); //reader.readResource("tests/namespace/uri-simple.xml"); - language = driver.createLanguageContext().getLanguage(); + language = driver.createLanguage(); loader = (X4OLanguageLoader)language.getLanguageConfiguration().getDefaultLanguageLoader().newInstance(); } diff --git a/x4o-driver/src/test/java/org/x4o/xml/lang/X4OLanguagePropertyTest.java b/x4o-driver/src/test/java/org/x4o/xml/lang/X4OLanguagePropertyTest.java index 131e00f..a9cfa9a 100644 --- a/x4o-driver/src/test/java/org/x4o/xml/lang/X4OLanguagePropertyTest.java +++ b/x4o-driver/src/test/java/org/x4o/xml/lang/X4OLanguagePropertyTest.java @@ -22,8 +22,6 @@ */ package org.x4o.xml.lang; -import org.x4o.xml.lang.X4OLanguageProperty; -import org.x4o.xml.lang.X4OLanguagePropertyKeys; import junit.framework.TestCase; @@ -34,7 +32,12 @@ import junit.framework.TestCase; * @version 1.0 Aug 27, 2012 */ public class X4OLanguagePropertyTest extends TestCase { - + + public void testUriValue() throws Exception { + assertEquals(1,1); + } + +/* public void testUriValue() throws Exception { new X4OLanguagePropertyKeys(); X4OLanguageProperty prop = X4OLanguageProperty.valueByUri(X4OLanguagePropertyKeys.LANGUAGE_NAME); @@ -106,4 +109,5 @@ public class X4OLanguagePropertyTest extends TestCase { X4OLanguageProperty elMap = X4OLanguageProperty.valueByUri(X4OLanguagePropertyKeys.EL_BEAN_INSTANCE_MAP); assertEquals(false, elMap.isValueValid("string-object")); } + */ } diff --git a/x4o-driver/src/test/java/org/x4o/xml/test/SwingTests.java b/x4o-driver/src/test/java/org/x4o/xml/test/SwingTests.java index 474cfa5..53908c7 100644 --- a/x4o-driver/src/test/java/org/x4o/xml/test/SwingTests.java +++ b/x4o-driver/src/test/java/org/x4o/xml/test/SwingTests.java @@ -26,7 +26,6 @@ import java.io.File; import java.io.FileOutputStream; import org.x4o.xml.io.X4OReader; -import org.x4o.xml.lang.X4OLanguagePropertyKeys; import org.x4o.xml.test.models.TestObjectRoot; @@ -50,7 +49,7 @@ public class SwingTests extends TestCase { X4OReader reader = driver.createReader(); File f = File.createTempFile("test-swing", ".xml"); //f.deleteOnExit(); - reader.setProperty(X4OLanguagePropertyKeys.DEBUG_OUTPUT_STREAM, new FileOutputStream(f)); + //reader.setProperty(X4OLanguagePropertyKeys.DEBUG_OUTPUT_STREAM, new FileOutputStream(f)); //reader.setProperty(X4OLanguagePropertyKeys.DEBUG_OUTPUT_ELD_PARSER, true); //reader.readResource("tests/test-swing.xml"); //Thread.sleep(30000); diff --git a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterElementClass.java b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterElementClass.java index 930ade5..21e5843 100644 --- a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterElementClass.java +++ b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterElementClass.java @@ -69,12 +69,12 @@ public class EldDocWriterElementClass extends AbstractApiDocWriter { printApiTableBean(event, "Element", "class","id","description"); } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={ElementClass.class},nodeBodyOrders={2},contentGroup="attribute",contentGroupType="summary") + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={ElementClass.class},nodeBodyOrders={2},contentGroup="attribute",contentGroupType="summary") public void writeElementClassAttribute(ApiDocWriteEvent event) throws SAXException { printApiTable(event,"Element Class Attribute Summary",ElementClassAttribute.class); } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={ElementClass.class},nodeBodyOrders={3},contentGroup="configurator",contentGroupType="summary") + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={ElementClass.class},nodeBodyOrders={3},contentGroup="configurator",contentGroupType="summary") public void writeElementConfigurator(ApiDocWriteEvent event) throws SAXException { printApiTable(event,"Element Configurator Summary",ElementConfigurator.class); } diff --git a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterElementInterface.java b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterElementInterface.java index ead36bd..78ea050 100644 --- a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterElementInterface.java +++ b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterElementInterface.java @@ -52,22 +52,22 @@ public class EldDocWriterElementInterface extends AbstractApiDocWriter { } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={ElementInterface.class},nodeBodyOrders={1},contentGroup="interface",contentGroupType="summary") + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={ElementInterface.class},nodeBodyOrders={1},contentGroup="interface",contentGroupType="summary") public void writeElementNamespaceBeanProperties(ApiDocWriteEvent event) throws SAXException { printApiTableBean(event,"Interface","description"); } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={ElementInterface.class},nodeBodyOrders={2},contentGroup="attribute",contentGroupType="summary") + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={ElementInterface.class},nodeBodyOrders={2},contentGroup="attribute",contentGroupType="summary") public void writeElementClassAttribute(ApiDocWriteEvent event) throws SAXException { printApiTable(event,"Element Class Attribute Summary",ElementClassAttribute.class); } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={ElementInterface.class},nodeBodyOrders={3},contentGroup="binding",contentGroupType="summary") + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={ElementInterface.class},nodeBodyOrders={3},contentGroup="binding",contentGroupType="summary") public void writeElementBindingHandler(ApiDocWriteEvent event) throws SAXException { printApiTable(event,"Element Binding Handler Summary",ElementBindingHandler.class); } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={ElementInterface.class},nodeBodyOrders={4},contentGroup="configurator",contentGroupType="summary") + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={ElementInterface.class},nodeBodyOrders={4},contentGroup="configurator",contentGroupType="summary") public void writeElementConfigurator(ApiDocWriteEvent event) throws SAXException { printApiTable(event,"Element Configurator Summary",ElementConfigurator.class); } diff --git a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterElementNamespace.java b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterElementNamespace.java index 05472ca..21e9479 100644 --- a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterElementNamespace.java +++ b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterElementNamespace.java @@ -47,12 +47,12 @@ public class EldDocWriterElementNamespace extends AbstractApiDocWriter { clearHrefContentGroup(doc,node,"summary","element",ElementClass.class); } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={ElementNamespaceContext.class},nodeBodyOrders={1},contentGroup="namespace",contentGroupType="summary") + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={ElementNamespaceContext.class},nodeBodyOrders={1},contentGroup="namespace",contentGroupType="summary") public void writeElementNamespaceBeanProperties(ApiDocWriteEvent event) throws SAXException { printApiTableBean(event,"Namespace","description","elementClasses","elementNamespaceInstanceProvider","prefixMapping"); } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={ElementNamespaceContext.class},nodeBodyOrders={2},contentGroup="element",contentGroupType="summary") + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={ElementNamespaceContext.class},nodeBodyOrders={2},contentGroup="element",contentGroupType="summary") public void writeElementNamespaceElements(ApiDocWriteEvent event) throws SAXException { printApiTable(event,"Element Summary",ElementClass.class); } diff --git a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterLanguage.java b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterLanguage.java index febbafe..0b3aa5c 100644 --- a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterLanguage.java +++ b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterLanguage.java @@ -64,7 +64,7 @@ public class EldDocWriterLanguage extends AbstractApiDocWriter { } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={X4OLanguageContext.class},nodeBodyOrders={1}) + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={X4OLanguageContext.class},nodeBodyOrders={1}) public void writeLanguageSummary(ApiDocWriteEvent event) throws SAXException { ApiDocContentWriter writer = event.getWriter(); ApiDocNode node = event.getEventObject(); @@ -99,12 +99,12 @@ public class EldDocWriterLanguage extends AbstractApiDocWriter { writer.docTableEnd(); } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={X4OLanguageContext.class},nodeBodyOrders={2}) + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={X4OLanguageContext.class},nodeBodyOrders={2}) public void writeModulesSummary(ApiDocWriteEvent event) throws SAXException { printApiTable(event,"Module Summary",X4OLanguageModule.class); } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={X4OLanguageContext.class},nodeBodyOrders={3}) + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={X4OLanguageContext.class},nodeBodyOrders={3}) public void writeNamespaceSummary(ApiDocWriteEvent event) throws SAXException { ApiDocContentWriter writer = event.getWriter(); ApiDocNode node = event.getEventObject(); diff --git a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterLanguageModule.java b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterLanguageModule.java index e3627ea..80bf25d 100644 --- a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterLanguageModule.java +++ b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/EldDocWriterLanguageModule.java @@ -55,27 +55,27 @@ public class EldDocWriterLanguageModule extends AbstractApiDocWriter { clearHrefContentGroup(doc,node,"summary","namespace",ElementNamespaceContext.class); } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={X4OLanguageModule.class},nodeBodyOrders={1},contentGroup="interface",contentGroupType="summary") + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={X4OLanguageModule.class},nodeBodyOrders={1},contentGroup="interface",contentGroupType="summary") public void writeInterfaceSummary(ApiDocWriteEvent event) throws SAXException { printApiTable(event,"Interface Summary",ElementInterface.class); } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={X4OLanguageModule.class},nodeBodyOrders={2},contentGroup="binding",contentGroupType="summary") + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={X4OLanguageModule.class},nodeBodyOrders={2},contentGroup="binding",contentGroupType="summary") public void writeBindingSummary(ApiDocWriteEvent event) throws SAXException { printApiTable(event,"Binding Summary",ElementBindingHandler.class); } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={X4OLanguageModule.class},nodeBodyOrders={3},contentGroup="attribute",contentGroupType="summary") + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={X4OLanguageModule.class},nodeBodyOrders={3},contentGroup="attribute",contentGroupType="summary") public void writeAttributeSummary(ApiDocWriteEvent event) throws SAXException { printApiTable(event,"Attribute Summary",ElementAttributeHandler.class); } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={X4OLanguageModule.class},nodeBodyOrders={4},contentGroup="configurator",contentGroupType="summary") + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={X4OLanguageModule.class},nodeBodyOrders={4},contentGroup="configurator",contentGroupType="summary") public void writeConfigutorSummary(ApiDocWriteEvent event) throws SAXException { printApiTable(event,"Configurator Summary",ElementConfigurator.class); } - @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY_PAGE,targetClasses={X4OLanguageModule.class},nodeBodyOrders={5},contentGroup="namespace",contentGroupType="summary") + @ApiDocNodeWriterMethod(nodeBody=ApiDocNodeBody.SUMMARY,targetClasses={X4OLanguageModule.class},nodeBodyOrders={5},contentGroup="namespace",contentGroupType="summary") public void writeNamespaceSummary(ApiDocWriteEvent event) throws SAXException { printApiTable(event,"Namespace Summary",ElementNamespaceContext.class); } diff --git a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/X4OWriteLanguageDocExecutor.java b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/X4OWriteLanguageDocExecutor.java index d5a3a2a..18a5431 100644 --- a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/X4OWriteLanguageDocExecutor.java +++ b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/X4OWriteLanguageDocExecutor.java @@ -95,7 +95,7 @@ public class X4OWriteLanguageDocExecutor { */ public void execute() throws ElementException { X4ODriver driver = X4ODriverManager.getX4ODriver(getLanguageName()); - X4OLanguageContext context = driver.createLanguageContext(getLanguageVersion()); + X4OLanguageContext context = driver.createLanguage(getLanguageVersion()).createLanguageContext(); // Run doc writer EldDocWriter docWriter = new EldDocWriter(context); diff --git a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/api/ApiDocContentWriter.java b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/api/ApiDocContentWriter.java index 724340d..667a41d 100644 --- a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/api/ApiDocContentWriter.java +++ b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/api/ApiDocContentWriter.java @@ -40,8 +40,8 @@ public class ApiDocContentWriter extends ContentWriterHtml { private boolean isAltRow = true; - public ApiDocContentWriter(Writer out,String encoding,String charNewLine,String charTab) { - super(out,encoding,charNewLine,charTab); + public ApiDocContentWriter(Writer out,String encoding) { + super(out,encoding); } public void docCommentGenerated() throws SAXException { diff --git a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/api/ApiDocWriter.java b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/api/ApiDocWriter.java index 5e79f53..777c689 100644 --- a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/api/ApiDocWriter.java +++ b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/api/ApiDocWriter.java @@ -172,8 +172,7 @@ public class ApiDocWriter extends AbstractApiDocWriter { writeNodeTreePath(bodyEvent); } writeNodeDescription(bodyEvent,isNodePageMode); - writeNodeSummary(bodyEvent,true); // print without div and block lists - writeNodeSummary(bodyEvent,false); + writeNodeSummary(bodyEvent,isNodePageMode); writeNodeDetails(bodyEvent); writer.docPageContentEnd(); writer.docPageClassEnd(); @@ -240,35 +239,28 @@ public class ApiDocWriter extends AbstractApiDocWriter { writer.printTagEnd(Tag.div); // description } - private void writeNodeSummary(ApiDocWriteEvent event,boolean isPage) throws SAXException { + private void writeNodeSummary(ApiDocWriteEvent event,boolean isPageMode) throws SAXException { ApiDocContentWriter writer = event.getWriter(); - List bodyWriterSummary = null; - List bodyWriterSummaryPage = findNodeBodyWriters(event.getEventObject(),ApiDocNodeBody.SUMMARY_PAGE); - List bodyWriterSummaryNormal = findNodeBodyWriters(event.getEventObject(),ApiDocNodeBody.SUMMARY); - if (isPage) { - bodyWriterSummary = bodyWriterSummaryPage; - } else { - bodyWriterSummary = bodyWriterSummaryNormal; - } - if (!isPage) { + List bodyWriterSummary = findNodeBodyWriters(event.getEventObject(),ApiDocNodeBody.SUMMARY); + if (!isPageMode) { writer.printTagStart(Tag.div, ApiDocContentCss.summary); writer.docPageBlockStart(); } - if (bodyWriterSummary.isEmpty() && !isPage && bodyWriterSummaryPage.isEmpty()) { - writer.docPageBlockStart(); + if (bodyWriterSummary.isEmpty() && event.getEventObject().getNodes().isEmpty()==false) { + if (!isPageMode) { writer.docPageBlockStart(); } defaultWriteSummary(event.getEventObject(),writer); - writer.docPageBlockEnd(); + if (!isPageMode) { writer.docPageBlockEnd(); } } for (int i=0;i nodes = null; - private Map contentGroupTypes = null; public ApiDocNode() { nodes = new ArrayList(30); - contentGroupTypes = new HashMap(3); } public ApiDocNode(Object userData,String id,String name,String description) { @@ -74,22 +69,6 @@ public class ApiDocNode { return nodes; } - public void addContentGroupType(String id,String name) { - contentGroupTypes.put(id, name); - } - - public void removeContentGroupType(String id) { - contentGroupTypes.remove(id); - } - - public String getContentGroupTypeName(String id) { - return contentGroupTypes.get(id); - } - - public Set getContentGroupTypeKeys() { - return contentGroupTypes.keySet(); - } - /** * @return the userData */ @@ -104,8 +83,6 @@ public class ApiDocNode { this.userData = userData; } - - /** * @return the id */ diff --git a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/api/dom/ApiDocNodeBody.java b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/api/dom/ApiDocNodeBody.java index a2214e8..7f98803 100644 --- a/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/api/dom/ApiDocNodeBody.java +++ b/x4o-eld-doc/src/main/java/org/x4o/xml/eld/doc/api/dom/ApiDocNodeBody.java @@ -34,10 +34,5 @@ public enum ApiDocNodeBody { DESCRIPTION_LINKS, DESCRIPTION_NODE, SUMMARY, - DETAIL, - - /** - * Summary page blocks had no div and no block lists around content. - */ - SUMMARY_PAGE + DETAIL } diff --git a/x4o-meta/src/test/java/org/x4o/xml/lang/meta/ParentObjectTest.java b/x4o-meta/src/test/java/org/x4o/xml/lang/meta/ParentObjectTest.java index b8c8da0..1d41eea 100644 --- a/x4o-meta/src/test/java/org/x4o/xml/lang/meta/ParentObjectTest.java +++ b/x4o-meta/src/test/java/org/x4o/xml/lang/meta/ParentObjectTest.java @@ -28,7 +28,7 @@ import org.x4o.xml.element.DefaultElement; import org.x4o.xml.element.Element; import org.x4o.xml.io.X4OReaderContext; import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguagePropertyKeys; +import org.x4o.xml.lang.phase.X4OPhase; import junit.framework.TestCase; @@ -44,7 +44,7 @@ public class ParentObjectTest extends TestCase { X4OLanguageContext context = null; MTestDriver driver = new MTestDriver(); X4OReaderContext reader = driver.createReaderContext(); - reader.setProperty(X4OLanguagePropertyKeys.PHASE_SKIP_RELEASE, true); + reader.addPhaseSkip(X4OPhase.READ_RELEASE); try { context = reader.readResourceContext("junit/test-meta-parent-element.xml"); assertEquals(1,context.getRootElement().getChilderen().size()); diff --git a/x4o-meta/src/test/java/org/x4o/xml/lang/meta/ReferenceStoreTest.java b/x4o-meta/src/test/java/org/x4o/xml/lang/meta/ReferenceStoreTest.java index 8b73420..ae4f07e 100644 --- a/x4o-meta/src/test/java/org/x4o/xml/lang/meta/ReferenceStoreTest.java +++ b/x4o-meta/src/test/java/org/x4o/xml/lang/meta/ReferenceStoreTest.java @@ -26,7 +26,7 @@ import java.util.Date; import org.x4o.xml.io.X4OReaderContext; import org.x4o.xml.lang.X4OLanguageContext; -import org.x4o.xml.lang.X4OLanguagePropertyKeys; +import org.x4o.xml.lang.phase.X4OPhase; import junit.framework.TestCase; @@ -42,7 +42,7 @@ public class ReferenceStoreTest extends TestCase { X4OLanguageContext context = null; MTestDriver driver = new MTestDriver(); X4OReaderContext reader = driver.createReaderContext(); - reader.setProperty(X4OLanguagePropertyKeys.PHASE_SKIP_RELEASE, true); + reader.addPhaseSkip(X4OPhase.READ_RELEASE); try { context = reader.readResourceContext("junit/test-meta-generic.xml"); assertEquals(Date.class.getName(),context.getRootElement().getChilderen().get(0).getElementObject().getClass().getName()); @@ -55,7 +55,7 @@ public class ReferenceStoreTest extends TestCase { X4OLanguageContext context = null; MTestDriver driver = new MTestDriver(); X4OReaderContext reader = driver.createReaderContext(); - reader.setProperty(X4OLanguagePropertyKeys.PHASE_SKIP_RELEASE, true); + reader.addPhaseSkip(X4OPhase.READ_RELEASE); try { context = reader.readResourceContext("junit/test-meta-reference.xml"); assertEquals(Date.class.getName(),context.getRootElement().getChilderen().get(0).getElementObject().getClass().getName()); @@ -68,7 +68,7 @@ public class ReferenceStoreTest extends TestCase { X4OLanguageContext context = null; MTestDriver driver = new MTestDriver(); X4OReaderContext reader = driver.createReaderContext(); - reader.setProperty(X4OLanguagePropertyKeys.PHASE_SKIP_RELEASE, true); + reader.addPhaseSkip(X4OPhase.READ_RELEASE); try { context = reader.readResourceContext("junit/test-meta-reference.xml"); assertEquals(Date.class.getName(),context.getRootElement().getChilderen().get(0).getElementObject().getClass().getName());